Is it possible to print a variable's type in standard C++?

Question

For example:

int a = 12;
cout << typeof(a) << endl;

Expected output:

int

user_576911 · Answer

C++11 update to a very old question: Print variable type in C++.

The accepted (and good) answer is to use typeid(a).name(), where a is a variable name.

Now in C++11 we have decltype(x), which can turn an expression into a type. And decltype() comes with its own set of very interesting rules. For example decltype(a) and decltype((a)) will generally be different types (and for good and understandable reasons once those reasons are exposed).

Will our trusty typeid(a).name() help us explore this brave new world?

No.

But the tool that will is not that complicated. And it is that tool which I am using as an answer to this question. I will compare and contrast this new tool to typeid(a).name(). And this new tool is actually built on top of typeid(a).name().

The fundamental issue:

typeid(a).name()

throws away cv-qualifiers, references, and lvalue/rvalue-ness. For example:

const int ci = 0;
std::cout << typeid(ci).name() << '
';

For me outputs:

and I'm guessing on MSVC outputs:

int

I.e. the const is gone. This is not a QOI (Quality Of Implementation) issue. The standard mandates this behavior.

What I'm recommending below is:

template  std::string type_name();

which would be used like this:

const int ci = 0;
std::cout << type_name() << '
';

and for me outputs:

int const

I have not tested this on MSVC. But I welcome feedback from those who do.

The C++11 Solution

I am using __cxa_demangle for non-MSVC platforms as recommend by ipapadop in his answer to demangle types. But on MSVC I'm trusting typeid to demangle names (untested). And this core is wrapped around some simple testing that detects, restores and reports cv-qualifiers and references to the input type.

#include 
#include 
#ifndef _MSC_VER
#   include 
#endif
#include 
#include 
#include 

template 
std::string
type_name()
{
    typedef typename std::remove_reference::type TR;
    std::unique_ptr own
           (
#ifndef _MSC_VER
                abi::__cxa_demangle(typeid(TR).name(), nullptr,
                                           nullptr, nullptr),
#else
                nullptr,
#endif
                std::free
           );
    std::string r = own != nullptr ? own.get() : typeid(TR).name();
    if (std::is_const::value)
        r += " const";
    if (std::is_volatile::value)
        r += " volatile";
    if (std::is_lvalue_reference::value)
        r += "&";
    else if (std::is_rvalue_reference::value)
        r += "&&";
    return r;
}

The Results

With this solution I can do this:

int& foo_lref();
int&& foo_rref();
int foo_value();

int
main()
{
    int i = 0;
    const int ci = 0;
    std::cout << "decltype(i) is " << type_name() << '
';
    std::cout << "decltype((i)) is " << type_name() << '
';
    std::cout << "decltype(ci) is " << type_name() << '
';
    std::cout << "decltype((ci)) is " << type_name() << '
';
    std::cout << "decltype(static_cast(i)) is " << type_name(i))>() << '
';
    std::cout << "decltype(static_cast(i)) is " << type_name(i))>() << '
';
    std::cout << "decltype(static_cast(i)) is " << type_name(i))>() << '
';
    std::cout << "decltype(foo_lref()) is " << type_name() << '
';
    std::cout << "decltype(foo_rref()) is " << type_name() << '
';
    std::cout << "decltype(foo_value()) is " << type_name() << '
';
}

and the output is:

decltype(i) is int
decltype((i)) is int&
decltype(ci) is int const
decltype((ci)) is int const&
decltype(static_cast(i)) is int&
decltype(static_cast(i)) is int&&
decltype(static_cast(i)) is int
decltype(foo_lref()) is int&
decltype(foo_rref()) is int&&
decltype(foo_value()) is int

Note (for example) the difference between decltype(i) and decltype((i)). The former is the type of the declaration of i. The latter is the "type" of the expression i. (expressions never have reference type, but as a convention decltype represents lvalue expressions with lvalue references).

Thus this tool is an excellent vehicle just to learn about decltype, in addition to exploring and debugging your own code.

In contrast, if I were to build this just on typeid(a).name(), without adding back lost cv-qualifiers or references, the output would be:

decltype(i) is int
decltype((i)) is int
decltype(ci) is int
decltype((ci)) is int
decltype(static_cast(i)) is int
decltype(static_cast(i)) is int
decltype(static_cast(i)) is int
decltype(foo_lref()) is int
decltype(foo_rref()) is int
decltype(foo_value()) is int

