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

Question

For example   int a   12  cout  lt  lt  typeof a   lt  lt  endl    Expected output   int

User · Answer

A more generic solution without function overloading than my previous one:

template<typename T>
std::string TypeOf(T){
    std::string Type="unknown";
    if(std::is_same<T,int>::value) Type="int";
    if(std::is_same<T,std::string>::value) Type="String";
    if(std::is_same<T,MyClass>::value) Type="MyClass";

    return Type;}

Here MyClass is user defined class. More conditions can be added here as well.

Example:

#include <iostream>



class MyClass{};


template<typename T>
std::string TypeOf(T){
    std::string Type="unknown";
    if(std::is_same<T,int>::value) Type="int";
    if(std::is_same<T,std::string>::value) Type="String";
    if(std::is_same<T,MyClass>::value) Type="MyClass";
    return Type;}


int main(){;
    int a=0;
    std::string s="";
    MyClass my;
    std::cout<<TypeOf(a)<<std::endl;
    std::cout<<TypeOf(s)<<std::endl;
    std::cout<<TypeOf(my)<<std::endl;

    return 0;}

Output:

int
String
MyClass

User · Answer

Try    include  lt typeinfo gt          std  cout  lt  lt  typeid a  name    lt  lt    n     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 · 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  lt string view gt   template  lt typename T gt  constexpr auto type name   noexcept     std  string view name    quot Error  unsupported compiler quot   prefix  suffix   ifdef   clang     name     PRETTY FUNCTION      prefix    quot auto type name    T    quot     suffix    quot   quot    elif defined   GNUC      name     PRETTY FUNCTION      prefix    quot constexpr auto type name    with T    quot     suffix    quot   quot    elif defined  MSC VER    name     FUNCSIG      prefix    quot auto   cdecl type name lt  quot     suffix    quot  gt  void  noexcept quot    endif   name remove prefix prefix size       name remove suffix suffix size       return name     Demo

User · Answer

You may also use c  filt with option -t  type  to demangle the type name    include  lt iostream gt   include  lt typeinfo gt   include  lt string gt   using namespace std   int main       auto x   1    string my type   typeid x  name      system   echo     my type       c  filt -t   c str       return 0      Tested on linux only

User · 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 lt typename T gt  constexpr void assertIfTestFailed      ifdef   clang       static assert testFn lt T gt      quot Test failed on this used type   quot    PRETTY FUNCTION      elif defined   GNUC        static assert testFn lt T gt      quot Test failed on this used type   quot    PRETTY FUNCTION      elif defined  MSC VER      static assert testFn lt T gt      quot Test failed on this used type   quot    FUNCSIG      else     static assert testFn lt T gt      quot Test failed on this used type  see surrounding logged error for details   quot     endif          MSVC Output  error C2338  Test failed on this used type  void   cdecl assertIfTestFailed lt class BadType gt  void      continued trace of where the erroring code came from

User · Answer

You could use a traits class for this  Something like    include  lt iostream gt  using namespace std   template  lt typename T gt  class type name   public      static const char  name       define DECLARE TYPE NAME x  template lt  gt  const char  type name lt x gt   name    x   define GET TYPE NAME x   type name lt typeof x  gt   name   DECLARE TYPE NAME int    int main         int a   12      cout  lt  lt  GET TYPE NAME a   lt  lt  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 · 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  lt iostream gt   include  lt boost type index hpp gt   using namespace std  using boost  typeindex  type id with cvr   int main       int i   0    const int ci   0    cout  lt  lt   decltype i  is    lt  lt  type id with cvr lt decltype i  gt    pretty name    lt  lt    n     cout  lt  lt   decltype  i   is    lt  lt  type id with cvr lt decltype  i   gt    pretty name    lt  lt    n     cout  lt  lt   decltype ci  is    lt  lt  type id with cvr lt decltype ci  gt    pretty name    lt  lt    n     cout  lt  lt   decltype  ci   is    lt  lt  type id with cvr lt decltype  ci   gt    pretty name    lt  lt    n     cout  lt  lt   decltype std  move i   is    lt  lt  type id with cvr lt decltype std  move i   gt    pretty name    lt  lt    n     cout  lt  lt   decltype std  static cast lt int amp  amp  gt  i   is    lt  lt  type id with cvr lt decltype static cast lt int amp  amp  gt  i   gt    pretty name    lt  lt    n     return 0

User · Answer

As mentioned  typeid   name   may return a mangled name  In GCC  and some other compilers  you can work around it with the following code    include  lt cxxabi h gt   include  lt iostream gt   include  lt typeinfo gt   include  lt cstdlib gt   namespace some namespace   namespace another namespace      class my class            int main       typedef some namespace  another namespace  my class my type       mangled   std  cout  lt  lt  typeid my type  name    lt  lt  std  endl        unmangled   int status   0    char  demangled   abi    cxa demangle typeid my type  name    0  0   amp status      switch  status        case -1             could not allocate memory       std  cout  lt  lt   Could not allocate memory   lt  lt  std  endl        return -1        break      case -2             invalid name under the C   ABI mangling rules       std  cout  lt  lt   Invalid name   lt  lt  std  endl        return -1        break      case -3             invalid argument       std  cout  lt  lt   Invalid argument to demangle     lt  lt  std  endl        return -1        break      std  cout  lt  lt  demangled  lt  lt  std  endl    free demangled     return 0

User · Answer

Note that the names generated by the RTTI feature of C   is not portable  For example  the class  MyNamespace  CMyContainer lt int  test MyNamespace  CMyObject gt    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 · Answer

You can use templates   template  lt typename T gt  const char  typeof T amp     return  unknown           default template lt  gt  const char  typeof int amp     return  int     template lt  gt  const char  typeof float amp     return  float       In the example above  when the type is not matched it will print  unknown

User · Answer

Try    include  lt typeinfo gt          std  cout  lt  lt  typeid a  name    lt  lt    n     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 · Answer

Note that the names generated by the RTTI feature of C   is not portable  For example  the class  MyNamespace  CMyContainer lt int  test MyNamespace  CMyObject gt    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 · Answer

Try    include  lt typeinfo gt          std  cout  lt  lt  typeid a  name    lt  lt    n     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 · Answer

I like Nick s method  A complete form might be this  for all basic data types    template  lt typename T gt  const char  typeof T amp     return  unknown           default template lt  gt  const char  typeof int amp     return  int     template lt  gt  const char  typeof short amp     return  short     template lt  gt  const char  typeof long amp     return  long     template lt  gt  const char  typeof unsigned amp     return  unsigned     template lt  gt  const char  typeof unsigned short amp     return  unsigned short     template lt  gt  const char  typeof unsigned long amp     return  unsigned long     template lt  gt  const char  typeof float amp     return  float     template lt  gt  const char  typeof double amp     return  double     template lt  gt  const char  typeof long double amp     return  long double     template lt  gt  const char  typeof std  string amp     return  String     template lt  gt  const char  typeof char amp     return  char     template lt  gt  const char  typeof signed char amp     return  signed char     template lt  gt  const char  typeof unsigned char amp     return  unsigned char     template lt  gt  const char  typeof char  amp     return  char      template lt  gt  const char  typeof signed char  amp     return  signed char      template lt  gt  const char  typeof unsigned char  amp     return  unsigned char

User · Answer

As mentioned  typeid   name   may return a mangled name  In GCC  and some other compilers  you can work around it with the following code    include  lt cxxabi h gt   include  lt iostream gt   include  lt typeinfo gt   include  lt cstdlib gt   namespace some namespace   namespace another namespace      class my class            int main       typedef some namespace  another namespace  my class my type       mangled   std  cout  lt  lt  typeid my type  name    lt  lt  std  endl        unmangled   int status   0    char  demangled   abi    cxa demangle typeid my type  name    0  0   amp status      switch  status        case -1             could not allocate memory       std  cout  lt  lt   Could not allocate memory   lt  lt  std  endl        return -1        break      case -2             invalid name under the C   ABI mangling rules       std  cout  lt  lt   Invalid name   lt  lt  std  endl        return -1        break      case -3             invalid argument       std  cout  lt  lt   Invalid argument to demangle     lt  lt  std  endl        return -1        break      std  cout  lt  lt  demangled  lt  lt  std  endl    free demangled     return 0

User · Answer

You can use templates   template  lt typename T gt  const char  typeof T amp     return  unknown           default template lt  gt  const char  typeof int amp     return  int     template lt  gt  const char  typeof float amp     return  float       In the example above  when the type is not matched it will print  unknown

User · Answer

Don t forget to include  lt typeinfo gt   I believe what you are referring to is runtime type identification  You can achieve the above by doing     include  lt iostream gt   include  lt typeinfo gt   using namespace std   int main       int i    cout  lt  lt  typeid i  name      return 0

User · Answer

