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

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 << type_name<void(*)(int)> << '\n';
    // -> `void (*)(int)`

    // Ugly mess case
    // Note that compiler removes cv-qualifiers from parameters and replaces arrays with pointers.
    std::cout << type_name<void (std::string::*(int[3],const int, void (*)(std::string)))(volatile int*const*)> << '\n';
    // -> `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 << type_name<std::ostream (*)(int, short)> << '\n';
    // -> `class? (*)(int,??)`
    // With appropriate TYPE_NAME's, the output would be `std::string (*)(int,short)`.
}

Code:

#include <type_traits>
#include <utility>

static constexpr std::size_t max_str_lit_len = 256;

template <std::size_t I, std::size_t N> constexpr char sl_at(const char (&str)[N])
{
    if constexpr(I < N)
        return str[I];
    else
        return '\0';
}

constexpr std::size_t sl_len(const char *str)
{
    for (std::size_t i = 0; i < max_str_lit_len; i++)
        if (str[i] == '\0')
            return i;
    return 0;
}

template <char ...C> struct str_lit
{
    static constexpr char value[] {C..., '\0'};
    static constexpr int size = sl_len(value);

    template <typename F, typename ...P> struct concat_impl {using type = typename concat_impl<F>::type::template concat_impl<P...>::type;};
    template <char ...CC> struct concat_impl<str_lit<CC...>> {using type = str_lit<C..., CC...>;};
    template <typename ...P> using concat = typename concat_impl<P...>::type;
};

template <typename, const char *> struct trim_str_lit_impl;
template <std::size_t ...I, const char *S> struct trim_str_lit_impl<std::index_sequence<I...>, S>
{
    using type = str_lit<S[I]...>;
};
template <std::size_t N, const char *S> using trim_str_lit = typename trim_str_lit_impl<std::make_index_sequence<N>, S>::type;

#define STR_LIT(str) ::trim_str_lit<::sl_len(str), ::str_lit<STR_TO_VA(str)>::value>
#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<off+0>(str),::sl_at<off+1>(str),::sl_at<off+2>(str),::sl_at<off+3>(str)

template <char ...C> constexpr str_lit<C...> make_str_lit(str_lit<C...>) {return {};}
template <std::size_t N> constexpr auto make_str_lit(const char (&str)[N])
{
    return trim_str_lit<sl_len((const char (&)[N])str), str>{};
}

template <std::size_t A, std::size_t B> struct cexpr_pow {static constexpr std::size_t value = A * cexpr_pow<A,B-1>::value;};
template <std::size_t A> struct cexpr_pow<A,0> {static constexpr std::size_t value = 1;};
template <std::size_t N, std::size_t X, typename = std::make_index_sequence<X>> struct num_to_str_lit_impl;
template <std::size_t N, std::size_t X, std::size_t ...Seq> struct num_to_str_lit_impl<N, X, std::index_sequence<Seq...>>
{
    static constexpr auto func()
    {
        if constexpr (N >= cexpr_pow<10,X>::value)
            return num_to_str_lit_impl<N, X+1>::func();
        else
            return str_lit<(N / cexpr_pow<10,X-1-Seq>::value % 10 + '0')...>{};
    }
};
template <std::size_t N> using num_to_str_lit = decltype(num_to_str_lit_impl<N,1>::func());


using spa = str_lit<' '>;
using lpa = str_lit<'('>;
using rpa = str_lit<')'>;
using lbr = str_lit<'['>;
using rbr = str_lit<']'>;
using ast = str_lit<'*'>;
using amp = str_lit<'&'>;
using con = str_lit<'c','o','n','s','t'>;
using vol = str_lit<'v','o','l','a','t','i','l','e'>;
using con_vol = con::concat<spa, vol>;
using nsp = str_lit<':',':'>;
using com = str_lit<','>;
using unk = str_lit<'?','?'>;

using c_cla = str_lit<'c','l','a','s','s','?'>;
using c_uni = str_lit<'u','n','i','o','n','?'>;
using c_enu = str_lit<'e','n','u','m','?'>;

template <typename T> inline constexpr bool ptr_or_ref = std::is_pointer_v<T> || std::is_reference_v<T> || std::is_member_pointer_v<T>;
template <typename T> inline constexpr bool func_or_arr = std::is_function_v<T> || std::is_array_v<T>;

template <typename T> struct primitive_type_name {using value = unk;};

template <typename T, typename = std::enable_if_t<std::is_class_v<T>>> using enable_if_class = T;
template <typename T, typename = std::enable_if_t<std::is_union_v<T>>> using enable_if_union = T;
template <typename T, typename = std::enable_if_t<std::is_enum_v <T>>> using enable_if_enum  = T;
template <typename T> struct primitive_type_name<enable_if_class<T>> {using value = c_cla;};
template <typename T> struct primitive_type_name<enable_if_union<T>> {using value = c_uni;};
template <typename T> struct primitive_type_name<enable_if_enum <T>> {using value = c_enu;};

