Type info

without RTTI

C++ RTTI

why even bother to disable it?

• compiler specific cost
  • might need more control
• embedded software
  • every byte of binary counts
• make execution less predictable
  • dynamic_cast might fail
• might not need the full package
  • just typeinfo, no dynamic_cast

• But sometimes typeinfo is useful
  • safe up-casting
  • simplified class interface
  • accept all methods

Example program

struct message {
    /*typeinfo*/ type;
    void* ptr;
};

void accept_message(const message& m) {
    if (m.type == /* some class */) {
       // do stuff
    } else {
       // do 
    }
}

Type info v1 - template instantiation

namespace type {                        

extern std::atomic<uint32_t> type_counter;

struct info {
    uint32_t    id;

    bool operator== (const info& other) const {return id == other.id;}
    bool operator!= (const info& other) const {return id != other.id;}
};

template <class ValueType>
const info& get_type() {
    static info info = {std::atomic_fetch_add(&type_counter, (uint32_t)1)};
    return info;
}

• Example usage

struct A {};
struct B {};

struct message {
    const type::info& type;
    void* ptr;

    template <class T>
    message(T* t) : type(type::get_type<T>()), ptr(t) {
    }
};

void accept_message(const message& m) {
    if (m.type == type::get_type<A>()) {
        printf("Got A class\n");
    } else {
        printf("Oops, got ??\n");
    }
}

int main(int argc, char* argv[]) {
    A a;
    B b;

    accept_message(message(&a));
    accept_message(message(&b));
}

• Let's run the test app

[maciek@pc type_info]$ ./test 
Got A class
Oops, got ??

Type info v1 - summary

• every template method instantiation produces new static variable
• info::id unique for every type
• pros
  • simple and short
• cons
  • atomics cost
  • static guard locks cost
  • no name string support

Type info v2 - support for type names

namespace type {                        

extern std::atomic<uint32_t> type_counter;

struct info {
    const char* name;
    uint32_t    id;

    bool operator== (const info& other) const {return id == other.id;}
    bool operator!= (const info& other) const {return id != other.id;}
};

template <class ValueType>
const info& get_type(const char* name="<type unnamed>") {
    static info info = {name, std::atomic_fetch_add(&type_counter, 1)};
    return info;
}

• Example usage

struct A {};
struct B {};

void accept_message(const message& m) {
    if (m.type == type::get_type<A>()) {
        printf("Got A class\n");
    } else {
        printf("Oops, got %s\n", m.type.name);
    }
}

const type::info infoA = type::get_type<A>("<A class>");
const type::info infoB = type::get_type<B>("<B class>");

int main(int argc, char* argv[]) {
    A a;
    B b;

    accept_message(message(&a));
    accept_message(message(&b));
}

• Let's run the test app

[maciek@pc type_info]$ ./test 
Got A class
Oops, got <B class>

Type info v2 - summary

• Same as type info v1 but
• pros
  • supports type name strings
• cons
  • each type has to by registered for name support
  • still atomics / guards

Type info v3 - no atomics

struct info {
    const char* name;

    bool operator== (const info& other) const {return this == &other;}
    bool operator!= (const info& other) const {return this != &other;}
};

template <class ValueType>
const info& get_type(const char* name="<type unnamed>") {
    static info info {name};
    return info;
}

• no atomics needed
• address of static variable becomes id
• ... but still cost of static lock guards

[maciek@pc type_info]$ objdump -tC ./a.out | grep "guard var" | cut -f2-3
   guard variable for type::info const& type::get_type<A>(char const*)::info
   guard variable for type::info const& type::get_type<B>(char const*)::info

Type info v4 - no locks

struct info {
    std::string name;

    info(const char* name) : name(name) {};
    info(const info&) = delete;

    bool operator== (const info& other) const {return this == &other;}
    bool operator!= (const info& other) const {return this != &other;}
};

template <class T>
struct info_class {
    static info type_info;
};

template <class T>
info info_class<T>::type_info("<type unnamed>");

template <class ValueType>
const info& get_type() {
    return info_class<ValueType>::type_info;
}

template <class ValueType>
const info& get_type(const char* name) {
    info& i = info_class<ValueType>::type_info;
    i.name = name;
    return i;
}

• Example usage

struct A {};
struct B {};

void accept_message(const message& m) {
    if (m.type == type::get_type<A>()) {
        printf("Got A class\n");
    } else {
        printf("Oops, got %s\n", m.type.name);
    }
}

int main(int argc, char* argv[]) {
   const type::info infoA = type::get_type<A>("<A class>");
   const type::info infoB = type::get_type<B>("<B class>");

    A a;
    B b;

    accept_message(message(&a));
    accept_message(message(&b));
}

Type info v4 - summary

• static member instead of static in function
• pros
  • no locks - type initialized during static init
• cons
  • order of globals init from different compilation units
    • can't correct name in static init
    • name correction only in function

Type info - summary

• Can replace typeinfo from RTTI for some cases
• Comes with some small trade-offs
• More control over binary size and runtime cost
• Other alternatives
  • boost::any - uses RTTI, gives access to typeinfo
  • std::any - RTTI needed only for typeinfo support

Thank you