As I challenge I decided to test how far can one go with platform-independent  hopefully  template trickery   The names are assembled completely at compilation time   Which means typeid T  name   couldn t be used  thus you have to explicitly provide names for non-compound types  Otherwise placeholders will be displayed instead    Example usage   TYPE NAME int  TYPE NAME void     You probably should list all primitive types here   TYPE NAME std  string   int main            A simple case     std  cout  lt  lt  type name lt void    int  gt   lt  lt    n          - gt   void     int           Ugly mess case        Note that compiler removes cv-qualifiers from parameters and replaces arrays with pointers      std  cout  lt  lt  type name lt void  std  string    int 3  const int  void     std  string    volatile int const   gt   lt  lt    n          - gt   void  std  string    int   int void     std  string    volatile int  const            A case with undefined types         If a type wasn t TYPE NAME d  it s replaced by a placeholder  one of  class     union     enum   or           std  cout  lt  lt  type name lt std  ostream     int  short  gt   lt  lt    n          - gt   class      int             With appropriate TYPE NAME s  the output would be  std  string     int short        Code    include  lt type traits gt   include  lt utility gt   static constexpr std  size t max str lit len   256   template  lt std  size t I  std  size t N gt  constexpr char sl at const char   amp str  N         if constexpr I  lt  N          return str I       else         return   0      constexpr std  size t sl len const char  str        for  std  size t i   0  i  lt  max str lit len  i            if  str i       0               return i      return 0     template  lt char    C gt  struct str lit       static constexpr char value    C       0        static constexpr int size   sl len value        template  lt typename F  typename    P gt  struct concat impl  using type   typename concat impl lt F gt   type  template concat impl lt P    gt   type        template  lt char    CC gt  struct concat impl lt str lit lt CC    gt  gt   using type   str lit lt C     CC    gt         template  lt typename    P gt  using concat   typename concat impl lt P    gt   type      template  lt typename  const char   gt  struct trim str lit impl  template  lt std  size t    I  const char  S gt  struct trim str lit impl lt std  index sequence lt I    gt   S gt        using type   str lit lt S I     gt      template  lt std  size t N  const char  S gt  using trim str lit   typename trim str lit impl lt std  make index sequence lt N gt   S gt   type    define STR LIT str    trim str lit lt   sl len str     str lit lt STR TO VA str  gt   value gt   define STR TO VA str  STR TO VA 16 str 0  STR TO VA 16 str 16  STR TO VA 16 str 32  STR TO VA 16 str 48   define STR TO VA 16 str off  STR TO VA 4 str 0 off  STR TO VA 4 str 4 off  STR TO VA 4 str 8 off  STR TO VA 4 str 12 off   define STR TO VA 4 str off    sl at lt off 0 gt  str    sl at lt off 1 gt  str    sl at lt off 2 gt  str    sl at lt off 3 gt  str   template  lt char    C gt  constexpr str lit lt C    gt  make str lit str lit lt C    gt    return      template  lt std  size t N gt  constexpr auto make str lit const char   amp str  N         return trim str lit lt sl len  const char   amp   N  str   str gt        template  lt std  size t A  std  size t B gt  struct cexpr pow  static constexpr std  size t value   A   cexpr pow lt A B-1 gt   value    template  lt std  size t A gt  struct cexpr pow lt A 0 gt   static constexpr std  size t value   1    template  lt std  size t N  std  size t X  typename   std  make index sequence lt X gt  gt  struct num to str lit impl  template  lt std  size t N  std  size t X  std  size t    Seq gt  struct num to str lit impl lt N  X  std  index sequence lt Seq    gt  gt        static constexpr auto func                 if constexpr  N  gt   cexpr pow lt 10 X gt   value              return num to str lit impl lt N  X 1 gt   func            else             return str lit lt  N   cexpr pow lt 10 X-1-Seq gt   value   10    0      gt              template  lt std  size t N gt  using num to str lit   decltype num to str lit impl lt N 1 gt   func       using spa   str lit lt     gt   using lpa   str lit lt     gt   using rpa   str lit lt     gt   using lbr   str lit lt     gt   using rbr   str lit lt     gt   using ast   str lit lt     gt   using amp   str lit lt   amp   gt   using con   str lit lt  c   o   n   s   t  gt   using vol   str lit lt  v   o   l   a   t   i   l   e  gt   using con vol   con  concat lt spa  vol gt   using nsp   str lit lt         gt   using com   str lit lt     gt   using unk   str lit lt         gt    using c cla   str lit lt  c   l   a   s   s      gt   using c uni   str lit lt  u   n   i   o   n      gt   using c enu   str lit lt  e   n   u   m      gt    template  lt typename T gt  inline constexpr bool ptr or ref   std  is pointer v lt T gt     std  is reference v lt T gt     std  is member pointer v lt T gt   template  lt typename T gt  inline constexpr bool func or arr   std  is function v lt T gt     std  is array v lt T gt    template  lt typename T gt  struct primitive type name  using value   unk     template  lt typename T  typename   std  enable if t lt std  is class v lt T gt  gt  gt  using enable if class   T  template  lt typename T  typename   std  enable if t lt std  is union v lt T gt  gt  gt  using enable if union   T  template  lt typename T  typename   std  enable if t lt std  is enum v  lt T gt  gt  gt  using enable if enum    T  template  lt typename T gt  struct primitive type name lt enable if class lt T gt  gt   using value   c cla    template  lt typename T gt  struct primitive type name lt enable if union lt T gt  gt   using value   c uni    template  lt typename T gt  struct primitive type name lt enable if enum  lt T gt  gt   using value   c enu     template  lt typename T gt  struct type name impl   template  lt typename T gt  using type name lit   std  conditional t lt std  is same v lt typename primitive type name lt T gt   value  template concat lt spa gt                                                                                  typename type name impl lt T gt   l  template concat lt typename type name impl lt T gt   r gt  gt                                               typename primitive type name lt T gt   value                                              typename type name impl lt T gt   l  template concat lt typename type name impl lt T gt   r gt  gt   template  lt typename T gt  inline constexpr const char  type name   type name lit lt T gt   value   template  lt typename T  typename   std  enable if t lt  std  is const v lt T gt   amp  amp   std  is volatile v lt T gt  gt  gt  using enable if no cv   T   template  lt typename T gt  struct type name impl       using l   typename primitive type name lt T gt   value  template concat lt spa gt       using r   str lit lt  gt      template  lt typename T gt  struct type name impl lt const T gt        using new T l   std  conditional t lt type name impl lt T gt   l  size  amp  amp   ptr or ref lt T gt                                          spa  concat lt typename type name impl lt T gt   l gt                                          typename type name impl lt T gt   l gt       using l   std  conditional t lt ptr or ref lt T gt                                    typename new T l  template concat lt con gt                                    con  concat lt new T l gt  gt       using r   typename type name impl lt T gt   r     template  lt typename T gt  struct type name impl lt volatile T gt        using new T l   std  conditional t lt type name impl lt T gt   l  size  amp  amp   ptr or ref lt T gt                                          spa  concat lt typename type name impl lt T gt   l gt                                          typename type name impl lt T gt   l gt       using l   std  conditional t lt ptr or ref lt T gt                                    typename new T l  template concat lt vol gt                                    vol  concat lt new T l gt  gt       using r   typename type name impl lt T gt   r     template  lt typename T gt  struct type name impl lt const volatile T gt        using new T l   std  conditional t lt type name impl lt T gt   l  size  amp  amp   ptr or ref lt T gt                                          spa  concat lt typename type name impl lt T gt   l gt                                          typename type name impl lt T gt   l gt       using l   std  conditional t lt ptr or ref lt T gt                                    typename new T l  template concat lt con vol gt                                    con vol  concat lt new T l gt  gt       using r   typename type name impl lt T gt   r     template  lt typename T gt  struct type name impl lt T   gt        using l   std  conditional t lt func or arr lt T gt                                    typename type name impl lt T gt   l  template concat lt lpa  ast gt                                    typename type name impl lt T gt   l  template concat lt      ast gt  gt       using r   std  conditional t lt func or arr lt T gt                                    rpa  concat lt typename type name impl lt T gt   r gt                                                typename type name impl lt T gt   r gt      template  lt typename T gt  struct type name impl lt T  amp  gt        using l   std  conditional t lt func or arr lt T gt                                    typename type name impl lt T gt   l  template concat lt lpa  amp gt                                    typename type name impl lt T gt   l  template concat lt      amp gt  gt       using r   std  conditional t lt func or arr lt T gt                                    rpa  concat lt typename type name impl lt T gt   r gt                                                typename type name impl lt T gt   r gt      template  lt typename T gt  struct type name impl lt T  amp  amp  gt        using l   std  conditional t lt func or arr lt T gt                                    typename type name impl lt T gt   l  template concat lt lpa  amp  amp gt                                    typename type name impl lt T gt   l  template concat lt      amp  amp gt  gt       using r   std  conditional t lt func or arr lt T gt                                    rpa  concat lt typename type name impl lt T gt   r gt                                                typename type name impl lt T gt   r gt      template  lt typename T  typename C gt  struct type name impl lt T C    gt        using l   std  conditional t lt func or arr lt T gt                                    typename type name impl lt T gt   l  template concat lt lpa  type name lit lt C gt   nsp  ast gt                                    typename type name impl lt T gt   l  template concat lt      type name lit lt C gt   nsp  ast gt  gt       using r   std  conditional t lt func or arr lt T gt                                    rpa  concat lt typename type name impl lt T gt   r gt                                                typename type name impl lt T gt   r gt      template  lt typename T gt  struct type name impl lt enable if no cv lt T   gt  gt        using l   typename type name impl lt T gt   l      using r   lbr  concat lt rbr  typename type name impl lt T gt   r gt      template  lt typename T  std  size t N gt  struct type name impl lt enable if no cv lt T N  gt  gt        using l   typename type name impl lt T gt   l      using r   lbr  concat lt num to str lit lt N gt   rbr  typename type name impl lt T gt   r gt      template  lt typename T gt  struct type name impl lt T   gt        using l   typename type name impl lt T gt   l      using r   lpa  concat lt rpa  typename type name impl lt T gt   r gt      template  lt typename T  typename P1  typename    P gt  struct type name impl lt T P1  P     gt        using l   typename type name impl lt T gt   l      using r   lpa  concat lt type name lit lt P1 gt                             com  concat lt type name lit lt P gt  gt      rpa  typename type name impl lt T gt   r gt        define TYPE NAME t  template  lt  gt  struct primitive type name lt t gt   using value   STR LIT  t

User · Answer

A more generic solution without function overloading than my previous one:

template<typename T>
std::string TypeOf(T){
    std::string Type="unknown";
    if(std::is_same<T,int>::value) Type="int";
    if(std::is_same<T,std::string>::value) Type="String";
    if(std::is_same<T,MyClass>::value) Type="MyClass";

    return Type;}

Here MyClass is user defined class. More conditions can be added here as well.

Example:

#include <iostream>



class MyClass{};


template<typename T>
std::string TypeOf(T){
    std::string Type="unknown";
    if(std::is_same<T,int>::value) Type="int";
    if(std::is_same<T,std::string>::value) Type="String";
    if(std::is_same<T,MyClass>::value) Type="MyClass";
    return Type;}


int main(){;
    int a=0;
    std::string s="";
    MyClass my;
    std::cout<<TypeOf(a)<<std::endl;
    std::cout<<TypeOf(s)<<std::endl;
    std::cout<<TypeOf(my)<<std::endl;

    return 0;}

Output:

int
String
MyClass

User · Answer

Try    include  lt typeinfo gt          std  cout  lt  lt  typeid a  name    lt  lt    n     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 · 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 lt typename T gt  class TD   int main        const int theAnswer   32      auto x   theAnswer      auto y    amp theAnswer      TD lt decltype x  gt  xType      TD lt decltype y  gt  yType      return 0      The result will be something like this  depending on the compilers   test4 cpp 10 21  error  aggregate    TD lt int gt  xType    has incomplete type and cannot be defined TD lt decltype x  gt  xType   test4 cpp 11 21  error  aggregate    TD lt const int   gt  yType    has incomplete type and cannot be defined TD lt decltype y  gt  yType    Hence  we get to know that x s type is int  y s type is const int

User · 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 lt typename T gt  class TD   int main        const int theAnswer   32      auto x   theAnswer      auto y    amp theAnswer      TD lt decltype x  gt  xType      TD lt decltype y  gt  yType      return 0      The result will be something like this  depending on the compilers   test4 cpp 10 21  error  aggregate    TD lt int gt  xType    has incomplete type and cannot be defined TD lt decltype x  gt  xType   test4 cpp 11 21  error  aggregate    TD lt const int   gt  yType    has incomplete type and cannot be defined TD lt decltype y  gt  yType    Hence  we get to know that x s type is int  y s type is const int

User · 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 lt typename T gt  constexpr void assertIfTestFailed      ifdef   clang       static assert testFn lt T gt      quot Test failed on this used type   quot    PRETTY FUNCTION      elif defined   GNUC        static assert testFn lt T gt      quot Test failed on this used type   quot    PRETTY FUNCTION      elif defined  MSC VER      static assert testFn lt T gt      quot Test failed on this used type   quot    FUNCSIG      else     static assert testFn lt T gt      quot Test failed on this used type  see surrounding logged error for details   quot     endif          MSVC Output  error C2338  Test failed on this used type  void   cdecl assertIfTestFailed lt class BadType gt  void      continued trace of where the erroring code came from

User · 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  lt  lt  typeid ci  name    lt  lt    n     For me outputs   i   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  lt typename T gt  std  string type name      which would be used like this   const int ci   0  std  cout  lt  lt  type name lt decltype ci  gt     lt  lt    n     and for me outputs   int const    lt disclaimer gt  I have not tested this on MSVC   lt  disclaimer gt   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  lt type traits gt   include  lt typeinfo gt   ifndef  MSC VER     include  lt cxxabi h gt   endif  include  lt memory gt   include  lt string gt   include  lt cstdlib gt   template  lt class T gt  std  string type name         typedef typename std  remove reference lt T gt   type TR      std  unique ptr lt char  void    void   gt  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 lt TR gt   value          r      const       if  std  is volatile lt TR gt   value          r      volatile       if  std  is lvalue reference lt T gt   value          r      amp        else if  std  is rvalue reference lt T gt   value          r      amp  amp        return r      The Results  With this solution I can do this   int amp  foo lref    int amp  amp  foo rref    int foo value     int main         int i   0      const int ci   0      std  cout  lt  lt   decltype i  is    lt  lt  type name lt decltype i  gt     lt  lt    n       std  cout  lt  lt   decltype  i   is    lt  lt  type name lt decltype  i   gt     lt  lt    n       std  cout  lt  lt   decltype ci  is    lt  lt  type name lt decltype ci  gt     lt  lt    n       std  cout  lt  lt   decltype  ci   is    lt  lt  type name lt decltype  ci   gt     lt  lt    n       std  cout  lt  lt   decltype static cast lt int amp  gt  i   is    lt  lt  type name lt decltype static cast lt int amp  gt  i   gt     lt  lt    n       std  cout  lt  lt   decltype static cast lt int amp  amp  gt  i   is    lt  lt  type name lt decltype static cast lt int amp  amp  gt  i   gt     lt  lt    n       std  cout  lt  lt   decltype static cast lt int gt  i   is    lt  lt  type name lt decltype static cast lt int gt  i   gt     lt  lt    n       std  cout  lt  lt   decltype foo lref    is    lt  lt  type name lt decltype foo lref    gt     lt  lt    n       std  cout  lt  lt   decltype foo rref    is    lt  lt  type name lt decltype foo rref    gt     lt  lt    n       std  cout  lt  lt   decltype foo value    is    lt  lt  type name lt decltype foo value    gt     lt  lt    n       and the output is   decltype i  is int decltype  i   is int amp  decltype ci  is int const decltype  ci   is int const amp  decltype static cast lt int amp  gt  i   is int amp  decltype static cast lt int amp  amp  gt  i   is int amp  amp  decltype static cast lt int gt  i   is int decltype foo lref    is int amp  decltype foo rref    is int amp  amp  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 lt int amp  gt  i   is int decltype static cast lt int amp  amp  gt  i   is int decltype static cast lt int gt  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  lt cstddef gt   include  lt stdexcept gt   include  lt cstring gt   include  lt ostream gt    ifndef  MSC VER    if   cplusplus  lt  201103      define CONSTEXPR11 TN      define CONSTEXPR14 TN      define NOEXCEPT TN    elif   cplusplus  lt  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  lt  1900      define CONSTEXPR11 TN      define CONSTEXPR14 TN      define NOEXCEPT TN    elif  MSC VER  lt  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  lt std  size t N gt      CONSTEXPR11 TN static string const char  amp 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  lt  sz    p  n    throw std  out of range  static string              inline std  ostream amp  operator lt  lt  std  ostream amp  os  static string const amp  s        return os write s data    s size        template  lt class T gt  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  lt  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  lt class T gt  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  lt  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 · 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 · 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  lt string view gt  using namespace std   namespace typeName    template  lt typename T gt    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   quot typeName  probe type quot      constexpr string view probe type name elaborated   quot class typeName  probe type quot      constexpr string view probe type name used  wrapped type name lt probe type gt     find  probe type name elaborated     -1   probe type name elaborated   probe type name      constexpr size t prefix size          return wrapped type name lt probe type gt     find  probe type name used          constexpr size t suffix size          return wrapped type name lt probe type gt     length    - prefix size    - probe type name used length            template  lt typename T gt    string view type name          constexpr auto type name   wrapped type name lt T gt           return type name substr  prefix size     type name length    - prefix size    - suffix size              include  lt iostream gt   using typeName  type name  using typeName  probe type   class test   int main        cout  lt  lt  type name lt class test gt      lt  lt  endl     cout  lt  lt  type name lt const int  amp  gt      lt  lt  endl    cout  lt  lt  type name lt unsigned int gt      lt  lt  endl     const int ic   42    const int  pic    amp ic    const int  amp  rpic   pic    cout  lt  lt  type name lt decltype ic  gt      lt  lt  endl    cout  lt  lt  type name lt decltype pic  gt      lt  lt  endl    cout  lt  lt  type name lt decltype rpic  gt      lt  lt  endl     cout  lt  lt  type name lt probe type gt      lt  lt  endl     Output gcc 10 2  test const int   amp  unsigned int const int const int   const int   amp  typeName  probe type  clang 11 0 0  test const int   amp  unsigned int const int const int   const int   amp  typeName  probe type  VS 2019 version 16 7 6  class test const int  amp  unsigned int const int const int  const int  amp  class typeName  probe type