I.e. Every reference and cv-qualifier is stripped off.

C++14 Update

Just when you think you've got a solution to a problem nailed, someone always comes out of nowhere and shows you a much better way. :-)

This answer from Jamboree shows how to get the type name in C++14 at compile time. It is a brilliant solution for a couple reasons:

It's at compile time!
You get the compiler itself to do the job instead of a library (even a std::lib). This means more accurate results for the latest language features (like lambdas).

Jamboree's answer doesn't quite lay everything out for VS, and I'm tweaking his code a little bit. But since this answer gets a lot of views, take some time to go over there and upvote his answer, without which, this update would never have happened.

#include 
#include 
#include 
#include 

#ifndef _MSC_VER
#  if __cplusplus < 201103
#    define CONSTEXPR11_TN
#    define CONSTEXPR14_TN
#    define NOEXCEPT_TN
#  elif __cplusplus < 201402
#    define CONSTEXPR11_TN constexpr
#    define CONSTEXPR14_TN
#    define NOEXCEPT_TN noexcept
#  else
#    define CONSTEXPR11_TN constexpr
#    define CONSTEXPR14_TN constexpr
#    define NOEXCEPT_TN noexcept
#  endif
#else  // _MSC_VER
#  if _MSC_VER < 1900
#    define CONSTEXPR11_TN
#    define CONSTEXPR14_TN
#    define NOEXCEPT_TN
#  elif _MSC_VER < 2000
#    define CONSTEXPR11_TN constexpr
#    define CONSTEXPR14_TN
#    define NOEXCEPT_TN noexcept
#  else
#    define CONSTEXPR11_TN constexpr
#    define CONSTEXPR14_TN constexpr
#    define NOEXCEPT_TN noexcept
#  endif
#endif  // _MSC_VER

class static_string
{
    const char* const p_;
    const std::size_t sz_;

public:
    typedef const char* const_iterator;

    template 
    CONSTEXPR11_TN static_string(const char(&a)[N]) NOEXCEPT_TN
        : p_(a)
        , sz_(N-1)
        {}

    CONSTEXPR11_TN static_string(const char* p, std::size_t N) NOEXCEPT_TN
        : p_(p)
        , sz_(N)
        {}

    CONSTEXPR11_TN const char* data() const NOEXCEPT_TN {return p_;}
    CONSTEXPR11_TN std::size_t size() const NOEXCEPT_TN {return sz_;}

    CONSTEXPR11_TN const_iterator begin() const NOEXCEPT_TN {return p_;}
    CONSTEXPR11_TN const_iterator end()   const NOEXCEPT_TN {return p_ + sz_;}

    CONSTEXPR11_TN char operator[](std::size_t n) const
    {
        return n < sz_ ? p_[n] : throw std::out_of_range("static_string");
    }
};

inline
std::ostream&
operator<<(std::ostream& os, static_string const& s)
{
    return os.write(s.data(), s.size());
}

template 
CONSTEXPR14_TN
static_string
type_name()
{
#ifdef __clang__
    static_string p = __PRETTY_FUNCTION__;
    return static_string(p.data() + 31, p.size() - 31 - 1);
#elif defined(__GNUC__)
    static_string p = __PRETTY_FUNCTION__;
#  if __cplusplus < 201402
    return static_string(p.data() + 36, p.size() - 36 - 1);
#  else
    return static_string(p.data() + 46, p.size() - 46 - 1);
#  endif
#elif defined(_MSC_VER)
    static_string p = __FUNCSIG__;
    return static_string(p.data() + 38, p.size() - 38 - 7);
#endif
}

This code will auto-backoff on the constexpr if you're still stuck in ancient C++11. And if you're painting on the cave wall with C++98/03, the noexcept is sacrificed as well.

C++17 Update

In the comments below Lyberta points out that the new std::string_view can replace static_string:

template 
constexpr
std::string_view
type_name()
{
    using namespace std;
#ifdef __clang__
    string_view p = __PRETTY_FUNCTION__;
    return string_view(p.data() + 34, p.size() - 34 - 1);
#elif defined(__GNUC__)
    string_view p = __PRETTY_FUNCTION__;
#  if __cplusplus < 201402
    return string_view(p.data() + 36, p.size() - 36 - 1);
#  else
    return string_view(p.data() + 49, p.find(';', 49) - 49);
#  endif
#elif defined(_MSC_VER)
    string_view p = __FUNCSIG__;
    return string_view(p.data() + 84, p.size() - 84 - 7);
#endif
}