template <typename T> struct type_name_impl;

template <typename T> using type_name_lit = std::conditional_t<std::is_same_v<typename primitive_type_name<T>::value::template concat<spa>,
                                                                               typename type_name_impl<T>::l::template concat<typename type_name_impl<T>::r>>,
                                            typename primitive_type_name<T>::value,
                                            typename type_name_impl<T>::l::template concat<typename type_name_impl<T>::r>>;
template <typename T> inline constexpr const char *type_name = type_name_lit<T>::value;

template <typename T, typename = std::enable_if_t<!std::is_const_v<T> && !std::is_volatile_v<T>>> using enable_if_no_cv = T;

template <typename T> struct type_name_impl
{
    using l = typename primitive_type_name<T>::value::template concat<spa>;
    using r = str_lit<>;
};
template <typename T> struct type_name_impl<const T>
{
    using new_T_l = std::conditional_t<type_name_impl<T>::l::size && !ptr_or_ref<T>,
                                       spa::concat<typename type_name_impl<T>::l>,
                                       typename type_name_impl<T>::l>;
    using l = std::conditional_t<ptr_or_ref<T>,
                                 typename new_T_l::template concat<con>,
                                 con::concat<new_T_l>>;
    using r = typename type_name_impl<T>::r;
};
template <typename T> struct type_name_impl<volatile T>
{
    using new_T_l = std::conditional_t<type_name_impl<T>::l::size && !ptr_or_ref<T>,
                                       spa::concat<typename type_name_impl<T>::l>,
                                       typename type_name_impl<T>::l>;
    using l = std::conditional_t<ptr_or_ref<T>,
                                 typename new_T_l::template concat<vol>,
                                 vol::concat<new_T_l>>;
    using r = typename type_name_impl<T>::r;
};
template <typename T> struct type_name_impl<const volatile T>
{
    using new_T_l = std::conditional_t<type_name_impl<T>::l::size && !ptr_or_ref<T>,
                                       spa::concat<typename type_name_impl<T>::l>,
                                       typename type_name_impl<T>::l>;
    using l = std::conditional_t<ptr_or_ref<T>,
                                 typename new_T_l::template concat<con_vol>,
                                 con_vol::concat<new_T_l>>;
    using r = typename type_name_impl<T>::r;
};
template <typename T> struct type_name_impl<T *>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, ast>,
                                 typename type_name_impl<T>::l::template concat<     ast>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<T &>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, amp>,
                                 typename type_name_impl<T>::l::template concat<     amp>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<T &&>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, amp, amp>,
                                 typename type_name_impl<T>::l::template concat<     amp, amp>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T, typename C> struct type_name_impl<T C::*>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, type_name_lit<C>, nsp, ast>,
                                 typename type_name_impl<T>::l::template concat<     type_name_lit<C>, nsp, ast>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<enable_if_no_cv<T[]>>
{
    using l = typename type_name_impl<T>::l;
    using r = lbr::concat<rbr, typename type_name_impl<T>::r>;
};
template <typename T, std::size_t N> struct type_name_impl<enable_if_no_cv<T[N]>>
{
    using l = typename type_name_impl<T>::l;
    using r = lbr::concat<num_to_str_lit<N>, rbr, typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<T()>
{
    using l = typename type_name_impl<T>::l;
    using r = lpa::concat<rpa, typename type_name_impl<T>::r>;
};
template <typename T, typename P1, typename ...P> struct type_name_impl<T(P1, P...)>
{
    using l = typename type_name_impl<T>::l;
    using r = lpa::concat<type_name_lit<P1>,
                          com::concat<type_name_lit<P>>..., rpa, typename type_name_impl<T>::r>;
};

#define TYPE_NAME(t) template <> struct primitive_type_name<t> {using value = STR_LIT(#t);};

User · Answer

A more generic solution without function overloading than my previous one   template lt typename T gt  std  string TypeOf T       std  string Type  unknown       if std  is same lt T int gt   value  Type  int       if std  is same lt T std  string gt   value  Type  String       if std  is same lt T MyClass gt   value  Type  MyClass        return Type     Here MyClass is user defined class  More conditions can be added here as well   Example    include  lt iostream gt     class MyClass      template lt typename T gt  std  string TypeOf T       std  string Type  unknown       if std  is same lt T int gt   value  Type  int       if std  is same lt T std  string gt   value  Type  String       if std  is same lt T MyClass gt   value  Type  MyClass       return Type     int main         int a 0      std  string s         MyClass my      std  cout lt  lt TypeOf a  lt  lt std  endl      std  cout lt  lt TypeOf s  lt  lt std  endl      std  cout lt  lt TypeOf my  lt  lt std  endl       return 0     Output   int String MyClass

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

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

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

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

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

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 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

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

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

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

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

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

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

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

A more generic solution without function overloading than my previous one   template lt typename T gt  std  string TypeOf T       std  string Type  unknown       if std  is same lt T int gt   value  Type  int       if std  is same lt T std  string gt   value  Type  String       if std  is same lt T MyClass gt   value  Type  MyClass        return Type     Here MyClass is user defined class  More conditions can be added here as well   Example    include  lt iostream gt     class MyClass      template lt typename T gt  std  string TypeOf T       std  string Type  unknown       if std  is same lt T int gt   value  Type  int       if std  is same lt T std  string gt   value  Type  String       if std  is same lt T MyClass gt   value  Type  MyClass       return Type     int main         int a 0      std  string s         MyClass my      std  cout lt  lt TypeOf a  lt  lt std  endl      std  cout lt  lt TypeOf s  lt  lt std  endl      std  cout lt  lt TypeOf my  lt  lt std  endl       return 0     Output   int String MyClass

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

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

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

A more generic solution without function overloading than my previous one   template lt typename T gt  std  string TypeOf T       std  string Type  unknown       if std  is same lt T int gt   value  Type  int       if std  is same lt T std  string gt   value  Type  String       if std  is same lt T MyClass gt   value  Type  MyClass        return Type     Here MyClass is user defined class  More conditions can be added here as well   Example    include  lt iostream gt     class MyClass      template lt typename T gt  std  string TypeOf T       std  string Type  unknown       if std  is same lt T int gt   value  Type  int       if std  is same lt T std  string gt   value  Type  String       if std  is same lt T MyClass gt   value  Type  MyClass       return Type     int main         int a 0      std  string s         MyClass my      std  cout lt  lt TypeOf a  lt  lt std  endl      std  cout lt  lt TypeOf s  lt  lt std  endl      std  cout lt  lt TypeOf my  lt  lt std  endl       return 0     Output   int String MyClass

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

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

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

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

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

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 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

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

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

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

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

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

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 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 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

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 << type_name<void(*)(int)> << '\n';
    // -> `void (*)(int)`

    // Ugly mess case
    // Note that compiler removes cv-qualifiers from parameters and replaces arrays with pointers.
    std::cout << type_name<void (std::string::*(int[3],const int, void (*)(std::string)))(volatile int*const*)> << '\n';
    // -> `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 << type_name<std::ostream (*)(int, short)> << '\n';
    // -> `class? (*)(int,??)`
    // With appropriate TYPE_NAME's, the output would be `std::string (*)(int,short)`.
}