User · 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  lt  lt  typeid ci  name    lt  lt    n     For me outputs   i   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  lt typename T gt  std  string type name      which would be used like this   const int ci   0  std  cout  lt  lt  type name lt decltype ci  gt     lt  lt    n     and for me outputs   int const    lt disclaimer gt  I have not tested this on MSVC   lt  disclaimer gt   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  lt type traits gt   include  lt typeinfo gt   ifndef  MSC VER     include  lt cxxabi h gt   endif  include  lt memory gt   include  lt string gt   include  lt cstdlib gt   template  lt class T gt  std  string type name         typedef typename std  remove reference lt T gt   type TR      std  unique ptr lt char  void    void   gt  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 lt TR gt   value          r      const       if  std  is volatile lt TR gt   value          r      volatile       if  std  is lvalue reference lt T gt   value          r      amp        else if  std  is rvalue reference lt T gt   value          r      amp  amp        return r      The Results  With this solution I can do this   int amp  foo lref    int amp  amp  foo rref    int foo value     int main         int i   0      const int ci   0      std  cout  lt  lt   decltype i  is    lt  lt  type name lt decltype i  gt     lt  lt    n       std  cout  lt  lt   decltype  i   is    lt  lt  type name lt decltype  i   gt     lt  lt    n       std  cout  lt  lt   decltype ci  is    lt  lt  type name lt decltype ci  gt     lt  lt    n       std  cout  lt  lt   decltype  ci   is    lt  lt  type name lt decltype  ci   gt     lt  lt    n       std  cout  lt  lt   decltype static cast lt int amp  gt  i   is    lt  lt  type name lt decltype static cast lt int amp  gt  i   gt     lt  lt    n       std  cout  lt  lt   decltype static cast lt int amp  amp  gt  i   is    lt  lt  type name lt decltype static cast lt int amp  amp  gt  i   gt     lt  lt    n       std  cout  lt  lt   decltype static cast lt int gt  i   is    lt  lt  type name lt decltype static cast lt int gt  i   gt     lt  lt    n       std  cout  lt  lt   decltype foo lref    is    lt  lt  type name lt decltype foo lref    gt     lt  lt    n       std  cout  lt  lt   decltype foo rref    is    lt  lt  type name lt decltype foo rref    gt     lt  lt    n       std  cout  lt  lt   decltype foo value    is    lt  lt  type name lt decltype foo value    gt     lt  lt    n       and the output is   decltype i  is int decltype  i   is int amp  decltype ci  is int const decltype  ci   is int const amp  decltype static cast lt int amp  gt  i   is int amp  decltype static cast lt int amp  amp  gt  i   is int amp  amp  decltype static cast lt int gt  i   is int decltype foo lref    is int amp  decltype foo rref    is int amp  amp  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 lt int amp  gt  i   is int decltype static cast lt int amp  amp  gt  i   is int decltype static cast lt int gt  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  lt cstddef gt   include  lt stdexcept gt   include  lt cstring gt   include  lt ostream gt    ifndef  MSC VER    if   cplusplus  lt  201103      define CONSTEXPR11 TN      define CONSTEXPR14 TN      define NOEXCEPT TN    elif   cplusplus  lt  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  lt  1900      define CONSTEXPR11 TN      define CONSTEXPR14 TN      define NOEXCEPT TN    elif  MSC VER  lt  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  lt std  size t N gt      CONSTEXPR11 TN static string const char  amp 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  lt  sz    p  n    throw std  out of range  static string              inline std  ostream amp  operator lt  lt  std  ostream amp  os  static string const amp  s        return os write s data    s size        template  lt class T gt  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  lt  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  lt class T gt  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  lt  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 · 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  lt typename T gt  struct type as string      declare your Wibble type  probably with definition of Wibble  template  lt  gt  struct type as string lt Wibble gt        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  lt typename T gt  const char  get type as string const T amp         return type as string lt T gt   value

User · 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  lt iostream gt   include  lt boost type index hpp gt   using namespace std  using boost  typeindex  type id with cvr   int main       int i   0    const int ci   0    cout  lt  lt   decltype i  is    lt  lt  type id with cvr lt decltype i  gt    pretty name    lt  lt    n     cout  lt  lt   decltype  i   is    lt  lt  type id with cvr lt decltype  i   gt    pretty name    lt  lt    n     cout  lt  lt   decltype ci  is    lt  lt  type id with cvr lt decltype ci  gt    pretty name    lt  lt    n     cout  lt  lt   decltype  ci   is    lt  lt  type id with cvr lt decltype  ci   gt    pretty name    lt  lt    n     cout  lt  lt   decltype std  move i   is    lt  lt  type id with cvr lt decltype std  move i   gt    pretty name    lt  lt    n     cout  lt  lt   decltype std  static cast lt int amp  amp  gt  i   is    lt  lt  type id with cvr lt decltype static cast lt int amp  amp  gt  i   gt    pretty name    lt  lt    n     return 0

User · Answer

Try    include  lt typeinfo gt          std  cout  lt  lt  typeid a  name    lt  lt    n     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 · Answer

I like Nick s method  A complete form might be this  for all basic data types    template  lt typename T gt  const char  typeof T amp     return  unknown           default template lt  gt  const char  typeof int amp     return  int     template lt  gt  const char  typeof short amp     return  short     template lt  gt  const char  typeof long amp     return  long     template lt  gt  const char  typeof unsigned amp     return  unsigned     template lt  gt  const char  typeof unsigned short amp     return  unsigned short     template lt  gt  const char  typeof unsigned long amp     return  unsigned long     template lt  gt  const char  typeof float amp     return  float     template lt  gt  const char  typeof double amp     return  double     template lt  gt  const char  typeof long double amp     return  long double     template lt  gt  const char  typeof std  string amp     return  String     template lt  gt  const char  typeof char amp     return  char     template lt  gt  const char  typeof signed char amp     return  signed char     template lt  gt  const char  typeof unsigned char amp     return  unsigned char     template lt  gt  const char  typeof char  amp     return  char      template lt  gt  const char  typeof signed char  amp     return  signed char      template lt  gt  const char  typeof unsigned char  amp     return  unsigned char

User · 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  lt typename T gt  struct type as string      declare your Wibble type  probably with definition of Wibble  template  lt  gt  struct type as string lt Wibble gt        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  lt typename T gt  const char  get type as string const T amp         return type as string lt T gt   value

User · Answer

You may also use c  filt with option -t  type  to demangle the type name    include  lt iostream gt   include  lt typeinfo gt   include  lt string gt   using namespace std   int main       auto x   1    string my type   typeid x  name      system   echo     my type       c  filt -t   c str       return 0      Tested on linux only

User · 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  lt string view gt   template  lt typename T gt  constexpr auto type name   noexcept     std  string view name    quot Error  unsupported compiler quot   prefix  suffix   ifdef   clang     name     PRETTY FUNCTION      prefix    quot auto type name    T    quot     suffix    quot   quot    elif defined   GNUC      name     PRETTY FUNCTION      prefix    quot constexpr auto type name    with T    quot     suffix    quot   quot    elif defined  MSC VER    name     FUNCSIG      prefix    quot auto   cdecl type name lt  quot     suffix    quot  gt  void  noexcept quot    endif   name remove prefix prefix size       name remove suffix suffix size       return name     Demo

User · Answer

You may also use c  filt with option -t  type  to demangle the type name    include  lt iostream gt   include  lt typeinfo gt   include  lt string gt   using namespace std   int main       auto x   1    string my type   typeid x  name      system   echo     my type       c  filt -t   c str       return 0      Tested on linux only

User · 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 lt typename T gt  class TD   int main        const int theAnswer   32      auto x   theAnswer      auto y    amp theAnswer      TD lt decltype x  gt  xType      TD lt decltype y  gt  yType      return 0      The result will be something like this  depending on the compilers   test4 cpp 10 21  error  aggregate    TD lt int gt  xType    has incomplete type and cannot be defined TD lt decltype x  gt  xType   test4 cpp 11 21  error  aggregate    TD lt const int   gt  yType    has incomplete type and cannot be defined TD lt decltype y  gt  yType    Hence  we get to know that x s type is int  y s type is const int

User · Answer

Don t forget to include  lt typeinfo gt   I believe what you are referring to is runtime type identification  You can achieve the above by doing     include  lt iostream gt   include  lt typeinfo gt   using namespace std   int main       int i    cout  lt  lt  typeid i  name      return 0

User · Answer

Note that the names generated by the RTTI feature of C   is not portable  For example  the class  MyNamespace  CMyContainer lt int  test MyNamespace  CMyObject gt    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 · 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 lt typename T gt  class TD   int main        const int theAnswer   32      auto x   theAnswer      auto y    amp theAnswer      TD lt decltype x  gt  xType      TD lt decltype y  gt  yType      return 0      The result will be something like this  depending on the compilers   test4 cpp 10 21  error  aggregate    TD lt int gt  xType    has incomplete type and cannot be defined TD lt decltype x  gt  xType   test4 cpp 11 21  error  aggregate    TD lt const int   gt  yType    has incomplete type and cannot be defined TD lt decltype y  gt  yType    Hence  we get to know that x s type is int  y s type is const int

User · 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  lt typename T gt  struct type as string      declare your Wibble type  probably with definition of Wibble  template  lt  gt  struct type as string lt Wibble gt        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  lt typename T gt  const char  get type as string const T amp         return type as string lt T gt   value

User · 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  lt typename T gt  struct type as string      declare your Wibble type  probably with definition of Wibble  template  lt  gt  struct type as string lt Wibble gt        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  lt typename T gt  const char  get type as string const T amp         return type as string lt T gt   value

User · Answer

A more generic solution without function overloading than my previous one:

template<typename T>
std::string TypeOf(T){
    std::string Type="unknown";
    if(std::is_same<T,int>::value) Type="int";
    if(std::is_same<T,std::string>::value) Type="String";
    if(std::is_same<T,MyClass>::value) Type="MyClass";

    return Type;}

Here MyClass is user defined class. More conditions can be added here as well.

Example:

#include <iostream>



class MyClass{};


template<typename T>
std::string TypeOf(T){
    std::string Type="unknown";
    if(std::is_same<T,int>::value) Type="int";
    if(std::is_same<T,std::string>::value) Type="String";
    if(std::is_same<T,MyClass>::value) Type="MyClass";
    return Type;}


int main(){;
    int a=0;
    std::string s="";
    MyClass my;
    std::cout<<TypeOf(a)<<std::endl;
    std::cout<<TypeOf(s)<<std::endl;
    std::cout<<TypeOf(my)<<std::endl;

    return 0;}

Output:

int
String
MyClass

User · 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  lt  lt  typeid ci  name    lt  lt    n     For me outputs   i   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  lt typename T gt  std  string type name      which would be used like this   const int ci   0  std  cout  lt  lt  type name lt decltype ci  gt     lt  lt    n     and for me outputs   int const    lt disclaimer gt  I have not tested this on MSVC   lt  disclaimer gt   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  lt type traits gt   include  lt typeinfo gt   ifndef  MSC VER     include  lt cxxabi h gt   endif  include  lt memory gt   include  lt string gt   include  lt cstdlib gt   template  lt class T gt  std  string type name         typedef typename std  remove reference lt T gt   type TR      std  unique ptr lt char  void    void   gt  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 lt TR gt   value          r      const       if  std  is volatile lt TR gt   value          r      volatile       if  std  is lvalue reference lt T gt   value          r      amp        else if  std  is rvalue reference lt T gt   value          r      amp  amp        return r      The Results  With this solution I can do this   int amp  foo lref    int amp  amp  foo rref    int foo value     int main         int i   0      const int ci   0      std  cout  lt  lt   decltype i  is    lt  lt  type name lt decltype i  gt     lt  lt    n       std  cout  lt  lt   decltype  i   is    lt  lt  type name lt decltype  i   gt     lt  lt    n       std  cout  lt  lt   decltype ci  is    lt  lt  type name lt decltype ci  gt     lt  lt    n       std  cout  lt  lt   decltype  ci   is    lt  lt  type name lt decltype  ci   gt     lt  lt    n       std  cout  lt  lt   decltype static cast lt int amp  gt  i   is    lt  lt  type name lt decltype static cast lt int amp  gt  i   gt     lt  lt    n       std  cout  lt  lt   decltype static cast lt int amp  amp  gt  i   is    lt  lt  type name lt decltype static cast lt int amp  amp  gt  i   gt     lt  lt    n       std  cout  lt  lt   decltype static cast lt int gt  i   is    lt  lt  type name lt decltype static cast lt int gt  i   gt     lt  lt    n       std  cout  lt  lt   decltype foo lref    is    lt  lt  type name lt decltype foo lref    gt     lt  lt    n       std  cout  lt  lt   decltype foo rref    is    lt  lt  type name lt decltype foo rref    gt     lt  lt    n       std  cout  lt  lt   decltype foo value    is    lt  lt  type name lt decltype foo value    gt     lt  lt    n       and the output is   decltype i  is int decltype  i   is int amp  decltype ci  is int const decltype  ci   is int const amp  decltype static cast lt int amp  gt  i   is int amp  decltype static cast lt int amp  amp  gt  i   is int amp  amp  decltype static cast lt int gt  i   is int decltype foo lref    is int amp  decltype foo rref    is int amp  amp  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 lt int amp  gt  i   is int decltype static cast lt int amp  amp  gt  i   is int decltype static cast lt int gt  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  lt cstddef gt   include  lt stdexcept gt   include  lt cstring gt   include  lt ostream gt    ifndef  MSC VER    if   cplusplus  lt  201103      define CONSTEXPR11 TN      define CONSTEXPR14 TN      define NOEXCEPT TN    elif   cplusplus  lt  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  lt  1900      define CONSTEXPR11 TN      define CONSTEXPR14 TN      define NOEXCEPT TN    elif  MSC VER  lt  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  lt std  size t N gt      CONSTEXPR11 TN static string const char  amp 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  lt  sz    p  n    throw std  out of range  static string              inline std  ostream amp  operator lt  lt  std  ostream amp  os  static string const amp  s        return os write s data    s size        template  lt class T gt  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  lt  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  lt class T gt  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  lt  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 · Answer