I've updated the constants for VS thanks to the very nice detective work by Jive Dadson in the comments below.

Update:

Be sure to check out this rewrite below which eliminates the unreadable magic numbers in my latest formulation.

user_1968 · Answer

Try:

#include 

// …
std::cout << typeid(a).name() << '
';

You might have to activate RTTI in your compiler options for this to work. Additionally, the output of this depends on the compiler. It might be a raw type name or a name mangling symbol or anything in between.

user_11638718 · Answer

According to Howard's solution, if you don't like the magic number, I think this is a good way to represent and it looks intuitive:

#include 

template 
constexpr auto type_name() {
  std::string_view name, prefix, suffix;
#ifdef __clang__
  name = __PRETTY_FUNCTION__;
  prefix = "auto type_name() [T = ";
  suffix = "]";
#elif defined(__GNUC__)
  name = __PRETTY_FUNCTION__;
  prefix = "constexpr auto type_name() [with T = ";
  suffix = "]";
#elif defined(_MSC_VER)
  name = __FUNCSIG__;
  prefix = "auto __cdecl type_name<";
  suffix = ">(void)";
#endif
  name.remove_prefix(prefix.size());
  name.remove_suffix(suffix.size());
  return name;
}

Demo.

mdec_15534 · Answer

Don't forget to include

I believe what you are referring to is runtime type identification. You can achieve the above by doing .

#include 
#include 

using namespace std;

int main() {
  int i;
  cout << typeid(i).name();
  return 0;
}

paercebal_14089 · Answer

Note that the names generated by the RTTI feature of C++ is not portable. For example, the class

MyNamespace::CMyContainer

will have the following names:

// MSVC 2003:
class MyNamespace::CMyContainer[int,class test_MyNamespace::CMyObject]
// G++ 4.2:
N8MyNamespace8CMyContainerIiN13test_MyNamespace9CMyObjectEEE

So you can't use this information for serialization. But still, the typeid(a).name() property can still be used for log/debug purposes

user_3233 · Answer

You can use templates.

template  const char* typeof(T&) { return "unknown"; }    // default
template<> const char* typeof(int&) { return "int"; }
template<> const char* typeof(float&) { return "float"; }

In the example above, when the type is not matched it will print "unknown".

user_7163942 · Answer

Howard Hinnant used magic numbers to extract type name. 康桓瑋 suggested string prefix and suffix. But prefix/suffix keep changing. With “probe_type” type_name automatically calculates prefix and suffix sizes for “probe_type” to extract type name:

#include 
using namespace std;

namespace typeName {
 template 
  constexpr string_view wrapped_type_name () {
#ifdef __clang__
    return __PRETTY_FUNCTION__;
#elif defined(__GNUC__)
    return  __PRETTY_FUNCTION__;
#elif defined(_MSC_VER)
    return  __FUNCSIG__;
#endif
  }

  class probe_type;
  constexpr string_view probe_type_name ("typeName::probe_type");
  constexpr string_view probe_type_name_elaborated ("class typeName::probe_type");
  constexpr string_view probe_type_name_used (wrapped_type_name ().find (probe_type_name_elaborated) != -1 ? probe_type_name_elaborated : probe_type_name);

  constexpr size_t prefix_size () {
    return wrapped_type_name ().find (probe_type_name_used);
  }

  constexpr size_t suffix_size () {
    return wrapped_type_name ().length () - prefix_size () - probe_type_name_used.length ();
  }

  template 
  string_view type_name () {
    constexpr auto type_name = wrapped_type_name ();

    return type_name.substr (prefix_size (), type_name.length () - prefix_size () - suffix_size ());
  }
}

#include 

using typeName::type_name;
using typeName::probe_type;

class test;

int main () {
  cout << type_name () << endl;

  cout << type_name () << endl;
  cout << type_name () << endl;

  const int ic = 42;
  const int* pic = ⁣
  const int*& rpic = pic;
  cout << type_name () << endl;
  cout << type_name () << endl;
  cout << type_name () << endl;

  cout << type_name () << endl;
}

Output

gcc 10.2:

test
const int *&
unsigned int
const int
const int *
const int *&
typeName::probe_type

clang 11.0.0:

test
const int *&
unsigned int
const int
const int *
const int *&
typeName::probe_type

VS 2019 version 16.7.6:

class test
const int*&
unsigned int
const int
const int*
const int*&
class typeName::probe_type

Greg_Hewgill_893 · Answer

You could use a traits class for this. Something like:

#include 
using namespace std;

template  class type_name {
public:
    static const char *name;
};

#define DECLARE_TYPE_NAME(x) template<> const char *type_name::name = #x;
#define GET_TYPE_NAME(x) (type_name::name)

DECLARE_TYPE_NAME(int);

int main()
{
    int a = 12;
    cout << GET_TYPE_NAME(a) << endl;
}

The DECLARE_TYPE_NAME define exists to make your life easier in declaring this traits class for all the types you expect to need.

This might be more useful than the solutions involving typeid because you get to control the output. For example, using typeid for long long on my compiler gives "x".

user_1593077 · Answer

_{Another take on @康桓瑋's answer (originally ), making less assumptions about the prefix and suffix specifics, and inspired by @Val's answer - but without polluting the global namespace; without any conditions; and hopefully easier to read.}

The popular compilers provide a macro with the current function's signature. Now, functions are templatable; so the signature contains the template arguments. So, the basic approach is: Given a type, be in a function with that type as a template argument.

Unfortunately, the type name is wrapped in text describing the function, which is different between compilers. For example, with GCC, the signature of template int foo() with type double is: int foo() [T = double].

So, how do you get rid of the wrapper text? @HowardHinnant's solution is the shortest and most "direct": Just use per-compiler magic numbers to remove a prefix and a suffix. But obviously, that's very brittle; and nobody likes magic numbers in their code. It turns out, however, that given the macro value for a type with a known name, you can determine what prefix and suffix constitute the wrapping.

#include 

template  constexpr std::string_view type_name();

template <>
constexpr std::string_view type_name()
{ return "void"; }

namespace detail {

using type_name_prober = void;

template 
constexpr std::string_view wrapped_type_name() 
{
#ifdef __clang__
    return __PRETTY_FUNCTION__;
#elif defined(__GNUC__)
    return __PRETTY_FUNCTION__;
#elif defined(_MSC_VER)
    return __FUNCSIG__;
#else
#error "Unsupported compiler"
#endif
}

constexpr std::size_t wrapped_type_name_prefix_length() { 
    return wrapped_type_name().find(type_name()); 
}

constexpr std::size_t wrapped_type_name_suffix_length() { 
    return wrapped_type_name().length() 
        - wrapped_type_name_prefix_length() 
        - type_name().length();
}

} // namespace detail

template 
constexpr std::string_view type_name() {
    constexpr auto wrapped_name = detail::wrapped_type_name();
    constexpr auto prefix_length = detail::wrapped_type_name_prefix_length();
    constexpr auto suffix_length = detail::wrapped_type_name_suffix_length();
    constexpr auto type_name_length = wrapped_name.length() - prefix_length - suffix_length;
    return wrapped_name.substr(prefix_length, type_name_length);
}

See it on GodBolt. This should be working with MSVC as well.

user_6942726 · Answer

In C++11, we have decltype. There is no way in standard c++ to display exact type of variable declared using decltype. We can use boost typeindex i.e type_id_with_cvr (cvr stands for const, volatile, reference) to print type like below.

#include 
#include 

using namespace std;
using boost::typeindex::type_id_with_cvr;

int main() {
  int i = 0;
  const int ci = 0;
  cout << "decltype(i) is " << type_id_with_cvr().pretty_name() << '
';
  cout << "decltype((i)) is " << type_id_with_cvr().pretty_name() << '
';
  cout << "decltype(ci) is " << type_id_with_cvr().pretty_name() << '
';
  cout << "decltype((ci)) is " << type_id_with_cvr().pretty_name() << '
';
  cout << "decltype(std::move(i)) is " << type_id_with_cvr().pretty_name() << '
';
  cout << "decltype(std::static_cast(i)) is " << type_id_with_cvr(i))>().pretty_name() << '
';
  return 0;
}

user_11828 · Answer

The other answers involving RTTI (typeid) are probably what you want, as long as:

you can afford the memory overhead (which can be considerable with some compilers)
the class names your compiler returns are useful