Code:

#include <type_traits>
#include <utility>

static constexpr std::size_t max_str_lit_len = 256;

template <std::size_t I, std::size_t N> constexpr char sl_at(const char (&str)[N])
{
    if constexpr(I < N)
        return str[I];
    else
        return '\0';
}

constexpr std::size_t sl_len(const char *str)
{
    for (std::size_t i = 0; i < max_str_lit_len; i++)
        if (str[i] == '\0')
            return i;
    return 0;
}

template <char ...C> struct str_lit
{
    static constexpr char value[] {C..., '\0'};
    static constexpr int size = sl_len(value);

    template <typename F, typename ...P> struct concat_impl {using type = typename concat_impl<F>::type::template concat_impl<P...>::type;};
    template <char ...CC> struct concat_impl<str_lit<CC...>> {using type = str_lit<C..., CC...>;};
    template <typename ...P> using concat = typename concat_impl<P...>::type;
};

template <typename, const char *> struct trim_str_lit_impl;
template <std::size_t ...I, const char *S> struct trim_str_lit_impl<std::index_sequence<I...>, S>
{
    using type = str_lit<S[I]...>;
};
template <std::size_t N, const char *S> using trim_str_lit = typename trim_str_lit_impl<std::make_index_sequence<N>, S>::type;

#define STR_LIT(str) ::trim_str_lit<::sl_len(str), ::str_lit<STR_TO_VA(str)>::value>
#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<off+0>(str),::sl_at<off+1>(str),::sl_at<off+2>(str),::sl_at<off+3>(str)

template <char ...C> constexpr str_lit<C...> make_str_lit(str_lit<C...>) {return {};}
template <std::size_t N> constexpr auto make_str_lit(const char (&str)[N])
{
    return trim_str_lit<sl_len((const char (&)[N])str), str>{};
}

template <std::size_t A, std::size_t B> struct cexpr_pow {static constexpr std::size_t value = A * cexpr_pow<A,B-1>::value;};
template <std::size_t A> struct cexpr_pow<A,0> {static constexpr std::size_t value = 1;};
template <std::size_t N, std::size_t X, typename = std::make_index_sequence<X>> struct num_to_str_lit_impl;
template <std::size_t N, std::size_t X, std::size_t ...Seq> struct num_to_str_lit_impl<N, X, std::index_sequence<Seq...>>
{
    static constexpr auto func()
    {
        if constexpr (N >= cexpr_pow<10,X>::value)
            return num_to_str_lit_impl<N, X+1>::func();
        else
            return str_lit<(N / cexpr_pow<10,X-1-Seq>::value % 10 + '0')...>{};
    }
};
template <std::size_t N> using num_to_str_lit = decltype(num_to_str_lit_impl<N,1>::func());