As I challenge I decided to test how far can one go with platform-independent  hopefully  template trickery   The names are assembled completely at compilation time   Which means typeid T  name   couldn t be used  thus you have to explicitly provide names for non-compound types  Otherwise placeholders will be displayed instead    Example usage   TYPE NAME int  TYPE NAME void     You probably should list all primitive types here   TYPE NAME std  string   int main            A simple case     std  cout  lt  lt  type name lt void    int  gt   lt  lt    n          - gt   void     int           Ugly mess case        Note that compiler removes cv-qualifiers from parameters and replaces arrays with pointers      std  cout  lt  lt  type name lt void  std  string    int 3  const int  void     std  string    volatile int const   gt   lt  lt    n          - gt   void  std  string    int   int void     std  string    volatile int  const            A case with undefined types         If a type wasn t TYPE NAME d  it s replaced by a placeholder  one of  class     union     enum   or           std  cout  lt  lt  type name lt std  ostream     int  short  gt   lt  lt    n          - gt   class      int             With appropriate TYPE NAME s  the output would be  std  string     int short        Code    include  lt type traits gt   include  lt utility gt   static constexpr std  size t max str lit len   256   template  lt std  size t I  std  size t N gt  constexpr char sl at const char   amp str  N         if constexpr I  lt  N          return str I       else         return   0      constexpr std  size t sl len const char  str        for  std  size t i   0  i  lt  max str lit len  i            if  str i       0               return i      return 0     template  lt char    C gt  struct str lit       static constexpr char value    C       0        static constexpr int size   sl len value        template  lt typename F  typename    P gt  struct concat impl  using type   typename concat impl lt F gt   type  template concat impl lt P    gt   type        template  lt char    CC gt  struct concat impl lt str lit lt CC    gt  gt   using type   str lit lt C     CC    gt         template  lt typename    P gt  using concat   typename concat impl lt P    gt   type      template  lt typename  const char   gt  struct trim str lit impl  template  lt std  size t    I  const char  S gt  struct trim str lit impl lt std  index sequence lt I    gt   S gt        using type   str lit lt S I     gt      template  lt std  size t N  const char  S gt  using trim str lit   typename trim str lit impl lt std  make index sequence lt N gt   S gt   type    define STR LIT str    trim str lit lt   sl len str     str lit lt STR TO VA str  gt   value gt   define STR TO VA str  STR TO VA 16 str 0  STR TO VA 16 str 16  STR TO VA 16 str 32  STR TO VA 16 str 48   define STR TO VA 16 str off  STR TO VA 4 str 0 off  STR TO VA 4 str 4 off  STR TO VA 4 str 8 off  STR TO VA 4 str 12 off   define STR TO VA 4 str off    sl at lt off 0 gt  str    sl at lt off 1 gt  str    sl at lt off 2 gt  str    sl at lt off 3 gt  str   template  lt char    C gt  constexpr str lit lt C    gt  make str lit str lit lt C    gt    return      template  lt std  size t N gt  constexpr auto make str lit const char   amp str  N         return trim str lit lt sl len  const char   amp   N  str   str gt        template  lt std  size t A  std  size t B gt  struct cexpr pow  static constexpr std  size t value   A   cexpr pow lt A B-1 gt   value    template  lt std  size t A gt  struct cexpr pow lt A 0 gt   static constexpr std  size t value   1    template  lt std  size t N  std  size t X  typename   std  make index sequence lt X gt  gt  struct num to str lit impl  template  lt std  size t N  std  size t X  std  size t    Seq gt  struct num to str lit impl lt N  X  std  index sequence lt Seq    gt  gt        static constexpr auto func                 if constexpr  N  gt   cexpr pow lt 10 X gt   value              return num to str lit impl lt N  X 1 gt   func            else             return str lit lt  N   cexpr pow lt 10 X-1-Seq gt   value   10    0      gt              template  lt std  size t N gt  using num to str lit   decltype num to str lit impl lt N 1 gt   func       using spa   str lit lt     gt   using lpa   str lit lt     gt   using rpa   str lit lt     gt   using lbr   str lit lt     gt   using rbr   str lit lt     gt   using ast   str lit lt     gt   using amp   str lit lt   amp   gt   using con   str lit lt  c   o   n   s   t  gt   using vol   str lit lt  v   o   l   a   t   i   l   e  gt   using con vol   con  concat lt spa  vol gt   using nsp   str lit lt         gt   using com   str lit lt     gt   using unk   str lit lt         gt    using c cla   str lit lt  c   l   a   s   s      gt   using c uni   str lit lt  u   n   i   o   n      gt   using c enu   str lit lt  e   n   u   m      gt    template  lt typename T gt  inline constexpr bool ptr or ref   std  is pointer v lt T gt     std  is reference v lt T gt     std  is member pointer v lt T gt   template  lt typename T gt  inline constexpr bool func or arr   std  is function v lt T gt     std  is array v lt T gt    template  lt typename T gt  struct primitive type name  using value   unk     template  lt typename T  typename   std  enable if t lt std  is class v lt T gt  gt  gt  using enable if class   T  template  lt typename T  typename   std  enable if t lt std  is union v lt T gt  gt  gt  using enable if union   T  template  lt typename T  typename   std  enable if t lt std  is enum v  lt T gt  gt  gt  using enable if enum    T  template  lt typename T gt  struct primitive type name lt enable if class lt T gt  gt   using value   c cla    template  lt typename T gt  struct primitive type name lt enable if union lt T gt  gt   using value   c uni    template  lt typename T gt  struct primitive type name lt enable if enum  lt T gt  gt   using value   c enu     template  lt typename T gt  struct type name impl   template  lt typename T gt  using type name lit   std  conditional t lt std  is same v lt typename primitive type name lt T gt   value  template concat lt spa gt                                                                                  typename type name impl lt T gt   l  template concat lt typename type name impl lt T gt   r gt  gt                                               typename primitive type name lt T gt   value                                              typename type name impl lt T gt   l  template concat lt typename type name impl lt T gt   r gt  gt   template  lt typename T gt  inline constexpr const char  type name   type name lit lt T gt   value   template  lt typename T  typename   std  enable if t lt  std  is const v lt T gt   amp  amp   std  is volatile v lt T gt  gt  gt  using enable if no cv   T   template  lt typename T gt  struct type name impl       using l   typename primitive type name lt T gt   value  template concat lt spa gt       using r   str lit lt  gt      template  lt typename T gt  struct type name impl lt const T gt        using new T l   std  conditional t lt type name impl lt T gt   l  size  amp  amp   ptr or ref lt T gt                                          spa  concat lt typename type name impl lt T gt   l gt                                          typename type name impl lt T gt   l gt       using l   std  conditional t lt ptr or ref lt T gt                                    typename new T l  template concat lt con gt                                    con  concat lt new T l gt  gt       using r   typename type name impl lt T gt   r     template  lt typename T gt  struct type name impl lt volatile T gt        using new T l   std  conditional t lt type name impl lt T gt   l  size  amp  amp   ptr or ref lt T gt                                          spa  concat lt typename type name impl lt T gt   l gt                                          typename type name impl lt T gt   l gt       using l   std  conditional t lt ptr or ref lt T gt                                    typename new T l  template concat lt vol gt                                    vol  concat lt new T l gt  gt       using r   typename type name impl lt T gt   r     template  lt typename T gt  struct type name impl lt const volatile T gt        using new T l   std  conditional t lt type name impl lt T gt   l  size  amp  amp   ptr or ref lt T gt                                          spa  concat lt typename type name impl lt T gt   l gt                                          typename type name impl lt T gt   l gt       using l   std  conditional t lt ptr or ref lt T gt                                    typename new T l  template concat lt con vol gt                                    con vol  concat lt new T l gt  gt       using r   typename type name impl lt T gt   r     template  lt typename T gt  struct type name impl lt T   gt        using l   std  conditional t lt func or arr lt T gt                                    typename type name impl lt T gt   l  template concat lt lpa  ast gt                                    typename type name impl lt T gt   l  template concat lt      ast gt  gt       using r   std  conditional t lt func or arr lt T gt                                    rpa  concat lt typename type name impl lt T gt   r gt                                                typename type name impl lt T gt   r gt      template  lt typename T gt  struct type name impl lt T  amp  gt        using l   std  conditional t lt func or arr lt T gt                                    typename type name impl lt T gt   l  template concat lt lpa  amp gt                                    typename type name impl lt T gt   l  template concat lt      amp gt  gt       using r   std  conditional t lt func or arr lt T gt                                    rpa  concat lt typename type name impl lt T gt   r gt                                                typename type name impl lt T gt   r gt      template  lt typename T gt  struct type name impl lt T  amp  amp  gt        using l   std  conditional t lt func or arr lt T gt                                    typename type name impl lt T gt   l  template concat lt lpa  amp  amp gt                                    typename type name impl lt T gt   l  template concat lt      amp  amp gt  gt       using r   std  conditional t lt func or arr lt T gt                                    rpa  concat lt typename type name impl lt T gt   r gt                                                typename type name impl lt T gt   r gt      template  lt typename T  typename C gt  struct type name impl lt T C    gt        using l   std  conditional t lt func or arr lt T gt                                    typename type name impl lt T gt   l  template concat lt lpa  type name lit lt C gt   nsp  ast gt                                    typename type name impl lt T gt   l  template concat lt      type name lit lt C gt   nsp  ast gt  gt       using r   std  conditional t lt func or arr lt T gt                                    rpa  concat lt typename type name impl lt T gt   r gt                                                typename type name impl lt T gt   r gt      template  lt typename T gt  struct type name impl lt enable if no cv lt T   gt  gt        using l   typename type name impl lt T gt   l      using r   lbr  concat lt rbr  typename type name impl lt T gt   r gt      template  lt typename T  std  size t N gt  struct type name impl lt enable if no cv lt T N  gt  gt        using l   typename type name impl lt T gt   l      using r   lbr  concat lt num to str lit lt N gt   rbr  typename type name impl lt T gt   r gt      template  lt typename T gt  struct type name impl lt T   gt        using l   typename type name impl lt T gt   l      using r   lpa  concat lt rpa  typename type name impl lt T gt   r gt      template  lt typename T  typename P1  typename    P gt  struct type name impl lt T P1  P     gt        using l   typename type name impl lt T gt   l      using r   lpa  concat lt type name lit lt P1 gt                             com  concat lt type name lit lt P gt  gt      rpa  typename type name impl lt T gt   r gt        define TYPE NAME t  template  lt  gt  struct primitive type name lt t gt   using value   STR LIT  t

User · Answer

You could use a traits class for this  Something like    include  lt iostream gt  using namespace std   template  lt typename T gt  class type name   public      static const char  name       define DECLARE TYPE NAME x  template lt  gt  const char  type name lt x gt   name    x   define GET TYPE NAME x   type name lt typeof x  gt   name   DECLARE TYPE NAME int    int main         int a   12      cout  lt  lt  GET TYPE NAME a   lt  lt  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 · Answer

include  lt iostream gt   include  lt typeinfo gt  using namespace std   define show type name  t        system   echo     string typeid  t  name          c  filt -t   c str     int main         auto a     one    two    three        cout  lt  lt   Type of a     lt  lt  typeid a  name    lt  lt  endl      cout  lt  lt   Real type of a  n       show type name a       for  auto s   a            if  string s      one                 cout  lt  lt   Type of s     lt  lt  typeid s  name    lt  lt  endl              cout  lt  lt   Real type of s  n               show type name s                     cout  lt  lt  s  lt  lt  endl             int i   5      cout  lt  lt   Type of i     lt  lt  typeid i  name    lt  lt  endl      cout  lt  lt   Real type of i  n       show type name i       return 0      Output   Type of a  St16initializer listIPKcE Real type of a  std  initializer list lt char const  gt  Type of s  PKc Real type of s  char const  one two three Type of i  i Real type of i  int

User · 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  lt typename T gt  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  quot direct quot   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  Instead  you get the macro value for a type with a known name  you can determine what prefix and suffix constitute the wrapping   include  lt string view gt   template  lt typename T gt  constexpr std  string view type name     template  lt  gt  constexpr std  string view type name lt void gt      return  quot void quot      namespace detail    using type name prober   void   template  lt typename T gt  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  quot Unsupported compiler quot   endif    constexpr std  size t wrapped type name prefix length          return wrapped type name lt type name prober gt    find type name lt type name prober gt          constexpr std  size t wrapped type name suffix length          return wrapped type name lt type name prober gt    length            - wrapped type name prefix length            - type name lt type name prober gt    length            namespace detail  template  lt typename T gt  constexpr std  string view type name         constexpr auto wrapped name   detail  wrapped type name lt T gt         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 · Answer

