C Get name of type in template

Question

I m writing some template classes for parseing some text data files  and as such it is likly the great majority of parse errors will be due to errors in the data file  which are for the most part not written by programmers  and so need a nice message about why the app failed to load e g  something like      Error parsing example txt  Value   notaninteger  of  MySectiom Key is not a valid int   I can work out the file  section and key names from the arguments passed to the template function and member vars in the class  however I m not sure how to get the name of the type the template function is trying to convert to   My current code looks like  with specialisations for just plain strings and such   template lt typename T gt  T GetValue const std  wstring  amp section  const std  wstring  amp key        std  map lt std  wstring  std  wstring gt   iterator it   map section  find key       if it    map section  end            throw ItemDoesNotExist file  section  key      else               try return boost  lexical cast lt T gt  it- gt second              needs to get the name from T somehow         catch     throw ParseError file  section  key  it- gt second  TypeName T              Id rather not have to make specific overloads for every type that the data files might use  since there are loads of them     Also I need a solution that does not incur any runtime overhead unless an exception occurs  i e  a completely compile time solution is what I want since this code is called tons of times and load times are already getting somewhat long    EDIT  Ok this is the solution I came up with   I have a types h containg the following   pragma once template lt typename T gt  const wchar t  GetTypeName      define DEFINE TYPE NAME type  name        template lt  gt const wchar t  GetTypeName lt type gt    return name     Then I can use the DEFINE TYPE NAME macro to in cpp files for each type I need to deal with  eg in the cpp file that defined the type to start with    The linker is then able to find the appropirate template specialisation as long as it was defined somewhere  or throw a linker error otherwise so that I can add the type

User · Accepted Answer

Jesse Beder s solution is likely the best  but if you don t like the names typeid gives you  I think gcc gives you mangled names for instance   you can do something like   template lt typename T gt  struct TypeParseTraits    define REGISTER PARSE TYPE X  template  lt  gt  struct TypeParseTraits lt X gt          static const char  name      const char  TypeParseTraits lt X gt   name    X   REGISTER PARSE TYPE int   REGISTER PARSE TYPE double   REGISTER PARSE TYPE FooClass      etc      And then use it like  throw ParseError TypeParseTraits lt T gt   name     EDIT   You could also combine the two  change name to be a function that by default calls typeid T  name   and then only specialize for those cases where that s not acceptable

User · Answer

This trick was mentioned under a few other questions  but not here yet   All major compilers support   PRETTY FUNC    GCC  amp  Clang     FUNCSIG    MSVC  as an extension   When used in a template like this   template  lt typename T gt  const char  foo          ifdef  MSC VER     return   FUNCSIG         else     return   PRETTY FUNCTION         endif     It produces strings in a compiler-dependent format  that contain  among other things  the name of T   E g  foo lt float gt    returns     const char  foo    with T   float   on GCC  const char  foo    T   float   on Clang  const char    cdecl foo lt float gt  void   on MSVC   You can easily parse the type names out of those strings  You just need to figure out how many  junk  characters your compiler inserts before and after the type   You can even do that completely at compile-time     The resulting names can slightly vary between different compilers  E g  GCC omits default template arguments  and MSVC prefixes classes with the word class     Here s an implementation that I ve been using  Everything is done at compile-time   Example usage   std  cout  lt  lt  TypeName lt float gt     lt  lt    n   std  cout  lt  lt  TypeName 1 2f    lt  lt    n     Implementation    include  lt array gt   include  lt cstddef gt   namespace impl       template  lt typename T gt      constexpr const auto  amp RawTypeName                  ifdef  MSC VER         return   FUNCSIG             else         return   PRETTY FUNCTION             endif            struct RawTypeNameFormat               std  size t leading junk   0  trailing junk   0                 Returns  false  on failure      inline constexpr bool GetRawTypeNameFormat RawTypeNameFormat  format                const auto  amp str   RawTypeName lt int gt             for  std  size t i   0   i                          if  str i      i   amp  amp  str i 1      n   amp  amp  str i 2      t                                 if  format                                        format- gt leading junk   i                      format- gt trailing junk   sizeof str -i-3-1      3  is the length of  int    1  is the space for the null terminator                                    return true                                  return false             inline static constexpr RawTypeNameFormat format                   static assert GetRawTypeNameFormat nullptr    Unable to figure out how to generate type names on this compiler             RawTypeNameFormat format          GetRawTypeNameFormat  amp format           return format                 Returns the type name in a  std  array lt char  N gt    null-terminated   template  lt typename T gt    nodiscard   constexpr auto CexprTypeName         constexpr std  size t len   sizeof impl  RawTypeName lt T gt     - impl  format leading junk - impl  format trailing junk      std  array lt char  len gt  name        for  std  size t i   0  i  lt  len-1  i            name i    impl  RawTypeName lt T gt    i   impl  format leading junk       return name     template  lt typename T gt    nodiscard   const char  TypeName         static constexpr auto name   CexprTypeName lt T gt         return name data      template  lt typename T gt    nodiscard   const char  TypeName const T  amp         return TypeName lt T gt