using spa = str_lit<' '>;
using lpa = str_lit<'('>;
using rpa = str_lit<')'>;
using lbr = str_lit<'['>;
using rbr = str_lit<']'>;
using ast = str_lit<'*'>;
using amp = str_lit<'&'>;
using con = str_lit<'c','o','n','s','t'>;
using vol = str_lit<'v','o','l','a','t','i','l','e'>;
using con_vol = con::concat<spa, vol>;
using nsp = str_lit<':',':'>;
using com = str_lit<','>;
using unk = str_lit<'?','?'>;

using c_cla = str_lit<'c','l','a','s','s','?'>;
using c_uni = str_lit<'u','n','i','o','n','?'>;
using c_enu = str_lit<'e','n','u','m','?'>;

template <typename T> inline constexpr bool ptr_or_ref = std::is_pointer_v<T> || std::is_reference_v<T> || std::is_member_pointer_v<T>;
template <typename T> inline constexpr bool func_or_arr = std::is_function_v<T> || std::is_array_v<T>;

template <typename T> struct primitive_type_name {using value = unk;};

template <typename T, typename = std::enable_if_t<std::is_class_v<T>>> using enable_if_class = T;
template <typename T, typename = std::enable_if_t<std::is_union_v<T>>> using enable_if_union = T;
template <typename T, typename = std::enable_if_t<std::is_enum_v <T>>> using enable_if_enum  = T;
template <typename T> struct primitive_type_name<enable_if_class<T>> {using value = c_cla;};
template <typename T> struct primitive_type_name<enable_if_union<T>> {using value = c_uni;};
template <typename T> struct primitive_type_name<enable_if_enum <T>> {using value = c_enu;};

template <typename T> struct type_name_impl;

template <typename T> using type_name_lit = std::conditional_t<std::is_same_v<typename primitive_type_name<T>::value::template concat<spa>,
                                                                               typename type_name_impl<T>::l::template concat<typename type_name_impl<T>::r>>,
                                            typename primitive_type_name<T>::value,
                                            typename type_name_impl<T>::l::template concat<typename type_name_impl<T>::r>>;
template <typename T> inline constexpr const char *type_name = type_name_lit<T>::value;

template <typename T, typename = std::enable_if_t<!std::is_const_v<T> && !std::is_volatile_v<T>>> using enable_if_no_cv = T;

template <typename T> struct type_name_impl
{
    using l = typename primitive_type_name<T>::value::template concat<spa>;
    using r = str_lit<>;
};
template <typename T> struct type_name_impl<const T>
{
    using new_T_l = std::conditional_t<type_name_impl<T>::l::size && !ptr_or_ref<T>,
                                       spa::concat<typename type_name_impl<T>::l>,
                                       typename type_name_impl<T>::l>;
    using l = std::conditional_t<ptr_or_ref<T>,
                                 typename new_T_l::template concat<con>,
                                 con::concat<new_T_l>>;
    using r = typename type_name_impl<T>::r;
};
template <typename T> struct type_name_impl<volatile T>
{
    using new_T_l = std::conditional_t<type_name_impl<T>::l::size && !ptr_or_ref<T>,
                                       spa::concat<typename type_name_impl<T>::l>,
                                       typename type_name_impl<T>::l>;
    using l = std::conditional_t<ptr_or_ref<T>,
                                 typename new_T_l::template concat<vol>,
                                 vol::concat<new_T_l>>;
    using r = typename type_name_impl<T>::r;
};
template <typename T> struct type_name_impl<const volatile T>
{
    using new_T_l = std::conditional_t<type_name_impl<T>::l::size && !ptr_or_ref<T>,
                                       spa::concat<typename type_name_impl<T>::l>,
                                       typename type_name_impl<T>::l>;
    using l = std::conditional_t<ptr_or_ref<T>,
                                 typename new_T_l::template concat<con_vol>,
                                 con_vol::concat<new_T_l>>;
    using r = typename type_name_impl<T>::r;
};
template <typename T> struct type_name_impl<T *>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, ast>,
                                 typename type_name_impl<T>::l::template concat<     ast>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<T &>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, amp>,
                                 typename type_name_impl<T>::l::template concat<     amp>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<T &&>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, amp, amp>,
                                 typename type_name_impl<T>::l::template concat<     amp, amp>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T, typename C> struct type_name_impl<T C::*>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, type_name_lit<C>, nsp, ast>,
                                 typename type_name_impl<T>::l::template concat<     type_name_lit<C>, nsp, ast>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<enable_if_no_cv<T[]>>
{
    using l = typename type_name_impl<T>::l;
    using r = lbr::concat<rbr, typename type_name_impl<T>::r>;
};
template <typename T, std::size_t N> struct type_name_impl<enable_if_no_cv<T[N]>>
{
    using l = typename type_name_impl<T>::l;
    using r = lbr::concat<num_to_str_lit<N>, rbr, typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<T()>
{
    using l = typename type_name_impl<T>::l;
    using r = lpa::concat<rpa, typename type_name_impl<T>::r>;
};
template <typename T, typename P1, typename ...P> struct type_name_impl<T(P1, P...)>
{
    using l = typename type_name_impl<T>::l;
    using r = lpa::concat<type_name_lit<P1>,
                          com::concat<type_name_lit<P>>..., rpa, typename type_name_impl<T>::r>;
};

#define TYPE_NAME(t) template <> struct primitive_type_name<t> {using value = STR_LIT(#t);};

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 << type_name<void(*)(int)> << '\n';
    // -> `void (*)(int)`

    // Ugly mess case
    // Note that compiler removes cv-qualifiers from parameters and replaces arrays with pointers.
    std::cout << type_name<void (std::string::*(int[3],const int, void (*)(std::string)))(volatile int*const*)> << '\n';
    // -> `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 << type_name<std::ostream (*)(int, short)> << '\n';
    // -> `class? (*)(int,??)`
    // With appropriate TYPE_NAME's, the output would be `std::string (*)(int,short)`.
}

Code:

#include <type_traits>
#include <utility>

static constexpr std::size_t max_str_lit_len = 256;

template <std::size_t I, std::size_t N> constexpr char sl_at(const char (&str)[N])
{
    if constexpr(I < N)
        return str[I];
    else
        return '\0';
}

constexpr std::size_t sl_len(const char *str)
{
    for (std::size_t i = 0; i < max_str_lit_len; i++)
        if (str[i] == '\0')
            return i;
    return 0;
}

template <char ...C> struct str_lit
{
    static constexpr char value[] {C..., '\0'};
    static constexpr int size = sl_len(value);

    template <typename F, typename ...P> struct concat_impl {using type = typename concat_impl<F>::type::template concat_impl<P...>::type;};
    template <char ...CC> struct concat_impl<str_lit<CC...>> {using type = str_lit<C..., CC...>;};
    template <typename ...P> using concat = typename concat_impl<P...>::type;
};

template <typename, const char *> struct trim_str_lit_impl;
template <std::size_t ...I, const char *S> struct trim_str_lit_impl<std::index_sequence<I...>, S>
{
    using type = str_lit<S[I]...>;
};
template <std::size_t N, const char *S> using trim_str_lit = typename trim_str_lit_impl<std::make_index_sequence<N>, S>::type;

#define STR_LIT(str) ::trim_str_lit<::sl_len(str), ::str_lit<STR_TO_VA(str)>::value>
#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<off+0>(str),::sl_at<off+1>(str),::sl_at<off+2>(str),::sl_at<off+3>(str)

template <char ...C> constexpr str_lit<C...> make_str_lit(str_lit<C...>) {return {};}
template <std::size_t N> constexpr auto make_str_lit(const char (&str)[N])
{
    return trim_str_lit<sl_len((const char (&)[N])str), str>{};
}

template <std::size_t A, std::size_t B> struct cexpr_pow {static constexpr std::size_t value = A * cexpr_pow<A,B-1>::value;};
template <std::size_t A> struct cexpr_pow<A,0> {static constexpr std::size_t value = 1;};
template <std::size_t N, std::size_t X, typename = std::make_index_sequence<X>> struct num_to_str_lit_impl;
template <std::size_t N, std::size_t X, std::size_t ...Seq> struct num_to_str_lit_impl<N, X, std::index_sequence<Seq...>>
{
    static constexpr auto func()
    {
        if constexpr (N >= cexpr_pow<10,X>::value)
            return num_to_str_lit_impl<N, X+1>::func();
        else
            return str_lit<(N / cexpr_pow<10,X-1-Seq>::value % 10 + '0')...>{};
    }
};
template <std::size_t N> using num_to_str_lit = decltype(num_to_str_lit_impl<N,1>::func());


using spa = str_lit<' '>;
using lpa = str_lit<'('>;
using rpa = str_lit<')'>;
using lbr = str_lit<'['>;
using rbr = str_lit<']'>;
using ast = str_lit<'*'>;
using amp = str_lit<'&'>;
using con = str_lit<'c','o','n','s','t'>;
using vol = str_lit<'v','o','l','a','t','i','l','e'>;
using con_vol = con::concat<spa, vol>;
using nsp = str_lit<':',':'>;
using com = str_lit<','>;
using unk = str_lit<'?','?'>;

using c_cla = str_lit<'c','l','a','s','s','?'>;
using c_uni = str_lit<'u','n','i','o','n','?'>;
using c_enu = str_lit<'e','n','u','m','?'>;