The alternative, (similar to Greg Hewgill's answer), is to build a compile-time table of traits.

template  struct type_as_string;

// declare your Wibble type (probably with definition of Wibble)
template <>
struct type_as_string
{
    static const char* const value = "Wibble";
};

Be aware that if you wrap the declarations in a macro, you'll have trouble declaring names for template types taking more than one parameter (e.g. std::map), due to the comma.

To access the name of the type of a variable, all you need is

template 
const char* get_type_as_string(const T&)
{
    return type_as_string::value;
}

user_2846062 · Answer

As explained by Scott Meyers in Effective Modern C++,

Calls to std::type_info::name are not guaranteed to return anythong sensible.

The best solution is to let the compiler generate an error message during the type deduction, for example,

template
class TD;

int main(){
    const int theAnswer = 32;
    auto x = theAnswer;
    auto y = &theAnswer;
    TD xType;
    TD yType;
    return 0;
}

The result will be something like this, depending on the compilers,

test4.cpp:10:21: error: aggregate ‘TD xType’ has incomplete type and cannot be defined TD xType;

test4.cpp:11:21: error: aggregate ‘TD yType’ has incomplete type and cannot be defined TD yType;

Hence, we get to know that x's type is int, y's type is const int*

user_2397086 · Answer

For anyone still visiting, I've recently had the same issue and decided to write a small library based on answers from this post. It provides constexpr type names and type indices und is is tested on Mac, Windows and Ubuntu.

The library code is here: https://github.com/TheLartians/StaticTypeInfo

user_8309701 · Answer

For something different, here's a "To English" conversion of the type, deconstructing every qualifier, extent, argument, and so on, recursively building the string describing the type I think the "deduced this" proposal would help cut down many of the specializations. In any case, this was a fun morning exercise, regardless of excessive bloat. :)

struct X {
    using T = int *((*)[10]);
    T f(T, const unsigned long long * volatile * );
};

int main() {

    std::cout << describe() << std::endl;
}

Output:

pointer to member function of class 1X taking (pointer to array[10]
of pointer to int, pointer to volatile pointer to const unsigned 
long long), and returning pointer to array[10] of pointer to int

Here's the code: https://godbolt.org/z/7jKK4or43

Note: most current version is in my github: https://github.com/cuzdav/type_to_string

// Print types as strings, including functions, member 

#include 
#include 
#include 
#include 

namespace detail {

template  struct Describe;

template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};
template  
struct Describe  {
    static std::string describe();
};

template 
std::string describe()
{
    using namespace std::string_literals;
    auto terminal = [&](char const * desc) {
        return desc + " "s + typeid(T).name();
    };
    if constexpr(std::is_const_v) {
        return "const " + describe>();
    }
    else if constexpr(std::is_volatile_v) {
        return "volatile " + describe>();
    }
    else if constexpr (std::is_same_v) {
        return "bool";
    }
    else if constexpr(std::is_same_v) {
        return "char";
    }
    else if constexpr(std::is_same_v) {
        return "signed char";
    }
    else if constexpr(std::is_same_v) {
        return "unsigned char";
    }
    else if constexpr(std::is_unsigned_v) {
        return "unsigned " + describe>();
    }
    else if constexpr(std::is_void_v) {
        return "void";
    }
    else if constexpr(std::is_integral_v) {
        if constexpr(std::is_same_v) 
            return "short";
        else if constexpr(std::is_same_v) 
            return "int";
        else if constexpr(std::is_same_v) 
            return "long";
        else if constexpr(std::is_same_v) 
            return "long long";
    }
    else if constexpr(std::is_same_v) {
        return "float";
    }
    else if constexpr(std::is_same_v) {
        return "double";
    }
    else if constexpr(std::is_same_v) {
        return "long double";
    }
    else if constexpr(std::is_same_v) { 
        return "nullptr_t";
    }
    else if constexpr(std::is_class_v) {
        return terminal("class");
    }
    else if constexpr(std::is_union_v) {
        return terminal("union");
    }
    else if constexpr(std::is_enum_v) {
        std::string result;
        if (!std::is_convertible_v>) {
            result += "scoped ";
        }
        return result + terminal("enum");
    }  
    else if constexpr(std::is_pointer_v) {
        return "pointer to " + describe>();
    }
    else if constexpr(std::is_lvalue_reference_v) {
        return "lvalue-ref to " + describe>();
    }
    else if constexpr(std::is_rvalue_reference_v) {
        return "rvalue-ref to " + describe>();
    }
    else if constexpr(std::is_bounded_array_v) {
        return "array[" + std::to_string(std::extent_v) + "] of " +
            describe>();
    }
    else if constexpr(std::is_unbounded_array_v) {
        return "array[] of " + describe>();
    }
    else if constexpr(std::is_function_v) {
        return Describe::describe();
    }
    else if constexpr(std::is_member_object_pointer_v) {
        return Describe::describe();
    }
    else if constexpr(std::is_member_function_pointer_v) {
        return Describe::describe();
    }
}

template  
std::string Describe::describe() {
    std::string result = "function taking (";
    ((result += detail::describe(", ")), ...);
    return result + "), returning " + detail::describe();
}

template  
std::string Describe::describe() {
    return "pointer to member of " + detail::describe() +
        " of type " + detail::describe();
}

struct Comma {
    char const * sep = "";
    std::string operator()(std::string const& str) {
        return std::exchange(sep, ", ") + str;
    }
};
enum Qualifiers {NONE=0, CONST=1, VOLATILE=2, NOEXCEPT=4, LVREF=8, RVREF=16};

template 
std::string describeMemberPointer(Qualifiers q) {
    std::string result = "pointer to ";
    if (NONE != (q & CONST)) result += "const ";
    if (NONE != (q & VOLATILE)) result += "volatile ";
    if (NONE != (q & NOEXCEPT)) result += "noexcept ";
    if (NONE != (q & LVREF)) result += "lvalue-ref ";
    if (NONE != (q & RVREF)) result += "rvalue-ref ";
    result += "member function of " + detail::describe() + " taking (";
    Comma comma;
    ((result += comma(detail::describe())), ...);
    return result + "), and returning " + detail::describe();
}

template  
std::string Describe::describe() {
    return describeMemberPointer(NONE);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(CONST);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(NOEXCEPT);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(VOLATILE);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(VOLATILE | NOEXCEPT);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(CONST | VOLATILE);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(CONST | NOEXCEPT);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(CONST | VOLATILE | NOEXCEPT);
}

template  
std::string Describe::describe() {
    return describeMemberPointer(LVREF);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(LVREF | CONST);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(LVREF | NOEXCEPT);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(LVREF | VOLATILE);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(LVREF | VOLATILE | NOEXCEPT);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(LVREF | CONST | VOLATILE);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(LVREF | CONST | NOEXCEPT);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(LVREF | CONST | VOLATILE | NOEXCEPT);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(RVREF);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(RVREF | CONST);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(RVREF | NOEXCEPT);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(RVREF | VOLATILE);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(RVREF | VOLATILE | NOEXCEPT);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(RVREF | CONST | VOLATILE);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(RVREF | CONST | NOEXCEPT);
}
template  
std::string Describe::describe() {
    return describeMemberPointer(RVREF | CONST | VOLATILE | NOEXCEPT);
}

} // detail