Note that the names generated by the RTTI feature of C   is not portable  For example  the class  MyNamespace  CMyContainer lt int  test MyNamespace  CMyObject gt    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 · Answer

As I challenge I decided to test how far can one go with platform-independent  hopefully  template trickery   The names are assembled completely at compilation time   Which means typeid T  name   couldn t be used  thus you have to explicitly provide names for non-compound types  Otherwise placeholders will be displayed instead    Example usage   TYPE NAME int  TYPE NAME void     You probably should list all primitive types here   TYPE NAME std  string   int main            A simple case     std  cout  lt  lt  type name lt void    int  gt   lt  lt    n          - gt   void     int           Ugly mess case        Note that compiler removes cv-qualifiers from parameters and replaces arrays with pointers      std  cout  lt  lt  type name lt void  std  string    int 3  const int  void     std  string    volatile int const   gt   lt  lt    n          - gt   void  std  string    int   int void     std  string    volatile int  const            A case with undefined types         If a type wasn t TYPE NAME d  it s replaced by a placeholder  one of  class     union     enum   or           std  cout  lt  lt  type name lt std  ostream     int  short  gt   lt  lt    n          - gt   class      int             With appropriate TYPE NAME s  the output would be  std  string     int short        Code    include  lt type traits gt   include  lt utility gt   static constexpr std  size t max str lit len   256   template  lt std  size t I  std  size t N gt  constexpr char sl at const char   amp str  N         if constexpr I  lt  N          return str I       else         return   0      constexpr std  size t sl len const char  str        for  std  size t i   0  i  lt  max str lit len  i            if  str i       0               return i      return 0     template  lt char    C gt  struct str lit       static constexpr char value    C       0        static constexpr int size   sl len value        template  lt typename F  typename    P gt  struct concat impl  using type   typename concat impl lt F gt   type  template concat impl lt P    gt   type        template  lt char    CC gt  struct concat impl lt str lit lt CC    gt  gt   using type   str lit lt C     CC    gt         template  lt typename    P gt  using concat   typename concat impl lt P    gt   type      template  lt typename  const char   gt  struct trim str lit impl  template  lt std  size t    I  const char  S gt  struct trim str lit impl lt std  index sequence lt I    gt   S gt        using type   str lit lt S I     gt      template  lt std  size t N  const char  S gt  using trim str lit   typename trim str lit impl lt std  make index sequence lt N gt   S gt   type    define STR LIT str    trim str lit lt   sl len str     str lit lt STR TO VA str  gt   value gt   define STR TO VA str  STR TO VA 16 str 0  STR TO VA 16 str 16  STR TO VA 16 str 32  STR TO VA 16 str 48   define STR TO VA 16 str off  STR TO VA 4 str 0 off  STR TO VA 4 str 4 off  STR TO VA 4 str 8 off  STR TO VA 4 str 12 off   define STR TO VA 4 str off    sl at lt off 0 gt  str    sl at lt off 1 gt  str    sl at lt off 2 gt  str    sl at lt off 3 gt  str   template  lt char    C gt  constexpr str lit lt C    gt  make str lit str lit lt C    gt    return      template  lt std  size t N gt  constexpr auto make str lit const char   amp str  N         return trim str lit lt sl len  const char   amp   N  str   str gt        template  lt std  size t A  std  size t B gt  struct cexpr pow  static constexpr std  size t value   A   cexpr pow lt A B-1 gt   value    template  lt std  size t A gt  struct cexpr pow lt A 0 gt   static constexpr std  size t value   1    template  lt std  size t N  std  size t X  typename   std  make index sequence lt X gt  gt  struct num to str lit impl  template  lt std  size t N  std  size t X  std  size t    Seq gt  struct num to str lit impl lt N  X  std  index sequence lt Seq    gt  gt        static constexpr auto func                 if constexpr  N  gt   cexpr pow lt 10 X gt   value              return num to str lit impl lt N  X 1 gt   func            else             return str lit lt  N   cexpr pow lt 10 X-1-Seq gt   value   10    0      gt              template  lt std  size t N gt  using num to str lit   decltype num to str lit impl lt N 1 gt   func       using spa   str lit lt     gt   using lpa   str lit lt     gt   using rpa   str lit lt     gt   using lbr   str lit lt     gt   using rbr   str lit lt     gt   using ast   str lit lt     gt   using amp   str lit lt   amp   gt   using con   str lit lt  c   o   n   s   t  gt   using vol   str lit lt  v   o   l   a   t   i   l   e  gt   using con vol   con  concat lt spa  vol gt   using nsp   str lit lt         gt   using com   str lit lt     gt   using unk   str lit lt         gt    using c cla   str lit lt  c   l   a   s   s      gt   using c uni   str lit lt  u   n   i   o   n      gt   using c enu   str lit lt  e   n   u   m      gt    template  lt typename T gt  inline constexpr bool ptr or ref   std  is pointer v lt T gt     std  is reference v lt T gt     std  is member pointer v lt T gt   template  lt typename T gt  inline constexpr bool func or arr   std  is function v lt T gt     std  is array v lt T gt    template  lt typename T gt  struct primitive type name  using value   unk     template  lt typename T  typename   std  enable if t lt std  is class v lt T gt  gt  gt  using enable if class   T  template  lt typename T  typename   std  enable if t lt std  is union v lt T gt  gt  gt  using enable if union   T  template  lt typename T  typename   std  enable if t lt std  is enum v  lt T gt  gt  gt  using enable if enum    T  template  lt typename T gt  struct primitive type name lt enable if class lt T gt  gt   using value   c cla    template  lt typename T gt  struct primitive type name lt enable if union lt T gt  gt   using value   c uni    template  lt typename T gt  struct primitive type name lt enable if enum  lt T gt  gt   using value   c enu     template  lt typename T gt  struct type name impl   template  lt typename T gt  using type name lit   std  conditional t lt std  is same v lt typename primitive type name lt T gt   value  template concat lt spa gt                                                                                  typename type name impl lt T gt   l  template concat lt typename type name impl lt T gt   r gt  gt                                               typename primitive type name lt T gt   value                                              typename type name impl lt T gt   l  template concat lt typename type name impl lt T gt   r gt  gt   template  lt typename T gt  inline constexpr const char  type name   type name lit lt T gt   value   template  lt typename T  typename   std  enable if t lt  std  is const v lt T gt   amp  amp   std  is volatile v lt T gt  gt  gt  using enable if no cv   T   template  lt typename T gt  struct type name impl       using l   typename primitive type name lt T gt   value  template concat lt spa gt       using r   str lit lt  gt      template  lt typename T gt  struct type name impl lt const T gt        using new T l   std  conditional t lt type name impl lt T gt   l  size  amp  amp   ptr or ref lt T gt                                          spa  concat lt typename type name impl lt T gt   l gt                                          typename type name impl lt T gt   l gt       using l   std  conditional t lt ptr or ref lt T gt                                    typename new T l  template concat lt con gt                                    con  concat lt new T l gt  gt       using r   typename type name impl lt T gt   r     template  lt typename T gt  struct type name impl lt volatile T gt        using new T l   std  conditional t lt type name impl lt T gt   l  size  amp  amp   ptr or ref lt T gt                                          spa  concat lt typename type name impl lt T gt   l gt                                          typename type name impl lt T gt   l gt       using l   std  conditional t lt ptr or ref lt T gt                                    typename new T l  template concat lt vol gt                                    vol  concat lt new T l gt  gt       using r   typename type name impl lt T gt   r     template  lt typename T gt  struct type name impl lt const volatile T gt        using new T l   std  conditional t lt type name impl lt T gt   l  size  amp  amp   ptr or ref lt T gt                                          spa  concat lt typename type name impl lt T gt   l gt                                          typename type name impl lt T gt   l gt       using l   std  conditional t lt ptr or ref lt T gt                                    typename new T l  template concat lt con vol gt                                    con vol  concat lt new T l gt  gt       using r   typename type name impl lt T gt   r     template  lt typename T gt  struct type name impl lt T   gt        using l   std  conditional t lt func or arr lt T gt                                    typename type name impl lt T gt   l  template concat lt lpa  ast gt                                    typename type name impl lt T gt   l  template concat lt      ast gt  gt       using r   std  conditional t lt func or arr lt T gt                                    rpa  concat lt typename type name impl lt T gt   r gt                                                typename type name impl lt T gt   r gt      template  lt typename T gt  struct type name impl lt T  amp  gt        using l   std  conditional t lt func or arr lt T gt                                    typename type name impl lt T gt   l  template concat lt lpa  amp gt                                    typename type name impl lt T gt   l  template concat lt      amp gt  gt       using r   std  conditional t lt func or arr lt T gt                                    rpa  concat lt typename type name impl lt T gt   r gt                                                typename type name impl lt T gt   r gt      template  lt typename T gt  struct type name impl lt T  amp  amp  gt        using l   std  conditional t lt func or arr lt T gt                                    typename type name impl lt T gt   l  template concat lt lpa  amp  amp gt                                    typename type name impl lt T gt   l  template concat lt      amp  amp gt  gt       using r   std  conditional t lt func or arr lt T gt                                    rpa  concat lt typename type name impl lt T gt   r gt                                                typename type name impl lt T gt   r gt      template  lt typename T  typename C gt  struct type name impl lt T C    gt        using l   std  conditional t lt func or arr lt T gt                                    typename type name impl lt T gt   l  template concat lt lpa  type name lit lt C gt   nsp  ast gt                                    typename type name impl lt T gt   l  template concat lt      type name lit lt C gt   nsp  ast gt  gt       using r   std  conditional t lt func or arr lt T gt                                    rpa  concat lt typename type name impl lt T gt   r gt                                                typename type name impl lt T gt   r gt      template  lt typename T gt  struct type name impl lt enable if no cv lt T   gt  gt        using l   typename type name impl lt T gt   l      using r   lbr  concat lt rbr  typename type name impl lt T gt   r gt      template  lt typename T  std  size t N gt  struct type name impl lt enable if no cv lt T N  gt  gt        using l   typename type name impl lt T gt   l      using r   lbr  concat lt num to str lit lt N gt   rbr  typename type name impl lt T gt   r gt      template  lt typename T gt  struct type name impl lt T   gt        using l   typename type name impl lt T gt   l      using r   lpa  concat lt rpa  typename type name impl lt T gt   r gt      template  lt typename T  typename P1  typename    P gt  struct type name impl lt T P1  P     gt        using l   typename type name impl lt T gt   l      using r   lpa  concat lt type name lit lt P1 gt                             com  concat lt type name lit lt P gt  gt      rpa  typename type name impl lt T gt   r gt        define TYPE NAME t  template  lt  gt  struct primitive type name lt t gt   using value   STR LIT  t

User · Answer

You could use a traits class for this  Something like    include  lt iostream gt  using namespace std   template  lt typename T gt  class type name   public      static const char  name       define DECLARE TYPE NAME x  template lt  gt  const char  type name lt x gt   name    x   define GET TYPE NAME x   type name lt typeof x  gt   name   DECLARE TYPE NAME int    int main         int a   12      cout  lt  lt  GET TYPE NAME a   lt  lt  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 · 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  lt string view gt  using namespace std   namespace typeName    template  lt typename T gt    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   quot typeName  probe type quot      constexpr string view probe type name elaborated   quot class typeName  probe type quot      constexpr string view probe type name used  wrapped type name lt probe type gt     find  probe type name elaborated     -1   probe type name elaborated   probe type name      constexpr size t prefix size          return wrapped type name lt probe type gt     find  probe type name used          constexpr size t suffix size          return wrapped type name lt probe type gt     length    - prefix size    - probe type name used length            template  lt typename T gt    string view type name          constexpr auto type name   wrapped type name lt T gt           return type name substr  prefix size     type name length    - prefix size    - suffix size              include  lt iostream gt   using typeName  type name  using typeName  probe type   class test   int main        cout  lt  lt  type name lt class test gt      lt  lt  endl     cout  lt  lt  type name lt const int  amp  gt      lt  lt  endl    cout  lt  lt  type name lt unsigned int gt      lt  lt  endl     const int ic   42    const int  pic    amp ic    const int  amp  rpic   pic    cout  lt  lt  type name lt decltype ic  gt      lt  lt  endl    cout  lt  lt  type name lt decltype pic  gt      lt  lt  endl    cout  lt  lt  type name lt decltype rpic  gt      lt  lt  endl     cout  lt  lt  type name lt probe type gt      lt  lt  endl     Output gcc 10 2  test const int   amp  unsigned int const int const int   const int   amp  typeName  probe type  clang 11 0 0  test const int   amp  unsigned int const int const int   const int   amp  typeName  probe type  VS 2019 version 16 7 6  class test const int  amp  unsigned int const int const int  const int  amp  class typeName  probe type

User · Answer

I like Nick s method  A complete form might be this  for all basic data types    template  lt typename T gt  const char  typeof T amp     return  unknown           default template lt  gt  const char  typeof int amp     return  int     template lt  gt  const char  typeof short amp     return  short     template lt  gt  const char  typeof long amp     return  long     template lt  gt  const char  typeof unsigned amp     return  unsigned     template lt  gt  const char  typeof unsigned short amp     return  unsigned short     template lt  gt  const char  typeof unsigned long amp     return  unsigned long     template lt  gt  const char  typeof float amp     return  float     template lt  gt  const char  typeof double amp     return  double     template lt  gt  const char  typeof long double amp     return  long double     template lt  gt  const char  typeof std  string amp     return  String     template lt  gt  const char  typeof char amp     return  char     template lt  gt  const char  typeof signed char amp     return  signed char     template lt  gt  const char  typeof unsigned char amp     return  unsigned char     template lt  gt  const char  typeof char  amp     return  char      template lt  gt  const char  typeof signed char  amp     return  signed char      template lt  gt  const char  typeof unsigned char  amp     return  unsigned char