template <typename T> inline constexpr bool ptr_or_ref = std::is_pointer_v<T> || std::is_reference_v<T> || std::is_member_pointer_v<T>;
template <typename T> inline constexpr bool func_or_arr = std::is_function_v<T> || std::is_array_v<T>;

template <typename T> struct primitive_type_name {using value = unk;};

template <typename T, typename = std::enable_if_t<std::is_class_v<T>>> using enable_if_class = T;
template <typename T, typename = std::enable_if_t<std::is_union_v<T>>> using enable_if_union = T;
template <typename T, typename = std::enable_if_t<std::is_enum_v <T>>> using enable_if_enum  = T;
template <typename T> struct primitive_type_name<enable_if_class<T>> {using value = c_cla;};
template <typename T> struct primitive_type_name<enable_if_union<T>> {using value = c_uni;};
template <typename T> struct primitive_type_name<enable_if_enum <T>> {using value = c_enu;};

template <typename T> struct type_name_impl;

template <typename T> using type_name_lit = std::conditional_t<std::is_same_v<typename primitive_type_name<T>::value::template concat<spa>,
                                                                               typename type_name_impl<T>::l::template concat<typename type_name_impl<T>::r>>,
                                            typename primitive_type_name<T>::value,
                                            typename type_name_impl<T>::l::template concat<typename type_name_impl<T>::r>>;
template <typename T> inline constexpr const char *type_name = type_name_lit<T>::value;

template <typename T, typename = std::enable_if_t<!std::is_const_v<T> && !std::is_volatile_v<T>>> using enable_if_no_cv = T;

template <typename T> struct type_name_impl
{
    using l = typename primitive_type_name<T>::value::template concat<spa>;
    using r = str_lit<>;
};
template <typename T> struct type_name_impl<const T>
{
    using new_T_l = std::conditional_t<type_name_impl<T>::l::size && !ptr_or_ref<T>,
                                       spa::concat<typename type_name_impl<T>::l>,
                                       typename type_name_impl<T>::l>;
    using l = std::conditional_t<ptr_or_ref<T>,
                                 typename new_T_l::template concat<con>,
                                 con::concat<new_T_l>>;
    using r = typename type_name_impl<T>::r;
};
template <typename T> struct type_name_impl<volatile T>
{
    using new_T_l = std::conditional_t<type_name_impl<T>::l::size && !ptr_or_ref<T>,
                                       spa::concat<typename type_name_impl<T>::l>,
                                       typename type_name_impl<T>::l>;
    using l = std::conditional_t<ptr_or_ref<T>,
                                 typename new_T_l::template concat<vol>,
                                 vol::concat<new_T_l>>;
    using r = typename type_name_impl<T>::r;
};
template <typename T> struct type_name_impl<const volatile T>
{
    using new_T_l = std::conditional_t<type_name_impl<T>::l::size && !ptr_or_ref<T>,
                                       spa::concat<typename type_name_impl<T>::l>,
                                       typename type_name_impl<T>::l>;
    using l = std::conditional_t<ptr_or_ref<T>,
                                 typename new_T_l::template concat<con_vol>,
                                 con_vol::concat<new_T_l>>;
    using r = typename type_name_impl<T>::r;
};
template <typename T> struct type_name_impl<T *>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, ast>,
                                 typename type_name_impl<T>::l::template concat<     ast>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<T &>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, amp>,
                                 typename type_name_impl<T>::l::template concat<     amp>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<T &&>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, amp, amp>,
                                 typename type_name_impl<T>::l::template concat<     amp, amp>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T, typename C> struct type_name_impl<T C::*>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, type_name_lit<C>, nsp, ast>,
                                 typename type_name_impl<T>::l::template concat<     type_name_lit<C>, nsp, ast>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<enable_if_no_cv<T[]>>
{
    using l = typename type_name_impl<T>::l;
    using r = lbr::concat<rbr, typename type_name_impl<T>::r>;
};
template <typename T, std::size_t N> struct type_name_impl<enable_if_no_cv<T[N]>>
{
    using l = typename type_name_impl<T>::l;
    using r = lbr::concat<num_to_str_lit<N>, rbr, typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<T()>
{
    using l = typename type_name_impl<T>::l;
    using r = lpa::concat<rpa, typename type_name_impl<T>::r>;
};
template <typename T, typename P1, typename ...P> struct type_name_impl<T(P1, P...)>
{
    using l = typename type_name_impl<T>::l;
    using r = lpa::concat<type_name_lit<P1>,
                          com::concat<type_name_lit<P>>..., rpa, typename type_name_impl<T>::r>;
};

#define TYPE_NAME(t) template <> struct primitive_type_name<t> {using value = STR_LIT(#t);};

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

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

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

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

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

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

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

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

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

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

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

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

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

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 << type_name<void(*)(int)> << '\n';
    // -> `void (*)(int)`

    // Ugly mess case
    // Note that compiler removes cv-qualifiers from parameters and replaces arrays with pointers.
    std::cout << type_name<void (std::string::*(int[3],const int, void (*)(std::string)))(volatile int*const*)> << '\n';
    // -> `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 << type_name<std::ostream (*)(int, short)> << '\n';
    // -> `class? (*)(int,??)`
    // With appropriate TYPE_NAME's, the output would be `std::string (*)(int,short)`.
}

Code:

#include <type_traits>
#include <utility>

static constexpr std::size_t max_str_lit_len = 256;

template <std::size_t I, std::size_t N> constexpr char sl_at(const char (&str)[N])
{
    if constexpr(I < N)
        return str[I];
    else
        return '\0';
}

constexpr std::size_t sl_len(const char *str)
{
    for (std::size_t i = 0; i < max_str_lit_len; i++)
        if (str[i] == '\0')
            return i;
    return 0;
}

template <char ...C> struct str_lit
{
    static constexpr char value[] {C..., '\0'};
    static constexpr int size = sl_len(value);

    template <typename F, typename ...P> struct concat_impl {using type = typename concat_impl<F>::type::template concat_impl<P...>::type;};
    template <char ...CC> struct concat_impl<str_lit<CC...>> {using type = str_lit<C..., CC...>;};
    template <typename ...P> using concat = typename concat_impl<P...>::type;
};

template <typename, const char *> struct trim_str_lit_impl;
template <std::size_t ...I, const char *S> struct trim_str_lit_impl<std::index_sequence<I...>, S>
{
    using type = str_lit<S[I]...>;
};
template <std::size_t N, const char *S> using trim_str_lit = typename trim_str_lit_impl<std::make_index_sequence<N>, S>::type;

#define STR_LIT(str) ::trim_str_lit<::sl_len(str), ::str_lit<STR_TO_VA(str)>::value>
#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<off+0>(str),::sl_at<off+1>(str),::sl_at<off+2>(str),::sl_at<off+3>(str)

template <char ...C> constexpr str_lit<C...> make_str_lit(str_lit<C...>) {return {};}
template <std::size_t N> constexpr auto make_str_lit(const char (&str)[N])
{
    return trim_str_lit<sl_len((const char (&)[N])str), str>{};
}

template <std::size_t A, std::size_t B> struct cexpr_pow {static constexpr std::size_t value = A * cexpr_pow<A,B-1>::value;};
template <std::size_t A> struct cexpr_pow<A,0> {static constexpr std::size_t value = 1;};
template <std::size_t N, std::size_t X, typename = std::make_index_sequence<X>> struct num_to_str_lit_impl;
template <std::size_t N, std::size_t X, std::size_t ...Seq> struct num_to_str_lit_impl<N, X, std::index_sequence<Seq...>>
{
    static constexpr auto func()
    {
        if constexpr (N >= cexpr_pow<10,X>::value)
            return num_to_str_lit_impl<N, X+1>::func();
        else
            return str_lit<(N / cexpr_pow<10,X-1-Seq>::value % 10 + '0')...>{};
    }
};
template <std::size_t N> using num_to_str_lit = decltype(num_to_str_lit_impl<N,1>::func());


using spa = str_lit<' '>;
using lpa = str_lit<'('>;
using rpa = str_lit<')'>;
using lbr = str_lit<'['>;
using rbr = str_lit<']'>;
using ast = str_lit<'*'>;
using amp = str_lit<'&'>;
using con = str_lit<'c','o','n','s','t'>;
using vol = str_lit<'v','o','l','a','t','i','l','e'>;
using con_vol = con::concat<spa, vol>;
using nsp = str_lit<':',':'>;
using com = str_lit<','>;
using unk = str_lit<'?','?'>;

using c_cla = str_lit<'c','l','a','s','s','?'>;
using c_uni = str_lit<'u','n','i','o','n','?'>;
using c_enu = str_lit<'e','n','u','m','?'>;

template <typename T> inline constexpr bool ptr_or_ref = std::is_pointer_v<T> || std::is_reference_v<T> || std::is_member_pointer_v<T>;
template <typename T> inline constexpr bool func_or_arr = std::is_function_v<T> || std::is_array_v<T>;

template <typename T> struct primitive_type_name {using value = unk;};

template <typename T, typename = std::enable_if_t<std::is_class_v<T>>> using enable_if_class = T;
template <typename T, typename = std::enable_if_t<std::is_union_v<T>>> using enable_if_union = T;
template <typename T, typename = std::enable_if_t<std::is_enum_v <T>>> using enable_if_enum  = T;
template <typename T> struct primitive_type_name<enable_if_class<T>> {using value = c_cla;};
template <typename T> struct primitive_type_name<enable_if_union<T>> {using value = c_uni;};
template <typename T> struct primitive_type_name<enable_if_enum <T>> {using value = c_enu;};