///////////////////////////////////
// Main function
///////////////////////////////////
template 
std::string describe() {
    return detail::describe();
}


///////////////////////////////////
// Sample code
///////////////////////////////////
#include 


struct X {
    using T = int *((*)[10]);
    T f(T, const unsigned long long * volatile * );
};

int main() {
    std::cout << describe() << std::endl;
}

user_11502722 · Answer

Copying from this answer: https://stackoverflow.com/a/56766138/11502722

I was able to get this somewhat working for C++ static_assert(). The wrinkle here is that static_assert() only accepts string literals; constexpr string_view will not work. You will need to accept extra text around the typename, but it works:

template
constexpr void assertIfTestFailed()
{
#ifdef __clang__
    static_assert(testFn(), "Test failed on this used type: " __PRETTY_FUNCTION__);
#elif defined(__GNUC__)
    static_assert(testFn(), "Test failed on this used type: " __PRETTY_FUNCTION__);
#elif defined(_MSC_VER)
    static_assert(testFn(), "Test failed on this used type: " __FUNCSIG__);
#else
    static_assert(testFn(), "Test failed on this used type (see surrounding logged error for details).");
#endif
    }
}

MSVC Output:

error C2338: Test failed on this used type: void __cdecl assertIfTestFailed(void)
... continued trace of where the erroring code came from ...

user_2378300 · Answer

Building on a number of the previous answers, I made this solution which does not store the result of __PRETTY_FUNCTION__ in the binary. It uses a static array to hold the string representation of the type name.

It requires C++23.

#include 
#include 
#include 