User · Answer

If you d like a pretty name  Logan Capaldo s solution can t deal with complex data structure  REGISTER PARSE TYPE map lt int int gt   and typeid map lt int int gt   name   gives me a result of St3mapIiiSt4lessIiESaISt4pairIKiiEEE  There is another interesting answer using unordered map or map comes from https   en cppreference com w cpp types type index    include  lt iostream gt   include  lt unordered map gt   include  lt map gt   include  lt typeindex gt  using namespace std  unordered map lt type index string gt  types map    int main        types map  typeid int    int       types map  typeid float    float       types map  typeid map lt int int gt     map lt int int gt         map lt int int gt  mp      cout lt  lt types map  typeid map lt int int gt    lt  lt endl      cout lt  lt types map  typeid mp   lt  lt endl      return 0

User · Answer

typeid T  name   is implementation defined and doesn t guarantee human readable string   Reading cppreference com       Returns an implementation defined null-terminated character string   containing the name of the type  No guarantees are given  in   particular  the returned string can be identical for several types and   change between invocations of the same program                With compilers such as gcc and clang  the returned string can be piped through c  filt -t to be converted to human-readable form     But in some cases gcc doesn t return right string  For example on my machine I have gcc whith -std c  11 and inside template function typeid T  name   returns  j  for  unsigned int   It s so called mangled name  To get real type name  use   abi    cxa demangle   function  gcc only     include  lt string gt   include  lt cstdlib gt   include  lt cxxabi h gt   template lt typename T gt  std  string type name         int status      std  string tname   typeid T  name        char  demangled name   abi    cxa demangle tname c str    NULL  NULL   amp status       if status    0            tname   demangled name          std  free demangled name                return tname

User · Answer

The solution is  typeid T  name     which returns std  type info

User · Answer

I just leave it there  If someone will still need it  then you can use this   template  lt class T gt  bool isString T  t    return false        normal case returns false  template  lt  gt  bool isString char  t    return true        but for char  or String c str   returns true         This will only CHECK type not GET it and only for 1 type or 2

User · Answer

As a rephrasing of Andrey s answer   The Boost TypeIndex library can be used to print names of types   Inside a template  this might read as follows   include  lt boost type index hpp gt   include  lt iostream gt   template lt typename T gt  void printNameOfType         std  cout  lt  lt   Type of T                    lt  lt  boost  typeindex  type id lt T gt    pretty name                   lt  lt  std  endl

User · Answer

As mentioned by Bunkar typeid T  name is implementation defined   To avoid this issue you can use Boost TypeIndex library   For example   boost  typeindex  type id lt T gt    pretty name      human readable

User · Answer

typeid uint8 t  name   is nice  but it returns  unsigned char  while you may expect  uint8 t    This piece of code will return you the appropriate type   define DECLARE SET FORMAT FOR type        if   typeid type     typeid T              formatStr    type   template lt typename T gt  static std  string GetFormatName         std  string formatStr       DECLARE SET FORMAT FOR  uint8 t        DECLARE SET FORMAT FOR  int8 t         DECLARE SET FORMAT FOR  uint16 t       DECLARE SET FORMAT FOR  int16 t        DECLARE SET FORMAT FOR  uint32 t       DECLARE SET FORMAT FOR  int32 t        DECLARE SET FORMAT FOR  float              to be exptended with other standard types you want to be displayed smartly      if   formatStr empty                   assert  false            formatStr   typeid T  name               return formatStr

User · Answer

The answer of Logan Capaldo is correct but can be marginally simplified because it is unnecessary to specialize the class every time  One can write      in header template lt typename T gt  struct TypeParseTraits   static const char  name         in c-file  define REGISTER PARSE TYPE X        template  lt  gt  const char  TypeParseTraits lt X gt   name    X  REGISTER PARSE TYPE int   REGISTER PARSE TYPE double   REGISTER PARSE TYPE FooClass      etc      This also allows you to put the REGISTER PARSE TYPE instructions in a C   file

[c++] C++ Get name of type in template

Examples related to c++

Examples related to templates

Examples related to compile-time

Examples related to typename