User · 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  lt string view gt  using namespace std   namespace typeName    template  lt typename T gt    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   quot typeName  probe type quot      constexpr string view probe type name elaborated   quot class typeName  probe type quot      constexpr string view probe type name used  wrapped type name lt probe type gt     find  probe type name elaborated     -1   probe type name elaborated   probe type name      constexpr size t prefix size          return wrapped type name lt probe type gt     find  probe type name used          constexpr size t suffix size          return wrapped type name lt probe type gt     length    - prefix size    - probe type name used length            template  lt typename T gt    string view type name          constexpr auto type name   wrapped type name lt T gt           return type name substr  prefix size     type name length    - prefix size    - suffix size              include  lt iostream gt   using typeName  type name  using typeName  probe type   class test   int main        cout  lt  lt  type name lt class test gt      lt  lt  endl     cout  lt  lt  type name lt const int  amp  gt      lt  lt  endl    cout  lt  lt  type name lt unsigned int gt      lt  lt  endl     const int ic   42    const int  pic    amp ic    const int  amp  rpic   pic    cout  lt  lt  type name lt decltype ic  gt      lt  lt  endl    cout  lt  lt  type name lt decltype pic  gt      lt  lt  endl    cout  lt  lt  type name lt decltype rpic  gt      lt  lt  endl     cout  lt  lt  type name lt probe type gt      lt  lt  endl     Output gcc 10 2  test const int   amp  unsigned int const int const int   const int   amp  typeName  probe type  clang 11 0 0  test const int   amp  unsigned int const int const int   const int   amp  typeName  probe type  VS 2019 version 16 7 6  class test const int  amp  unsigned int const int const int  const int  amp  class typeName  probe type

User · Answer

Very ugly but does the trick if you only want compile time info  e g  for debugging    auto testVar   std  make tuple 1  1 0   abc    decltype testVar   foo  1    Returns   Compilation finished with errors  source cpp  In function  int main     source cpp 5 19  error   foo  is not a member of  std  tuple lt int  double  const char  gt

User · 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  lt string view gt   template  lt typename T gt  constexpr auto type name   noexcept     std  string view name    quot Error  unsupported compiler quot   prefix  suffix   ifdef   clang     name     PRETTY FUNCTION      prefix    quot auto type name    T    quot     suffix    quot   quot    elif defined   GNUC      name     PRETTY FUNCTION      prefix    quot constexpr auto type name    with T    quot     suffix    quot   quot    elif defined  MSC VER    name     FUNCSIG      prefix    quot auto   cdecl type name lt  quot     suffix    quot  gt  void  noexcept quot    endif   name remove prefix prefix size       name remove suffix suffix size       return name     Demo

User · Answer

Try    include  lt typeinfo gt          std  cout  lt  lt  typeid a  name    lt  lt    n     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 · Answer

Very ugly but does the trick if you only want compile time info  e g  for debugging    auto testVar   std  make tuple 1  1 0   abc    decltype testVar   foo  1    Returns   Compilation finished with errors  source cpp  In function  int main     source cpp 5 19  error   foo  is not a member of  std  tuple lt int  double  const char  gt

User · 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  lt typename T gt  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  quot direct quot   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  Instead  you get the macro value for a type with a known name  you can determine what prefix and suffix constitute the wrapping   include  lt string view gt   template  lt typename T gt  constexpr std  string view type name     template  lt  gt  constexpr std  string view type name lt void gt      return  quot void quot      namespace detail    using type name prober   void   template  lt typename T gt  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  quot Unsupported compiler quot   endif    constexpr std  size t wrapped type name prefix length          return wrapped type name lt type name prober gt    find type name lt type name prober gt          constexpr std  size t wrapped type name suffix length          return wrapped type name lt type name prober gt    length            - wrapped type name prefix length            - type name lt type name prober gt    length            namespace detail  template  lt typename T gt  constexpr std  string view type name         constexpr auto wrapped name   detail  wrapped type name lt T gt         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 · 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 lt typename T gt  constexpr void assertIfTestFailed      ifdef   clang       static assert testFn lt T gt      quot Test failed on this used type   quot    PRETTY FUNCTION      elif defined   GNUC        static assert testFn lt T gt      quot Test failed on this used type   quot    PRETTY FUNCTION      elif defined  MSC VER      static assert testFn lt T gt      quot Test failed on this used type   quot    FUNCSIG      else     static assert testFn lt T gt      quot Test failed on this used type  see surrounding logged error for details   quot     endif          MSVC Output  error C2338  Test failed on this used type  void   cdecl assertIfTestFailed lt class BadType gt  void      continued trace of where the erroring code came from

User · Answer

You could use a traits class for this  Something like    include  lt iostream gt  using namespace std   template  lt typename T gt  class type name   public      static const char  name       define DECLARE TYPE NAME x  template lt  gt  const char  type name lt x gt   name    x   define GET TYPE NAME x   type name lt typeof x  gt   name   DECLARE TYPE NAME int    int main         int a   12      cout  lt  lt  GET TYPE NAME a   lt  lt  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 · Answer

include  lt iostream gt   include  lt typeinfo gt  using namespace std   define show type name  t        system   echo     string typeid  t  name          c  filt -t   c str     int main         auto a     one    two    three        cout  lt  lt   Type of a     lt  lt  typeid a  name    lt  lt  endl      cout  lt  lt   Real type of a  n       show type name a       for  auto s   a            if  string s      one                 cout  lt  lt   Type of s     lt  lt  typeid s  name    lt  lt  endl              cout  lt  lt   Real type of s  n               show type name s                     cout  lt  lt  s  lt  lt  endl             int i   5      cout  lt  lt   Type of i     lt  lt  typeid i  name    lt  lt  endl      cout  lt  lt   Real type of i  n       show type name i       return 0      Output   Type of a  St16initializer listIPKcE Real type of a  std  initializer list lt char const  gt  Type of s  PKc Real type of s  char const  one two three Type of i  i Real type of i  int

User · Answer

Note that the names generated by the RTTI feature of C   is not portable  For example  the class  MyNamespace  CMyContainer lt int  test MyNamespace  CMyObject gt    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 · Answer

Note that the names generated by the RTTI feature of C   is not portable  For example  the class  MyNamespace  CMyContainer lt int  test MyNamespace  CMyObject gt    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 · 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 · Answer

You can use templates   template  lt typename T gt  const char  typeof T amp     return  unknown           default template lt  gt  const char  typeof int amp     return  int     template lt  gt  const char  typeof float amp     return  float       In the example above  when the type is not matched it will print  unknown

User · Answer

A more generic solution without function overloading than my previous one:

template<typename T>
std::string TypeOf(T){
    std::string Type="unknown";
    if(std::is_same<T,int>::value) Type="int";
    if(std::is_same<T,std::string>::value) Type="String";
    if(std::is_same<T,MyClass>::value) Type="MyClass";

    return Type;}

Here MyClass is user defined class. More conditions can be added here as well.

Example:

#include <iostream>



class MyClass{};


template<typename T>
std::string TypeOf(T){
    std::string Type="unknown";
    if(std::is_same<T,int>::value) Type="int";
    if(std::is_same<T,std::string>::value) Type="String";
    if(std::is_same<T,MyClass>::value) Type="MyClass";
    return Type;}


int main(){;
    int a=0;
    std::string s="";
    MyClass my;
    std::cout<<TypeOf(a)<<std::endl;
    std::cout<<TypeOf(s)<<std::endl;
    std::cout<<TypeOf(my)<<std::endl;

    return 0;}

Output:

int
String
MyClass

User · Answer

Don t forget to include  lt typeinfo gt   I believe what you are referring to is runtime type identification  You can achieve the above by doing     include  lt iostream gt   include  lt typeinfo gt   using namespace std   int main       int i    cout  lt  lt  typeid i  name      return 0

User · Answer

You can use templates   template  lt typename T gt  const char  typeof T amp     return  unknown           default template lt  gt  const char  typeof int amp     return  int     template lt  gt  const char  typeof float amp     return  float       In the example above  when the type is not matched it will print  unknown

User · 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  lt string view gt  using namespace std   namespace typeName    template  lt typename T gt    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   quot typeName  probe type quot      constexpr string view probe type name elaborated   quot class typeName  probe type quot      constexpr string view probe type name used  wrapped type name lt probe type gt     find  probe type name elaborated     -1   probe type name elaborated   probe type name      constexpr size t prefix size          return wrapped type name lt probe type gt     find  probe type name used          constexpr size t suffix size          return wrapped type name lt probe type gt     length    - prefix size    - probe type name used length            template  lt typename T gt    string view type name          constexpr auto type name   wrapped type name lt T gt           return type name substr  prefix size     type name length    - prefix size    - suffix size              include  lt iostream gt   using typeName  type name  using typeName  probe type   class test   int main        cout  lt  lt  type name lt class test gt      lt  lt  endl     cout  lt  lt  type name lt const int  amp  gt      lt  lt  endl    cout  lt  lt  type name lt unsigned int gt      lt  lt  endl     const int ic   42    const int  pic    amp ic    const int  amp  rpic   pic    cout  lt  lt  type name lt decltype ic  gt      lt  lt  endl    cout  lt  lt  type name lt decltype pic  gt      lt  lt  endl    cout  lt  lt  type name lt decltype rpic  gt      lt  lt  endl     cout  lt  lt  type name lt probe type gt      lt  lt  endl     Output gcc 10 2  test const int   amp  unsigned int const int const int   const int   amp  typeName  probe type  clang 11 0 0  test const int   amp  unsigned int const int const int   const int   amp  typeName  probe type  VS 2019 version 16 7 6  class test const int  amp  unsigned int const int const int  const int  amp  class typeName  probe type

User · Answer

As mentioned  typeid   name   may return a mangled name  In GCC  and some other compilers  you can work around it with the following code    include  lt cxxabi h gt   include  lt iostream gt   include  lt typeinfo gt   include  lt cstdlib gt   namespace some namespace   namespace another namespace      class my class            int main       typedef some namespace  another namespace  my class my type       mangled   std  cout  lt  lt  typeid my type  name    lt  lt  std  endl        unmangled   int status   0    char  demangled   abi    cxa demangle typeid my type  name    0  0   amp status      switch  status        case -1             could not allocate memory       std  cout  lt  lt   Could not allocate memory   lt  lt  std  endl        return -1        break      case -2             invalid name under the C   ABI mangling rules       std  cout  lt  lt   Invalid name   lt  lt  std  endl        return -1        break      case -3             invalid argument       std  cout  lt  lt   Invalid argument to demangle     lt  lt  std  endl        return -1        break      std  cout  lt  lt  demangled  lt  lt  std  endl    free demangled     return 0

User · Answer

Don t forget to include  lt typeinfo gt   I believe what you are referring to is runtime type identification  You can achieve the above by doing     include  lt iostream gt   include  lt typeinfo gt   using namespace std   int main       int i    cout  lt  lt  typeid i  name      return 0

User · Answer

You can use templates   template  lt typename T gt  const char  typeof T amp     return  unknown           default template lt  gt  const char  typeof int amp     return  int     template lt  gt  const char  typeof float amp     return  float       In the example above  when the type is not matched it will print  unknown

User · Answer

Try    include  lt typeinfo gt          std  cout  lt  lt  typeid a  name    lt  lt    n     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 · Answer

As I challenge I decided to test how far can one go with platform-independent  hopefully  template trickery   The names are assembled completely at compilation time   Which means typeid T  name   couldn t be used  thus you have to explicitly provide names for non-compound types  Otherwise placeholders will be displayed instead    Example usage   TYPE NAME int  TYPE NAME void     You probably should list all primitive types here   TYPE NAME std  string   int main            A simple case     std  cout  lt  lt  type name lt void    int  gt   lt  lt    n          - gt   void     int           Ugly mess case        Note that compiler removes cv-qualifiers from parameters and replaces arrays with pointers      std  cout  lt  lt  type name lt void  std  string    int 3  const int  void     std  string    volatile int const   gt   lt  lt    n          - gt   void  std  string    int   int void     std  string    volatile int  const            A case with undefined types         If a type wasn t TYPE NAME d  it s replaced by a placeholder  one of  class     union     enum   or           std  cout  lt  lt  type name lt std  ostream     int  short  gt   lt  lt    n          - gt   class      int             With appropriate TYPE NAME s  the output would be  std  string     int short        Code    include  lt type traits gt   include  lt utility gt   static constexpr std  size t max str lit len   256   template  lt std  size t I  std  size t N gt  constexpr char sl at const char   amp str  N         if constexpr I  lt  N          return str I       else         return   0      constexpr std  size t sl len const char  str        for  std  size t i   0  i  lt  max str lit len  i            if  str i       0               return i      return 0     template  lt char    C gt  struct str lit       static constexpr char value    C       0        static constexpr int size   sl len value        template  lt typename F  typename    P gt  struct concat impl  using type   typename concat impl lt F gt   type  template concat impl lt P    gt   type        template  lt char    CC gt  struct concat impl lt str lit lt CC    gt  gt   using type   str lit lt C     CC    gt         template  lt typename    P gt  using concat   typename concat impl lt P    gt   type      template  lt typename  const char   gt  struct trim str lit impl  template  lt std  size t    I  const char  S gt  struct trim str lit impl lt std  index sequence lt I    gt   S gt        using type   str lit lt S I     gt      template  lt std  size t N  const char  S gt  using trim str lit   typename trim str lit impl lt std  make index sequence lt N gt   S gt   type    define STR LIT str    trim str lit lt   sl len str     str lit lt STR TO VA str  gt   value gt   define STR TO VA str  STR TO VA 16 str 0  STR TO VA 16 str 16  STR TO VA 16 str 32  STR TO VA 16 str 48   define STR TO VA 16 str off  STR TO VA 4 str 0 off  STR TO VA 4 str 4 off  STR TO VA 4 str 8 off  STR TO VA 4 str 12 off   define STR TO VA 4 str off    sl at lt off 0 gt  str    sl at lt off 1 gt  str    sl at lt off 2 gt  str    sl at lt off 3 gt  str   template  lt char    C gt  constexpr str lit lt C    gt  make str lit str lit lt C    gt    return      template  lt std  size t N gt  constexpr auto make str lit const char   amp str  N         return trim str lit lt sl len  const char   amp   N  str   str gt        template  lt std  size t A  std  size t B gt  struct cexpr pow  static constexpr std  size t value   A   cexpr pow lt A B-1 gt   value    template  lt std  size t A gt  struct cexpr pow lt A 0 gt   static constexpr std  size t value   1    template  lt std  size t N  std  size t X  typename   std  make index sequence lt X gt  gt  struct num to str lit impl  template  lt std  size t N  std  size t X  std  size t    Seq gt  struct num to str lit impl lt N  X  std  index sequence lt Seq    gt  gt        static constexpr auto func                 if constexpr  N  gt   cexpr pow lt 10 X gt   value              return num to str lit impl lt N  X 1 gt   func            else             return str lit lt  N   cexpr pow lt 10 X-1-Seq gt   value   10    0      gt              template  lt std  size t N gt  using num to str lit   decltype num to str lit impl lt N 1 gt   func       using spa   str lit lt     gt   using lpa   str lit lt     gt   using rpa   str lit lt     gt   using lbr   str lit lt     gt   using rbr   str lit lt     gt   using ast   str lit lt     gt   using amp   str lit lt   amp   gt   using con   str lit lt  c   o   n   s   t  gt   using vol   str lit lt  v   o   l   a   t   i   l   e  gt   using con vol   con  concat lt spa  vol gt   using nsp   str lit lt         gt   using com   str lit lt     gt   using unk   str lit lt         gt    using c cla   str lit lt  c   l   a   s   s      gt   using c uni   str lit lt  u   n   i   o   n      gt   using c enu   str lit lt  e   n   u   m      gt    template  lt typename T gt  inline constexpr bool ptr or ref   std  is pointer v lt T gt     std  is reference v lt T gt     std  is member pointer v lt T gt   template  lt typename T gt  inline constexpr bool func or arr   std  is function v lt T gt     std  is array v lt T gt    template  lt typename T gt  struct primitive type name  using value   unk     template  lt typename T  typename   std  enable if t lt std  is class v lt T gt  gt  gt  using enable if class   T  template  lt typename T  typename   std  enable if t lt std  is union v lt T gt  gt  gt  using enable if union   T  template  lt typename T  typename   std  enable if t lt std  is enum v  lt T gt  gt  gt  using enable if enum    T  template  lt typename T gt  struct primitive type name lt enable if class lt T gt  gt   using value   c cla    template  lt typename T gt  struct primitive type name lt enable if union lt T gt  gt   using value   c uni    template  lt typename T gt  struct primitive type name lt enable if enum  lt T gt  gt   using value   c enu     template  lt typename T gt  struct type name impl   template  lt typename T gt  using type name lit   std  conditional t lt std  is same v lt typename primitive type name lt T gt   value  template concat lt spa gt                                                                                  typename type name impl lt T gt   l  template concat lt typename type name impl lt T gt   r gt  gt                                               typename primitive type name lt T gt   value                                              typename type name impl lt T gt   l  template concat lt typename type name impl lt T gt   r gt  gt   template  lt typename T gt  inline constexpr const char  type name   type name lit lt T gt   value   template  lt typename T  typename   std  enable if t lt  std  is const v lt T gt   amp  amp   std  is volatile v lt T gt  gt  gt  using enable if no cv   T   template  lt typename T gt  struct type name impl       using l   typename primitive type name lt T gt   value  template concat lt spa gt       using r   str lit lt  gt      template  lt typename T gt  struct type name impl lt const T gt        using new T l   std  conditional t lt type name impl lt T gt   l  size  amp  amp   ptr or ref lt T gt                                          spa  concat lt typename type name impl lt T gt   l gt                                          typename type name impl lt T gt   l gt       using l   std  conditional t lt ptr or ref lt T gt                                    typename new T l  template concat lt con gt                                    con  concat lt new T l gt  gt       using r   typename type name impl lt T gt   r     template  lt typename T gt  struct type name impl lt volatile T gt        using new T l   std  conditional t lt type name impl lt T gt   l  size  amp  amp   ptr or ref lt T gt                                          spa  concat lt typename type name impl lt T gt   l gt                                          typename type name impl lt T gt   l gt       using l   std  conditional t lt ptr or ref lt T gt                                    typename new T l  template concat lt vol gt                                    vol  concat lt new T l gt  gt       using r   typename type name impl lt T gt   r     template  lt typename T gt  struct type name impl lt const volatile T gt        using new T l   std  conditional t lt type name impl lt T gt   l  size  amp  amp   ptr or ref lt T gt                                          spa  concat lt typename type name impl lt T gt   l gt                                          typename type name impl lt T gt   l gt       using l   std  conditional t lt ptr or ref lt T gt                                    typename new T l  template concat lt con vol gt                                    con vol  concat lt new T l gt  gt       using r   typename type name impl lt T gt   r     template  lt typename T gt  struct type name impl lt T   gt        using l   std  conditional t lt func or arr lt T gt                                    typename type name impl lt T gt   l  template concat lt lpa  ast gt                                    typename type name impl lt T gt   l  template concat lt      ast gt  gt       using r   std  conditional t lt func or arr lt T gt                                    rpa  concat lt typename type name impl lt T gt   r gt                                                typename type name impl lt T gt   r gt      template  lt typename T gt  struct type name impl lt T  amp  gt        using l   std  conditional t lt func or arr lt T gt                                    typename type name impl lt T gt   l  template concat lt lpa  amp gt                                    typename type name impl lt T gt   l  template concat lt      amp gt  gt       using r   std  conditional t lt func or arr lt T gt                                    rpa  concat lt typename type name impl lt T gt   r gt                                                typename type name impl lt T gt   r gt      template  lt typename T gt  struct type name impl lt T  amp  amp  gt        using l   std  conditional t lt func or arr lt T gt                                    typename type name impl lt T gt   l  template concat lt lpa  amp  amp gt                                    typename type name impl lt T gt   l  template concat lt      amp  amp gt  gt       using r   std  conditional t lt func or arr lt T gt                                    rpa  concat lt typename type name impl lt T gt   r gt                                                typename type name impl lt T gt   r gt      template  lt typename T  typename C gt  struct type name impl lt T C    gt        using l   std  conditional t lt func or arr lt T gt                                    typename type name impl lt T gt   l  template concat lt lpa  type name lit lt C gt   nsp  ast gt                                    typename type name impl lt T gt   l  template concat lt      type name lit lt C gt   nsp  ast gt  gt       using r   std  conditional t lt func or arr lt T gt                                    rpa  concat lt typename type name impl lt T gt   r gt                                                typename type name impl lt T gt   r gt      template  lt typename T gt  struct type name impl lt enable if no cv lt T   gt  gt        using l   typename type name impl lt T gt   l      using r   lbr  concat lt rbr  typename type name impl lt T gt   r gt      template  lt typename T  std  size t N gt  struct type name impl lt enable if no cv lt T N  gt  gt        using l   typename type name impl lt T gt   l      using r   lbr  concat lt num to str lit lt N gt   rbr  typename type name impl lt T gt   r gt      template  lt typename T gt  struct type name impl lt T   gt        using l   typename type name impl lt T gt   l      using r   lpa  concat lt rpa  typename type name impl lt T gt   r gt      template  lt typename T  typename P1  typename    P gt  struct type name impl lt T P1  P     gt        using l   typename type name impl lt T gt   l      using r   lpa  concat lt type name lit lt P1 gt                             com  concat lt type name lit lt P gt  gt      rpa  typename type name impl lt T gt   r gt        define TYPE NAME t  template  lt  gt  struct primitive type name lt t gt   using value   STR LIT  t

User · 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  lt typename T gt  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  quot direct quot   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  Instead  you get the macro value for a type with a known name  you can determine what prefix and suffix constitute the wrapping   include  lt string view gt   template  lt typename T gt  constexpr std  string view type name     template  lt  gt  constexpr std  string view type name lt void gt      return  quot void quot      namespace detail    using type name prober   void   template  lt typename T gt  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  quot Unsupported compiler quot   endif    constexpr std  size t wrapped type name prefix length          return wrapped type name lt type name prober gt    find type name lt type name prober gt          constexpr std  size t wrapped type name suffix length          return wrapped type name lt type name prober gt    length            - wrapped type name prefix length            - type name lt type name prober gt    length            namespace detail  template  lt typename T gt  constexpr std  string view type name         constexpr auto wrapped name   detail  wrapped type name lt T gt         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 · Answer

Don t forget to include  lt typeinfo gt   I believe what you are referring to is runtime type identification  You can achieve the above by doing     include  lt iostream gt   include  lt typeinfo gt   using namespace std   int main       int i    cout  lt  lt  typeid i  name      return 0

User · Answer

Don t forget to include  lt typeinfo gt   I believe what you are referring to is runtime type identification  You can achieve the above by doing     include  lt iostream gt   include  lt typeinfo gt   using namespace std   int main       int i    cout  lt  lt  typeid i  name      return 0

User · Answer

include  lt iostream gt   include  lt typeinfo gt  using namespace std   define show type name  t        system   echo     string typeid  t  name          c  filt -t   c str     int main         auto a     one    two    three        cout  lt  lt   Type of a     lt  lt  typeid a  name    lt  lt  endl      cout  lt  lt   Real type of a  n       show type name a       for  auto s   a            if  string s      one                 cout  lt  lt   Type of s     lt  lt  typeid s  name    lt  lt  endl              cout  lt  lt   Real type of s  n               show type name s                     cout  lt  lt  s  lt  lt  endl             int i   5      cout  lt  lt   Type of i     lt  lt  typeid i  name    lt  lt  endl      cout  lt  lt   Real type of i  n       show type name i       return 0      Output   Type of a  St16initializer listIPKcE Real type of a  std  initializer list lt char const  gt  Type of s  PKc Real type of s  char const  one two three Type of i  i Real type of i  int

User · 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  lt  lt  typeid ci  name    lt  lt    n     For me outputs   i   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  lt typename T gt  std  string type name      which would be used like this   const int ci   0  std  cout  lt  lt  type name lt decltype ci  gt     lt  lt    n     and for me outputs   int const    lt disclaimer gt  I have not tested this on MSVC   lt  disclaimer gt   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  lt type traits gt   include  lt typeinfo gt   ifndef  MSC VER     include  lt cxxabi h gt   endif  include  lt memory gt   include  lt string gt   include  lt cstdlib gt   template  lt class T gt  std  string type name         typedef typename std  remove reference lt T gt   type TR      std  unique ptr lt char  void    void   gt  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 lt TR gt   value          r      const       if  std  is volatile lt TR gt   value          r      volatile       if  std  is lvalue reference lt T gt   value          r      amp        else if  std  is rvalue reference lt T gt   value          r      amp  amp        return r      The Results  With this solution I can do this   int amp  foo lref    int amp  amp  foo rref    int foo value     int main         int i   0      const int ci   0      std  cout  lt  lt   decltype i  is    lt  lt  type name lt decltype i  gt     lt  lt    n       std  cout  lt  lt   decltype  i   is    lt  lt  type name lt decltype  i   gt     lt  lt    n       std  cout  lt  lt   decltype ci  is    lt  lt  type name lt decltype ci  gt     lt  lt    n       std  cout  lt  lt   decltype  ci   is    lt  lt  type name lt decltype  ci   gt     lt  lt    n       std  cout  lt  lt   decltype static cast lt int amp  gt  i   is    lt  lt  type name lt decltype static cast lt int amp  gt  i   gt     lt  lt    n       std  cout  lt  lt   decltype static cast lt int amp  amp  gt  i   is    lt  lt  type name lt decltype static cast lt int amp  amp  gt  i   gt     lt  lt    n       std  cout  lt  lt   decltype static cast lt int gt  i   is    lt  lt  type name lt decltype static cast lt int gt  i   gt     lt  lt    n       std  cout  lt  lt   decltype foo lref    is    lt  lt  type name lt decltype foo lref    gt     lt  lt    n       std  cout  lt  lt   decltype foo rref    is    lt  lt  type name lt decltype foo rref    gt     lt  lt    n       std  cout  lt  lt   decltype foo value    is    lt  lt  type name lt decltype foo value    gt     lt  lt    n       and the output is   decltype i  is int decltype  i   is int amp  decltype ci  is int const decltype  ci   is int const amp  decltype static cast lt int amp  gt  i   is int amp  decltype static cast lt int amp  amp  gt  i   is int amp  amp  decltype static cast lt int gt  i   is int decltype foo lref    is int amp  decltype foo rref    is int amp  amp  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 lt int amp  gt  i   is int decltype static cast lt int amp  amp  gt  i   is int decltype static cast lt int gt  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  lt cstddef gt   include  lt stdexcept gt   include  lt cstring gt   include  lt ostream gt    ifndef  MSC VER    if   cplusplus  lt  201103      define CONSTEXPR11 TN      define CONSTEXPR14 TN      define NOEXCEPT TN    elif   cplusplus  lt  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  lt  1900      define CONSTEXPR11 TN      define CONSTEXPR14 TN      define NOEXCEPT TN    elif  MSC VER  lt  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  lt std  size t N gt      CONSTEXPR11 TN static string const char  amp 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  lt  sz    p  n    throw std  out of range  static string              inline std  ostream amp  operator lt  lt  std  ostream amp  os  static string const amp  s        return os write s data    s size        template  lt class T gt  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  lt  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  lt class T gt  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  lt  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 · Answer

Very ugly but does the trick if you only want compile time info  e g  for debugging    auto testVar   std  make tuple 1  1 0   abc    decltype testVar   foo  1    Returns   Compilation finished with errors  source cpp  In function  int main     source cpp 5 19  error   foo  is not a member of  std  tuple lt int  double  const char  gt

User · Answer

You could use a traits class for this  Something like    include  lt iostream gt  using namespace std   template  lt typename T gt  class type name   public      static const char  name       define DECLARE TYPE NAME x  template lt  gt  const char  type name lt x gt   name    x   define GET TYPE NAME x   type name lt typeof x  gt   name   DECLARE TYPE NAME int    int main         int a   12      cout  lt  lt  GET TYPE NAME a   lt  lt  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 · 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  lt typename T gt  struct type as string      declare your Wibble type  probably with definition of Wibble  template  lt  gt  struct type as string lt Wibble gt        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  lt typename T gt  const char  get type as string const T amp         return type as string lt T gt   value

User · 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  lt iostream gt   include  lt boost type index hpp gt   using namespace std  using boost  typeindex  type id with cvr   int main       int i   0    const int ci   0    cout  lt  lt   decltype i  is    lt  lt  type id with cvr lt decltype i  gt    pretty name    lt  lt    n     cout  lt  lt   decltype  i   is    lt  lt  type id with cvr lt decltype  i   gt    pretty name    lt  lt    n     cout  lt  lt   decltype ci  is    lt  lt  type id with cvr lt decltype ci  gt    pretty name    lt  lt    n     cout  lt  lt   decltype  ci   is    lt  lt  type id with cvr lt decltype  ci   gt    pretty name    lt  lt    n     cout  lt  lt   decltype std  move i   is    lt  lt  type id with cvr lt decltype std  move i   gt    pretty name    lt  lt    n     cout  lt  lt   decltype std  static cast lt int amp  amp  gt  i   is    lt  lt  type id with cvr lt decltype static cast lt int amp  amp  gt  i   gt    pretty name    lt  lt    n     return 0

User · Answer

I like Nick s method  A complete form might be this  for all basic data types    template  lt typename T gt  const char  typeof T amp     return  unknown           default template lt  gt  const char  typeof int amp     return  int     template lt  gt  const char  typeof short amp     return  short     template lt  gt  const char  typeof long amp     return  long     template lt  gt  const char  typeof unsigned amp     return  unsigned     template lt  gt  const char  typeof unsigned short amp     return  unsigned short     template lt  gt  const char  typeof unsigned long amp     return  unsigned long     template lt  gt  const char  typeof float amp     return  float     template lt  gt  const char  typeof double amp     return  double     template lt  gt  const char  typeof long double amp     return  long double     template lt  gt  const char  typeof std  string amp     return  String     template lt  gt  const char  typeof char amp     return  char     template lt  gt  const char  typeof signed char amp     return  signed char     template lt  gt  const char  typeof unsigned char amp     return  unsigned char     template lt  gt  const char  typeof char  amp     return  char      template lt  gt  const char  typeof signed char  amp     return  signed char      template lt  gt  const char  typeof unsigned char  amp     return  unsigned char

User · 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  lt iostream gt   include  lt boost type index hpp gt   using namespace std  using boost  typeindex  type id with cvr   int main       int i   0    const int ci   0    cout  lt  lt   decltype i  is    lt  lt  type id with cvr lt decltype i  gt    pretty name    lt  lt    n     cout  lt  lt   decltype  i   is    lt  lt  type id with cvr lt decltype  i   gt    pretty name    lt  lt    n     cout  lt  lt   decltype ci  is    lt  lt  type id with cvr lt decltype ci  gt    pretty name    lt  lt    n     cout  lt  lt   decltype  ci   is    lt  lt  type id with cvr lt decltype  ci   gt    pretty name    lt  lt    n     cout  lt  lt   decltype std  move i   is    lt  lt  type id with cvr lt decltype std  move i   gt    pretty name    lt  lt    n     cout  lt  lt   decltype std  static cast lt int amp  amp  gt  i   is    lt  lt  type id with cvr lt decltype static cast lt int amp  amp  gt  i   gt    pretty name    lt  lt    n     return 0

User · Answer

You can use templates   template  lt typename T gt  const char  typeof T amp     return  unknown           default template lt  gt  const char  typeof int amp     return  int     template lt  gt  const char  typeof float amp     return  float       In the example above  when the type is not matched it will print  unknown

User · 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  lt typename T gt  struct type as string      declare your Wibble type  probably with definition of Wibble  template  lt  gt  struct type as string lt Wibble gt        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  lt typename T gt  const char  get type as string const T amp         return type as string lt T gt   value

User · 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 lt typename T gt  constexpr void assertIfTestFailed      ifdef   clang       static assert testFn lt T gt      quot Test failed on this used type   quot    PRETTY FUNCTION      elif defined   GNUC        static assert testFn lt T gt      quot Test failed on this used type   quot    PRETTY FUNCTION      elif defined  MSC VER      static assert testFn lt T gt      quot Test failed on this used type   quot    FUNCSIG      else     static assert testFn lt T gt      quot Test failed on this used type  see surrounding logged error for details   quot     endif          MSVC Output  error C2338  Test failed on this used type  void   cdecl assertIfTestFailed lt class BadType gt  void      continued trace of where the erroring code came from

User · Answer

Note that the names generated by the RTTI feature of C   is not portable  For example  the class  MyNamespace  CMyContainer lt int  test MyNamespace  CMyObject gt    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 · Answer

Don t forget to include  lt typeinfo gt   I believe what you are referring to is runtime type identification  You can achieve the above by doing     include  lt iostream gt   include  lt typeinfo gt   using namespace std   int main       int i    cout  lt  lt  typeid i  name      return 0

User · Answer

Try    include  lt typeinfo gt          std  cout  lt  lt  typeid a  name    lt  lt    n     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 · Answer

As mentioned  typeid   name   may return a mangled name  In GCC  and some other compilers  you can work around it with the following code    include  lt cxxabi h gt   include  lt iostream gt   include  lt typeinfo gt   include  lt cstdlib gt   namespace some namespace   namespace another namespace      class my class            int main       typedef some namespace  another namespace  my class my type       mangled   std  cout  lt  lt  typeid my type  name    lt  lt  std  endl        unmangled   int status   0    char  demangled   abi    cxa demangle typeid my type  name    0  0   amp status      switch  status        case -1             could not allocate memory       std  cout  lt  lt   Could not allocate memory   lt  lt  std  endl        return -1        break      case -2             invalid name under the C   ABI mangling rules       std  cout  lt  lt   Invalid name   lt  lt  std  endl        return -1        break      case -3             invalid argument       std  cout  lt  lt   Invalid argument to demangle     lt  lt  std  endl        return -1        break      std  cout  lt  lt  demangled  lt  lt  std  endl    free demangled     return 0

User · 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 · Answer

You can use templates   template  lt typename T gt  const char  typeof T amp     return  unknown           default template lt  gt  const char  typeof int amp     return  int     template lt  gt  const char  typeof float amp     return  float       In the example above  when the type is not matched it will print  unknown

User · Answer

You could use a traits class for this  Something like    include  lt iostream gt  using namespace std   template  lt typename T gt  class type name   public      static const char  name       define DECLARE TYPE NAME x  template lt  gt  const char  type name lt x gt   name    x   define GET TYPE NAME x   type name lt typeof x  gt   name   DECLARE TYPE NAME int    int main         int a   12      cout  lt  lt  GET TYPE NAME a   lt  lt  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 · 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  lt typename T gt  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  quot direct quot   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  Instead  you get the macro value for a type with a known name  you can determine what prefix and suffix constitute the wrapping   include  lt string view gt   template  lt typename T gt  constexpr std  string view type name     template  lt  gt  constexpr std  string view type name lt void gt      return  quot void quot      namespace detail    using type name prober   void   template  lt typename T gt  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  quot Unsupported compiler quot   endif    constexpr std  size t wrapped type name prefix length          return wrapped type name lt type name prober gt    find type name lt type name prober gt          constexpr std  size t wrapped type name suffix length          return wrapped type name lt type name prober gt    length            - wrapped type name prefix length            - type name lt type name prober gt    length            namespace detail  template  lt typename T gt  constexpr std  string view type name         constexpr auto wrapped name   detail  wrapped type name lt T gt         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 · 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  lt typename T gt  struct type as string      declare your Wibble type  probably with definition of Wibble  template  lt  gt  struct type as string lt Wibble gt        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  lt typename T gt  const char  get type as string const T amp         return type as string lt T gt   value

User · 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 · Answer

You may also use c  filt with option -t  type  to demangle the type name    include  lt iostream gt   include  lt typeinfo gt   include  lt string gt   using namespace std   int main       auto x   1    string my type   typeid x  name      system   echo     my type       c  filt -t   c str       return 0      Tested on linux only

User · Answer

include  lt iostream gt   include  lt typeinfo gt  using namespace std   define show type name  t        system   echo     string typeid  t  name          c  filt -t   c str     int main         auto a     one    two    three        cout  lt  lt   Type of a     lt  lt  typeid a  name    lt  lt  endl      cout  lt  lt   Real type of a  n       show type name a       for  auto s   a            if  string s      one                 cout  lt  lt   Type of s     lt  lt  typeid s  name    lt  lt  endl              cout  lt  lt   Real type of s  n               show type name s                     cout  lt  lt  s  lt  lt  endl             int i   5      cout  lt  lt   Type of i     lt  lt  typeid i  name    lt  lt  endl      cout  lt  lt   Real type of i  n       show type name i       return 0      Output   Type of a  St16initializer listIPKcE Real type of a  std  initializer list lt char const  gt  Type of s  PKc Real type of s  char const  one two three Type of i  i Real type of i  int

User · 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  lt string view gt   template  lt typename T gt  constexpr auto type name   noexcept     std  string view name    quot Error  unsupported compiler quot   prefix  suffix   ifdef   clang     name     PRETTY FUNCTION      prefix    quot auto type name    T    quot     suffix    quot   quot    elif defined   GNUC      name     PRETTY FUNCTION      prefix    quot constexpr auto type name    with T    quot     suffix    quot   quot    elif defined  MSC VER    name     FUNCSIG      prefix    quot auto   cdecl type name lt  quot     suffix    quot  gt  void  noexcept quot    endif   name remove prefix prefix size       name remove suffix suffix size       return name     Demo

User · Answer

Don t forget to include  lt typeinfo gt   I believe what you are referring to is runtime type identification  You can achieve the above by doing     include  lt iostream gt   include  lt typeinfo gt   using namespace std   int main       int i    cout  lt  lt  typeid i  name      return 0

User · Answer

You could use a traits class for this  Something like    include  lt iostream gt  using namespace std   template  lt typename T gt  class type name   public      static const char  name       define DECLARE TYPE NAME x  template lt  gt  const char  type name lt x gt   name    x   define GET TYPE NAME x   type name lt typeof x  gt   name   DECLARE TYPE NAME int    int main         int a   12      cout  lt  lt  GET TYPE NAME a   lt  lt  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 · Answer

You can use templates   template  lt typename T gt  const char  typeof T amp     return  unknown           default template lt  gt  const char  typeof int amp     return  int     template lt  gt  const char  typeof float amp     return  float       In the example above  when the type is not matched it will print  unknown

User · 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  lt typename T gt  struct type as string      declare your Wibble type  probably with definition of Wibble  template  lt  gt  struct type as string lt Wibble gt        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  lt typename T gt  const char  get type as string const T amp         return type as string lt T gt   value

User · Answer

Very ugly but does the trick if you only want compile time info  e g  for debugging    auto testVar   std  make tuple 1  1 0   abc    decltype testVar   foo  1    Returns   Compilation finished with errors  source cpp  In function  int main     source cpp 5 19  error   foo  is not a member of  std  tuple lt int  double  const char  gt

User · Answer

Note that the names generated by the RTTI feature of C   is not portable  For example  the class  MyNamespace  CMyContainer lt int  test MyNamespace  CMyObject gt    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 · Answer

You could use a traits class for this  Something like    include  lt iostream gt  using namespace std   template  lt typename T gt  class type name   public      static const char  name       define DECLARE TYPE NAME x  template lt  gt  const char  type name lt x gt   name    x   define GET TYPE NAME x   type name lt typeof x  gt   name   DECLARE TYPE NAME int    int main         int a   12      cout  lt  lt  GET TYPE NAME a   lt  lt  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

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

Examples related to c++

Examples related to variables

Examples related to c++11

Examples related to typeof