template 
constexpr auto type_name() {
    auto gen = []  () constexpr -> std::string_view  {
        return __PRETTY_FUNCTION__;
    };
    constexpr std::string_view search_type = "float";
    constexpr auto search_type_string = gen.template operator()();
    constexpr auto prefix = search_type_string.find(search_type);
    constexpr auto suffix = search_type_string.size() - prefix - search_type.size();
    constexpr auto str = gen.template operator()();
    constexpr int size = str.size() - prefix - suffix;
    constexpr auto static arr = [&](std::index_sequence) constexpr {
        return std::array{str[prefix + I]...};
    } (std::make_index_sequence{});

    return std::string_view(arr.data(), size);
}

user_6219626 · Answer

C++ Data type resolve in Compile-Time using Template and Runtime using TypeId.

Compile time solution.

template 
constexpr auto substring_as_array(std::string_view str, std::index_sequence)
{
  return std::array{str[Idxs]..., '
'};
}

template 
constexpr auto type_name_array()
{
#if defined(__clang__)
  constexpr auto prefix   = std::string_view{"[T = "};
  constexpr auto suffix   = std::string_view{"]"};
  constexpr auto function = std::string_view{__PRETTY_FUNCTION__};
#elif defined(__GNUC__)
  constexpr auto prefix   = std::string_view{"with T = "};
  constexpr auto suffix   = std::string_view{"]"};
  constexpr auto function = std::string_view{__PRETTY_FUNCTION__};
#elif defined(_MSC_VER)
  constexpr auto prefix   = std::string_view{"type_name_array<"};
  constexpr auto suffix   = std::string_view{">(void)"};
  constexpr auto function = std::string_view{__FUNCSIG__};
#else
# error Unsupported compiler
#endif

  constexpr auto start = function.find(prefix) + prefix.size();
  constexpr auto end = function.rfind(suffix);

  static_assert(start < end);

  constexpr auto name = function.substr(start, (end - start));
  return substring_as_array(name, std::make_index_sequence{});
}

template 
struct type_name_holder {
  static inline constexpr auto value = type_name_array();
};

template 
constexpr auto type_name() -> std::string_view
{
  constexpr auto& value = type_name_holder::value;
  return std::string_view{value.data(), value.size()};
}

Runtime solution.

template 
void PrintDataType(T type)
{
    auto name = typeid(type).name();
    string cmd_str = "echo '" + string(name) + "' | c++filt -t";
    system(cmd_str.c_str());
}

Main Code

#include 
#include 
#include 
#include 
#include 
#include    // std::array
#include  // std::index_sequence
using std::string;

int main()
{
    //Dynamic resolution.
    std::map iMap;
    PrintDataType(iMap);
    
    //Compile type resolution.
    std::cout << type_name>() << std::endl;

    return 0;
}

Code Snippet

user_18032104 · Answer

Consider this code:

#include 

int main()
{
    char a = 2; // Will print the type "char"
    std::string s = typeid(a).name(); // Store it in a string
    
    if(s == "f") 
    {
        std::cout<<"float";
    }
    
    else if(s == "d")
    {
        std::cout<<"double";
    }
    
    else if(s == "i")
    {
        std::cout<<"int";
    }
    
    else if(s == "c") // Because typeid(a).name(); would print c only, so to make it more concise we should print char
    {
        std::cout<<"char";
    }
    
    return 0;
}

I believe you want the whole word (rather than only printing the short form of int (which is i), you want int), that is why I did the if. Why didn't I immediately do

if(typeid(a).name() == "c")

In short, this won't work. You need to store it in a string.

For some of the variables (string,long double etc... which do not print the expected result comparing their short forms), you need to compare the result of applying the typeid operator with the typeid of a specific type.

Example:

#include 

int main()
{
    int a = 2; // Declare type "int"
    std::string b = "Hi"; // Declare type "string"
    long double c = 3438; // Declare type "long double"
    if(typeid(a) == typeid(int))
    {
        std::cout<<"int
";
    }

    if(typeid(b) == typeid(std::string))
    {
        std::cout<<"string
";
    }
    
    if(typeid(c) == typeid(long double))
    {
        std::cout<<"long double";
    }
    return 0;
}

It outputs int,string and long double.

Maybe you would ask why can't we compare the type with the short form it outputs?

That is because:

Returns an implementation defined null-terminated character string containing the name of the type. No guarantees are given; in particular, the returned string can be identical for several types and change between invocations of the same program. - Cpp Reference

IMO, Python is better than C++ in this case. Python has type function to directly access the type of variable.

Is it possible to print a variable's type in standard C++?

25 Answers

Update: