Inspecting Type and Value Info at C++ Compile Time

Templates can be used to smuggle out compile-time information via error messaging, and you can do this for type, size and alignment information regardless of your development environment.

Since this leverages the build tooling, this works in a variety of development environments, from VIM on a remote Linux server, to Windows with Visual Studio. It also works with types in templates, wrapped in multiple using, stringified together with ##, and with multiple macro layers like handle types, where IDEs can get confused.

Inspecting Types

The idea is that you generate an error which results in the error messaging being embedded in the type information for a template. This works with MSVC, Clang, and G++.

template <typename... T> struct InspectType;

This is an incomplete type. This means when you try to make a value of that type, you get an error at compile time.

Here's a simple example:

InspectType<decltype(5 * 100ul)> expr;

This gives a reasonable message with the type at compile time. Even if you're deep in a change which doesn't build yet, you can still get type information for auto variables, template types, and expressions.

D:\dev\cpp\inspector\main.cpp(49): error C2079: 'expr' uses undefined struct 'InspectType<unsigned long>'

What you're looking for is that response nestled as the template parameter in InspectType<...>: unsigned long.

When Compiler Messages are too Helpful

C++ compilers have been working on improving messages and sometimes the messages are a bit too helpful. This is possible when dealing with templates hidden behind a type alias.

std::string a; InspectTypes<std::string> it1; InspectTypes<decltype(a)> it2;

std::string is a bit more complicated than MSVC leads on here:

D:\dev\cpp\inspector\main.cpp(88): error C2079: 'it1' uses undefined struct 'InspectTypes<std::string>' D:\dev\cpp\inspector\main.cpp(89): error C2079: 'it2' uses undefined struct 'InspectTypes<std::string>'

Clang provides a bit more info, but not the entire story as well:

$ clang++ main.cpp --std=c++20 main.cpp:88:29: error: implicit instantiation of undefined template 'InspectTypes<std::basic_string<char>>' InspectTypes<std::string> it1; ^

Usually, this sort of shorter, more direct messaging is exactly what we want! However, when debugging sometimes we want to see the whole lot of information.

Inspection can be delayed until linking with this gadget:

template<typename T> struct Inspector { static void type(); };

This produces a spammier and more difficult to read message, but it works as a fallback when IDEs and other methods fail. What happens here is the template declares a function and because there's not one implemented, the linker will generate an error with the type information.

MSVC:

main.cpp.obj : error LNK2019: unresolved external symbol "public: static void __cdecl Inspector<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >::type(void)" (?type@?$Inspector@V?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@@SAXXZ) referenced in function main

Hidden in this is our type: class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >.

Clang:

$ clang++ main.cpp --std=c++20 /usr/bin/ld: /tmp/main-725aec.o: in function `main': main.cpp:(.text+0x85): undefined reference to `Inspector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >::type()'

Hidden in this is our type std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >.

It's not a preferred way to go about getting this information, but it's available when other methods fail.

Value inspection

Using non-type template parameters, you can use incomplete types to also see compile-time values.

template<int... V> struct InspectValues;

This allows seeing size and alignment info and prevents the need to guess, such as when setting up static_asserts to verify type sizes or when rearranging fields to reduce padding.

InspectValues<sizeof(Foo), alignof(Foo)> ivi;

With MSVC this gives the message:

D:\dev\cpp\inspector\main.cpp(66): error C2079: 'ivi' uses undefined struct 'InspectValues<16,8>'

And for Clang:

main.cpp:67:43: error: implicit instantiation of undefined template 'InspectValues<16, 8>' InspectValues<sizeof(Foo), alignof(Foo)> ivi;

G++ has a similar message:

main.cpp: In function ‘int main()’: main.cpp:67:50: error: aggregate ‘InspectValues<16, 8> ivi’ has incomplete type and cannot be defined 67 | InspectValues<sizeof(Foo), alignof(Foo)> ivi;

IDE support

This is a fallback method for me when IDE methods fail.

Visual Studio and CLion both report size info for me when hovering a type. Visual Studio also shows alignment and has a "Memory Layout" view to see even more in-depth information and padding gaps in your types.

Example memory layout showing a padding gap
Example memory layout showing a padding gap

Other Methods

MSVC, at compile time

With MSVC, you can use this more simple approach, though it doesn't work with Clang or G++:

template <typename T> void printType() { static_assert(false, __FUNCSIG__); }

Then inside code:

printType<std::string>();

The result here is also very direct:

D:\dev\cpp\inspector\main.cpp(41): error C2338: static_assert failed: 'void __cdecl printType<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >>(void)'

At runtime, MSVC, Clang or G++

If you can wait until runtime, you can use this function:

template<typename T> void runtimePrintType() { #if _MSC_VER std::cout << __FUNCSIG__ << '\n'; #else std::cout << __PRETTY_FUNCTION__ << '\n'; #endif }

MSVC:

void __cdecl runtimePrintType<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >>(v oid)

Clang:

void runtimePrintType() [T = std::basic_string<char>]

G++:

void runtimePrintType() [with T = std::__cxx11::basic_string<char>]