template <typename T> struct type_name_impl;

template <typename T> using type_name_lit = std::conditional_t<std::is_same_v<typename primitive_type_name<T>::value::template concat<spa>,
                                                                               typename type_name_impl<T>::l::template concat<typename type_name_impl<T>::r>>,
                                            typename primitive_type_name<T>::value,
                                            typename type_name_impl<T>::l::template concat<typename type_name_impl<T>::r>>;
template <typename T> inline constexpr const char *type_name = type_name_lit<T>::value;

template <typename T, typename = std::enable_if_t<!std::is_const_v<T> && !std::is_volatile_v<T>>> using enable_if_no_cv = T;

template <typename T> struct type_name_impl
{
    using l = typename primitive_type_name<T>::value::template concat<spa>;
    using r = str_lit<>;
};
template <typename T> struct type_name_impl<const T>
{
    using new_T_l = std::conditional_t<type_name_impl<T>::l::size && !ptr_or_ref<T>,
                                       spa::concat<typename type_name_impl<T>::l>,
                                       typename type_name_impl<T>::l>;
    using l = std::conditional_t<ptr_or_ref<T>,
                                 typename new_T_l::template concat<con>,
                                 con::concat<new_T_l>>;
    using r = typename type_name_impl<T>::r;
};
template <typename T> struct type_name_impl<volatile T>
{
    using new_T_l = std::conditional_t<type_name_impl<T>::l::size && !ptr_or_ref<T>,
                                       spa::concat<typename type_name_impl<T>::l>,
                                       typename type_name_impl<T>::l>;
    using l = std::conditional_t<ptr_or_ref<T>,
                                 typename new_T_l::template concat<vol>,
                                 vol::concat<new_T_l>>;
    using r = typename type_name_impl<T>::r;
};
template <typename T> struct type_name_impl<const volatile T>
{
    using new_T_l = std::conditional_t<type_name_impl<T>::l::size && !ptr_or_ref<T>,
                                       spa::concat<typename type_name_impl<T>::l>,
                                       typename type_name_impl<T>::l>;
    using l = std::conditional_t<ptr_or_ref<T>,
                                 typename new_T_l::template concat<con_vol>,
                                 con_vol::concat<new_T_l>>;
    using r = typename type_name_impl<T>::r;
};
template <typename T> struct type_name_impl<T *>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, ast>,
                                 typename type_name_impl<T>::l::template concat<     ast>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<T &>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, amp>,
                                 typename type_name_impl<T>::l::template concat<     amp>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<T &&>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, amp, amp>,
                                 typename type_name_impl<T>::l::template concat<     amp, amp>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T, typename C> struct type_name_impl<T C::*>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, type_name_lit<C>, nsp, ast>,
                                 typename type_name_impl<T>::l::template concat<     type_name_lit<C>, nsp, ast>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<enable_if_no_cv<T[]>>
{
    using l = typename type_name_impl<T>::l;
    using r = lbr::concat<rbr, typename type_name_impl<T>::r>;
};
template <typename T, std::size_t N> struct type_name_impl<enable_if_no_cv<T[N]>>
{
    using l = typename type_name_impl<T>::l;
    using r = lbr::concat<num_to_str_lit<N>, rbr, typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<T()>
{
    using l = typename type_name_impl<T>::l;
    using r = lpa::concat<rpa, typename type_name_impl<T>::r>;
};
template <typename T, typename P1, typename ...P> struct type_name_impl<T(P1, P...)>
{
    using l = typename type_name_impl<T>::l;
    using r = lpa::concat<type_name_lit<P1>,
                          com::concat<type_name_lit<P>>..., rpa, typename type_name_impl<T>::r>;
};

#define TYPE_NAME(t) template <> struct primitive_type_name<t> {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

A more generic solution without function overloading than my previous one   template lt typename T gt  std  string TypeOf T       std  string Type  unknown       if std  is same lt T int gt   value  Type  int       if std  is same lt T std  string gt   value  Type  String       if std  is same lt T MyClass gt   value  Type  MyClass        return Type     Here MyClass is user defined class  More conditions can be added here as well   Example    include  lt iostream gt     class MyClass      template lt typename T gt  std  string TypeOf T       std  string Type  unknown       if std  is same lt T int gt   value  Type  int       if std  is same lt T std  string gt   value  Type  String       if std  is same lt T MyClass gt   value  Type  MyClass       return Type     int main         int a 0      std  string s         MyClass my      std  cout lt  lt TypeOf a  lt  lt std  endl      std  cout lt  lt TypeOf s  lt  lt std  endl      std  cout lt  lt TypeOf my  lt  lt std  endl       return 0     Output   int String MyClass

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

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

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

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

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 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

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

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

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

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

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

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

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

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

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

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

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

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

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 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

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

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

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

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

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

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

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

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

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

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 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

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

[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