Is there a portable wrapper for C++ type_info that standardizes type name string format?

Question

The format of the output of type_info::name() is implementation specific.

namespace N { struct A; }

const N::A *a;

typeid(a).name(); // returns e.g. "const struct N::A" but compiler-specific

Has anyone written a wrapper that returns dependable, predictable type information that is the same across compilers. Multiple templated functions would allow user to get specific information about a type. So I might be able to use:

MyTypeInfo::name(a); // returns "const struct N::A *"
MyTypeInfo::base(a); // returns "A"
MyTypeInfo::pointer(a); // returns "*"
MyTypeInfo::nameSpace(a); // returns "N"
MyTypeInfo::cv(a); // returns "const"

These functions are just examples, someone with better knowledge of the C++ type system could probably design a better API. The one I'm interested in in base(). All functions would raise an exception if RTTI was disabled or an unsupported compiler was detected.

This seems like the sort of thing that Boost might implement, but I can't find it in there anywhere. Is there a portable library that does this?

Rawden

I'm not aware of anything, but it sounds like it would be a good idea. (Formally, the standard allows an implementation to return "" for all types, but practically, most implementations return something directly usable, and the ones that don't return the mangled name, which can be demangled.) – Accent

The only issue I can see is that the string is completely implementation specific, and by no mean guaranteed to faithfully represent the type itself. Even worse, it might not even be unique. – Frisk

@Matthieu - library detects such compilers and the call fails. Caller has to live with it. The compilers most of us use give useful information in type_info. – Rawden

possible duplicate of Why does typeid.name() return weird characters using GCC and how to make it print unmangled names? – Niddering

Answer 1

There are some limitations to do such things in C++, so you probably won't find exactly what you want in the near future. The meta-information about the types that the compiler inserts in the compiled code is also implementation-specific to the RTL used by the compiler, so it'd be difficult for a third-party library to do a good job without relying to undocumented features of each specific compiler that might break in later versions.

The Qt framework has, to my knowledge, the nearest thing to what you intended. But they do that completely independent from RTTI. Instead, they have their own "compiler" that parses the source code and generates additional source modules with the meta-information. Then, you compile+link these modules along with your program and use their API to get the information. Take a look at http://doc.qt.nokia.com/latest/metaobjects.html

Hangnail

I don't see much of a problem. Having something which works at least with some compilers is better than nothing, imho. – Kiefer

I think this can be made robust on all compilers because self tests are trivial with low runtime overhead. – Rawden

Answer 2

Jeremy Pack (from Boost Extension plugin framework) appears to have written such a thing:

http://blog.redshoelace.com/2009/06/resource-management-across-dll.html

 3. RTTI does not always function as expected across DLL boundaries. Check out the type_info classes to see how I deal with that.

So you could have a look there.

---

PS. I remembered because I once fixed a bug in that area; this might still add information so here's the link: https://mcmap.net/q/266463/-boost-extension-simple-inheritance-sample-why-we-see-no-animals-on-linux

Fiend

I'm not sure this does quite what I'm asking - I'm interested in the actual type name string, not comparing types. – Rawden

Answer 3

GCC has __cxa_demangle https://gcc.gnu.org/onlinedocs/libstdc++/manual/ext_demangling.html

If there are such extensions for all compilers you target, you could use them to write a portable function with macros to detect the compiler.

Niddering