如何在C++中获得完整的类型名称（RTTI的typeid在不同平台下有不同的输出值表达，自建类改进了RTTI丢失的信息）

2023-02-22 20:27:09

 
地球人都知道C++里有一个typeid操作符可以用来获取一个类型/表达式的名称：
  1. std::cout << typeid(int).name() << std::endl;

但是这个name()的返回值是取决于编译器的，在vc和gcc中打印出来的结果如下：

  1. int // vc
  2. i   // gcc

一个稍微长一点的类型名称，比如：

  1. class Foo {};
  2. std::cout << typeid(Foo*[10]).name() << std::endl;

打出来是这个效果：

  1. class Foo * [10] // vc
  2. A10_P3Foo        // gcc

（话说gcc您的返回结果真是。。）
当然了，想在gcc里得到和微软差不多显示效果的方法也是有的，那就是使用__cxa_demangle：

  1. char* name = abi::__cxa_demangle(typeid(Foo*[10]).name(), nullptr, nullptr, nullptr);
  2. std::cout << name << std::endl;
  3. free(name);

显示效果：

  1. Foo* [10]

先不说不同编译器下的适配问题，来看看下面这个会打印出啥：

  1. // vc
  2. std::cout << typeid(const int&).name() << std::endl;
  3. // gcc
  4. char* name = abi::__cxa_demangle(typeid(const int&).name(), nullptr, nullptr, nullptr);
  5. std::cout << name << std::endl;
  6. free(name);

显示效果：

  1. int // vc
  2. int // gcc

可爱的cv限定符和引用都被丢掉了=.=
如果直接在typeid的结果上加上被丢弃的信息，对于一些类型而言（如函数指针引用）得到的将不是一个正确的类型名称。
想要获得一个类型的完整名称，并且获得的名称必须要是一个正确的类型名称，应该怎样做呢？

一、如何检查C++中的类型

我们需要一个泛型类，用特化/偏特化机制静态检查出C++中的各种类型，并且不能忽略掉类型限定符（type-specifiers）和各种声明符（declarators）。
先来考虑一个最简单的类模板：

  1. template <typename T>
  2. struct check
  3. {
  4. // ...
  5. };

假如在它的基础上特化，需要写多少个版本呢？我们可以稍微实现下试试：

  1. template <typename T> struct check<T &>;
  2. template <typename T> struct check<T const &>;
  3. template <typename T> struct check<T volatile &>;
  4. template <typename T> struct check<T const volatile &>;
  5. template <typename T> struct check<T &&>;
  6. template <typename T> struct check<T const &&>;
  7. template <typename T> struct check<T volatile &&>;
  8. template <typename T> struct check<T const volatile &&>;
  9. template <typename T> struct check<T *>;
  10. template <typename T> struct check<T const *>;
  11. template <typename T> struct check<T volatile *>;
  12. template <typename T> struct check<T const volatile *>;
  13. template <typename T> struct check<T * const>;
  14. template <typename T> struct check<T * volatile>;
  15. template <typename T> struct check<T * const volatile>;
  16. template <typename T> struct check<T []>;
  17. template <typename T> struct check<T const []>;
  18. template <typename T> struct check<T volatile []>;
  19. template <typename T> struct check<T const volatile []>;
  20. template <typename T, size_t N> struct check<T [N]>;
  21. template <typename T, size_t N> struct check<T const [N]>;
  22. template <typename T, size_t N> struct check<T volatile [N]>;
  23. template <typename T, size_t N> struct check<T const volatile [N]>;
  24. // ......

这还远远没有完。有同学可能会说了，我们不是有伟大的宏嘛，这些东西都像是一个模子刻出来的，弄一个宏批量生成下不就完了。

实际上当我们真的信心满满的动手去写这些宏的时候，才发现适配上的细微差别会让宏写得非常痛苦（比如&和*的差别，[]和[N]的差别，还有函数类型、函数指针、函数指针引用、函数指针数组、类成员指针、……）。当我们一一罗列出需要特化的细节时，不由得感叹C++类型系统的复杂和纠结。

但是上面的理由并不是这个思路的致命伤。
不可行的地方在于：我们可以写一个多维指针，或多维数组，类型是可以嵌套的。总不可能为每一个维度都特化一个模板吧。

不过正由于类型其实是嵌套的，我们可以用模板元编程的基本思路来搞定这个问题：

  1. template <typename T> struct check<T const> : check<T>;
  2. template <typename T> struct check<T volatile> : check<T>;
  3. template <typename T> struct check<T const volatile> : check<T>;
  4. template <typename T> struct check<T & > : check<T>;
  5. template <typename T> struct check<T &&> : check<T>;
  6. template <typename T> struct check<T * > : check<T>;
  7. // ......

一个简单的继承，就让特化变得simple很多。因为当我们萃取出一个类型，比如T *，之后的T其实是携带上了除*之外所有其他类型信息的一个类型。那么把这个T再重复投入check中，就会继续萃取它的下一个类型特征。

可以先用指针、引用的萃取来看看效果：

  1. #include <iostream>
  2. template <typename T>
  3. struct check
  4. {
  5. check(void)  { std::cout << typeid(T).name(); }
  6. ~check(void) { std::cout << std::endl; }
  7. };
  8. #define CHECK_TYPE__(OPT) \
  9. template <typename T> \
  10. struct check<T OPT> : check<T> \
  11. { \
  12. check(void) { std::cout << " "#OPT; } \
  13. };
  14. CHECK_TYPE__(const)
  15. CHECK_TYPE__(volatile)
  16. CHECK_TYPE__(const volatile)
  17. CHECK_TYPE__(&)
  18. CHECK_TYPE__(&&)
  19. CHECK_TYPE__(*)
  20. int main(void)
  21. {
  22. check<const volatile void * const*&>();
  23. system("pause");
  24. return 0;
  25. }

输出结果（vc）：

  1. void const volatile * const * &

很漂亮，是不是？当然，在gcc里这样输出，void会变成v，所以gcc下面要这样写check模板：

  1. template <typename T>
  2. struct check
  3. {
  4. check(void)
  5. {
  6. char* real_name = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
  7. std::cout << real_name;
  8. free(real_name);
  9. }
  10. ~check(void) { std::cout << std::endl; }
  11. };

二、保存和输出字符串

我们可以简单的这样修改check让它同时支持vc和gcc：

  1. template <typename T>
  2. struct check
  3. {
  4. check(void)
  5. {
  6. #   if defined(__GNUC__)
  7. char* real_name = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
  8. std::cout << real_name;
  9. free(real_name);
  10. #   else
  11. std::cout << typeid(T).name();
  12. #   endif
  13. }
  14. ~check(void) { std::cout << std::endl; }
  15. };

但是到目前为止，check的输出结果都是无法保存的。比较好的方式是可以像typeid(T).name()一样返回一个字符串。这就要求check能够把结果保存在一个std::string对象里。
当然了，我们可以直接给check一个“std::string& out”类型的构造函数，但是这样会把输出的状态管理、字符的打印逻辑等等都揉在一起。因此，比较好的设计方法是实现一个output类，负责输出和维护状态。我们到后面就会慢慢感觉到这样做的好处在哪里。
output类的实现可以是这样：

  1. class output
  2. {
  3. bool is_compact_ = true;
  4. template <typename T>
  5. bool check_empty(const T&) { return false; }
  6. bool check_empty(const char* val)
  7. {
  8. return (!val) || (val[0] == 0);
  9. }
  10. template <typename T>
  11. void out(const T& val)
  12. {
  13. if (check_empty(val)) return;
  14. if (!is_compact_) sr_ += " ";
  15. using ss_t = std::ostringstream;
  16. sr_ += static_cast<ss_t&>(ss_t() << val).str();
  17. is_compact_ = false;
  18. }
  19. std::string& sr_;
  20. public:
  21. output(std::string& sr) : sr_(sr) {}
  22. output& operator()(void) { return (*this); }
  23. template <typename T1, typename... T>
  24. output& operator()(const T1& val, const T&... args)
  25. {
  26. out(val);
  27. return operator()(args...);
  28. }
  29. output& compact(void)
  30. {
  31. is_compact_ = true;
  32. return (*this);
  33. }
  34. };

这个小巧的output类负责自动管理输出状态（是否增加空格）和输出的类型转换（使用std::ostringstream）。
上面的实现里有两个比较有意思的地方。
一是operator()的做法，采用了变参模板。这种做法让我们可以这样用output：

  1. output out(str);
  2. out("Hello", "World", 123, "!");

这种写法比cout的流操作符舒服多了。
二是operator()和compact的返回值。当然，这里可以直接使用void，但是这会造成一些限制。
比如说，我们想在使用operator()之后马上compact呢？若让函数返回自身对象的引用，就可以让output用起来非常顺手：

  1. output out(str);
  2. out.compact()("Hello", "World", 123, "!").compact()("?");

check的定义和CHECK_TYPE__宏只需要略作修改就可以使用output类：

  1. template <typename T>
  2. struct check
  3. {
  4. output out_;
  5. check(const output& out) : out_(out)
  6. {
  7. #   if defined(__GNUC__)
  8. char* real_name = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
  9. out_(real_name);
  10. free(real_name);
  11. #   else
  12. out_(typeid(T).name());
  13. #   endif
  14. }
  15. };
  16. #define CHECK_TYPE__(OPT) \
  17. template <typename T> \
  18. struct check<T OPT> : check<T> \
  19. { \
  20. using base_t = check<T>; \
  21. using base_t::out_; \
  22. check(const output& out) : base_t(out) { out_(#OPT); } \
  23. };

为了让外部的使用依旧简洁，实现一个外敷函数模板是很自然的事情：

  1. template <typename T>
  2. inline std::string check_type(void)
  3. {
  4. std::string str;
  5. check<T> { str };
  6. return std::move(str);
  7. }
  8. int main(void)
  9. {
  10. std::cout << check_type<const volatile void * const*&>() << std::endl;
  11. system("pause");
  12. return 0;
  13. }

如果我们想实现表达式的类型输出，使用decltype包裹一下就行了。

不知道看到这里的朋友有没有注意到，check在gcc下的输出可能会出现问题。原因是abi::__cxa_demangle并不能保证永远返回一个有效的字符串。
我们来看看这个函数的返回值说明：

“Returns: A pointer to the start of the NUL-terminated demangled name, or NULL if the demangling fails. The caller is responsible for deallocating this memory using free.”

所以说比较好的做法应该是在abi::__cxa_demangle返回空的时候，直接使用typeid(T).name()的结果。
一种健壮的写法可以像这样：

  1. template <typename T>
  2. struct check
  3. {
  4. output out_;
  5. check(const output& out) : out_(out)
  6. {
  7. #   if defined(__GNUC__)
  8. const char* typeid_name = typeid(T).name();
  9. auto deleter = [](char* p)
  10. {
  11. if (p) free(p);
  12. };
  13. std::unique_ptr<char, decltype(deleter)> real_name
  14. {
  15. abi::__cxa_demangle(typeid_name, nullptr, nullptr, nullptr), deleter
  16. };
  17. out_(real_name ? real_name.get() : typeid_name);
  18. #   else
  19. out_(typeid(T).name());
  20. #   endif
  21. }
  22. };

上面我们通过使用std::unique_ptr配合lambda的自定义deleter，实现了一个简单的Scope Guard机制，来保证当abi::__cxa_demangle返回的非NULL指针一定会被free掉。

三、输出有效的类型定义

3.1 一些准备工作

上面的特化解决了cv限定符、引用和指针，甚至对于未特化的数组、类成员指针等都有还不错的显示效果，不过却无法保证输出的类型名称一定是一个有效的类型定义。比如说：

  1. check_type<int(*)[]>(); // int [] *

原因是因为这个类型是一个指针，指向一个int[]，所以会先匹配到指针的特化，因此*就被写到了最后面。
对于数组、函数等类型来说，若它们处在一个复合类型（compound types）中“子类型”的位置上，它们就需要用括号把它们的“父类型”给括起来。
因此我们还需要预先完成下面这些工作：

    • 1. 如何判断数组、函数等类型的特化处于check继承链中“被继承”（也就是某个类的基类）的位置上
    • 2. 圆括号()、方括号[]，以及函数参数列表的输出逻辑

      上面的第1点，可以利用模板偏特化这种静态的判断来解决。比如说，给check添加一个默认的bool模板参数：

      1. template <typename T, bool IsBase = false>
      2. struct check
      3. {
      4. // ...
      5. };
      6. #define CHECK_TYPE__(OPT) \
      7. template <typename T, bool IsBase> \
      8. struct check<T OPT, IsBase> : check<T, true> \
      9. { \
      10. using base_t = check<T, true>; \
      11. using base_t::out_; \
      12. check(const output& out) : base_t(out) { out_(#OPT); } \
      13. };

      这个小小的修改就可以让check在继承的时候把父-子信息传递下去。

      接下来先考虑圆括号的输出逻辑。我们可以构建一个bracket类，在编译期帮我们自动处理圆括号：

      1. // ()
      2. template <bool>
      3. struct bracket
      4. {
      5. output& out_;
      6. bracket(output& out, const char* = nullptr) : out_(out)
      7. { out_("(").compact(); }
      8. ~bracket(void)
      9. { out_.compact()(")"); }
      10. };
      11. template <>
      12. struct bracket<false>
      13. {
      14. bracket(output& out, const char* str = nullptr)
      15. { out(str); }
      16. };

      在bracket里，不仅实现了圆括号的输出，其实还实现了一个编译期if的小功能。当不输出圆括号时，我们可以给bracket指定一个其它的输出内容。
      当然，不实现bracket，直接在check的类型特化里处理括号逻辑也可以，但是这样的话逻辑就被某个check特化绑死了。我们可以看到bracket的逻辑被剥离出来以后，后面所有需要输出圆括号的部分都可以直接复用这个功能。

      然后是[]的输出逻辑。考虑到对于[N]类型的数组，还需要把N的具体数值输出来，因此输出逻辑可以这样写：

      1. // [N]
      2. template <size_t N = 0>
      3. struct bound
      4. {
      5. output& out_;
      6. bound(output& out) : out_(out) {}
      7. ~bound(void)
      8. {
      9. if (N == 0) out_("[]");
      10. else        out_("[").compact()
      11. ( N ).compact()
      12. ("]");
      13. }
      14. };

      输出逻辑需要写在bound类的析构，而不是构造里。原因是对于一个数组类型，[N]总是写在最后面的。
      这里在输出的时候直接使用了运行时的if-else，而没有再用特化来处理。是因为当N是一个编译期数值时，对于现代的编译器来说“if (N == 0) ; else ;”语句会被优化掉，只生成确定逻辑的汇编码。

      最后，是函数参数的输出逻辑。函数参数列表需要使用变参模板适配，用编译期递归的元编程手法输出参数，最后在两头加上括号。
      我们可以先写出递归的结束条件：

      1. template <bool, typename... P>
      2. struct parameter;
      3. template <bool IsStart>
      4. struct parameter<IsStart>
      5. {
      6. output& out_;
      7. parameter(output& out) : out_(out) {}
      8. ~parameter(void)
      9. { bracket<IsStart> { out_ }; }
      10. };

      输出逻辑写在析构里的理由，和bound一致。结束条件是显然的：当参数包为空时，parameter将只输出一对括号。
      注意到模板的bool类型参数，让我们在使用的时候需要这样写：

      1. parameter<true, P...> parameter_;

      这是因为bool模板参数混在变参里，指定默认值也是没办法省略true的。
      稍微有点复杂的是参数列表的输出。一个简单的写法是这样：

      1. template <bool IsStart, typename P1, typename... P>
      2. struct parameter<IsStart, P1, P...>
      3. {
      4. output& out_;
      5. parameter(output& out) : out_(out) {}
      6. ~parameter(void)
      7. {
      8. bracket<IsStart> bk { out_, "," }; (void)bk;
      9. check<P1> { out_ };
      10. parameter<false, P...> { out_.compact() };
      11. }
      12. };

      parameter在析构的时候，析构函数的scope就是bracket的影响范围，后面的其它显示内容，都应该被包括在bracket之内，因此bracket需要显式定义临时变量bk；
      check的调用理由很简单，因为我们需要显示出每个参数的具体类型；
      最下面是parameter的递归调用。在把out_丢进去之前，我们需要思考下具体的显示效果。是希望打印出(P1, P2, P3)呢，还是(P1 , P2 , P3)？
      在这里我们选择了逗号之前没有空格的第一个版本，因此给parameter传递的是out_.compact()。

      对parameter的代码来说，看起来不明显的就是bracket的作用域了，check和parameter的调用其实是被bracket包围住的。为了强调bracket的作用范围，同时规避掉莫名其妙的“(void)bk;”手法，我们可以使用lambda表达式来凸显逻辑：

      1. template <bool IsStart, typename P1, typename... P>
      2. struct parameter<IsStart, P1, P...>
      3. {
      4. output& out_;
      5. parameter(output& out) : out_(out) {}
      6. ~parameter(void)
      7. {
      8. [this](bracket<IsStart>&&)
      9. {
      10. check<P1> { out_ };
      11. parameter<false, P...> { out_.compact() };
      12. } (bracket<IsStart> { out_, "," });
      13. }
      14. };

      这样bracket的作用域一目了然，并且和check、parameter的定义方式保持一致，同时也更容易看出来out_.compact()的意图。

      3.2 数组（Arrays）的处理

      好了，有了上面的这些准备工作，写一个check的T[]特化是很简单的：

      1. template <typename T, bool IsBase>
      2. struct check<T[], IsBase> : check<T, true>
      3. {
      4. using base_t = check<T, true>;
      5. using base_t::out_;
      6. bound<>         bound_;
      7. bracket<IsBase> bracket_;
      8. check(const output& out) : base_t(out)
      9. , bound_  (out_)
      10. , bracket_(out_)
      11. {}
      12. };

      这时对于不指定数组长度的[]类型，输出结果如下：

      1. check_type<int(*)[]>(); // int (*) []

      当我们开始兴致勃勃的接着追加[N]的模板特化之前，需要先检查下cv的检查机制是否运作良好：

      1. check_type<const int[]>();

      尝试编译时，gcc会给我们吐出一堆类似这样的compile error：

      1. error: ambiguous class template instantiation for 'struct check<const int [], false>'
      2. check<T> { str };
      3. ^

      检查了出错信息后，我们会惊讶的发现对于const int[]类型，竟然可以同时匹配T const和T[]。
      这是因为按照C++标准ISO/IEC-14882:2011，3.9.3 CV-qualifiers，第5款：

      “Cv-qualifiers applied to an array type attach to the underlying element type, so the notation “cv T,” where T is an array type, refers to an array whose elements are so-qualified. Such array types can be said to be more (or less) cv-qualified than other types based on the cv-qualification of the underlying element types.”

      可能描述有点晦涩，不过没关系，在8.3.4 Arrays的第1款最下面还有一行批注如下：

      “[ Note: An “array of N cv-qualifier-seq T” has cv-qualified type; see 3.9.3. —end note ]”

      意思就是对于const int[]来说，const不仅属于数组里面的int元素所有，同时还会作用到数组本身上。
      所以说，我们不得不多做点工作，把cv限定符也特化进来：

      1. #define CHECK_TYPE_ARRAY__(CV_OPT) \
      2. template <typename T, bool IsBase> \
      3. struct check<T CV_OPT [], IsBase> : check<T CV_OPT, true> \
      4. { \
      5. using base_t = check<T CV_OPT, true>; \
      6. using base_t::out_; \
      7. \
      8. bound<>         bound_; \
      9. bracket<IsBase> bracket_; \
      10. \
      11. check(const output& out) : base_t(out) \
      12. , bound_  (out_) \
      13. , bracket_(out_) \
      14. {} \
      15. };
      16. #define CHECK_TYPE_PLACEHOLDER__
      17. CHECK_TYPE_ARRAY__(CHECK_TYPE_PLACEHOLDER__)
      18. CHECK_TYPE_ARRAY__(const)
      19. CHECK_TYPE_ARRAY__(volatile)
      20. CHECK_TYPE_ARRAY__(const volatile)

      这样对于加了cv属性的数组而言，编译和显示才是正常的。
      接下来，考虑[N]，我们需要稍微修改一下上面的CHECK_TYPE_ARRAY__宏，让它可以同时处理[]和[N]：

      1. #define CHECK_TYPE_ARRAY__(CV_OPT, BOUND_OPT, ...) \
      2. template <typename T, bool IsBase __VA_ARGS__> \
      3. struct check<T CV_OPT [BOUND_OPT], IsBase> : check<T CV_OPT, true> \
      4. { \
      5. using base_t = check<T CV_OPT, true>; \
      6. using base_t::out_; \
      7. \
      8. bound<BOUND_OPT> bound_; \
      9. bracket<IsBase>  bracket_; \
      10. \
      11. check(const output& out) : base_t(out) \
      12. , bound_  (out_) \
      13. , bracket_(out_) \
      14. {} \
      15. };
      16. #define CHECK_TYPE_ARRAY_CV__(BOUND_OPT, ...) \
      17. CHECK_TYPE_ARRAY__(, BOUND_OPT, ,##__VA_ARGS__) \
      18. CHECK_TYPE_ARRAY__(const, BOUND_OPT, ,##__VA_ARGS__) \
      19. CHECK_TYPE_ARRAY__(volatile, BOUND_OPT, ,##__VA_ARGS__) \
      20. CHECK_TYPE_ARRAY__(const volatile, BOUND_OPT, ,##__VA_ARGS__)

      这段代码里稍微用了点“preprocessor”式的技巧。gcc的__VA_ARGS__处理其实不那么人性化。虽然我们可以通过“,##__VA_ARGS__”，在变参为空时消除掉前面的逗号，但这个机制却只对第一层宏有效。当我们把__VA_ARGS__继续向下传递时，变参为空逗号也不会消失。
      因此，我们只有用上面这种略显抽搐的写法来干掉第二层宏里的逗号。这个处理技巧也同样适用于vc。

      然后，实现各种特化模板的时候到了：

      1. #define CHECK_TYPE_PLACEHOLDER__
      2. CHECK_TYPE_ARRAY_CV__(CHECK_TYPE_PLACEHOLDER__)
      3. #if defined(__GNUC__)
      4. CHECK_TYPE_ARRAY_CV__(0)
      5. #endif
      6. CHECK_TYPE_ARRAY_CV__(N, size_t N)

      这里有个有意思的地方是:gcc里可以定义0长数组[0]，也叫“柔性数组”。这玩意在gcc里不会适配到T[N]或T[]上，所以要单独考虑。

      现在，我们适配上了所有的引用、数组，以及普通指针：

      1. check_type<const volatile void *(&)[10]>(); // void const volatile * (&) [10]
      2. check_type<int [1][2][3]>();                // int (([1]) [2]) [3]

      这里看起来有点不一样的是多维数组的输出结果，每个维度都被括号限定了结合范围。这种用括号明确标明数组每个维度的结合优先级的写法，虽然看起来不那么干脆，不过在C++中也是合法的。
      当然，如果觉得这样不好看，想搞定这个也很简单，稍微改一下CHECK_TYPE_ARRAY__就可以了：

      1. #define CHECK_TYPE_ARRAY__(CV_OPT, BOUND_OPT, ...) \
      2. template <typename T, bool IsBase __VA_ARGS__> \
      3. struct check<T CV_OPT [BOUND_OPT], IsBase> : check<T CV_OPT, !std::is_array<T>::value> \
      4. { \
      5. using base_t = check<T CV_OPT, !std::is_array<T>::value>; \
      6. using base_t::out_; \
      7. \
      8. bound<BOUND_OPT> bound_; \
      9. bracket<IsBase>  bracket_; \
      10. \
      11. check(const output& out) : base_t(out) \
      12. , bound_  (out_) \
      13. , bracket_(out_) \
      14. {} \
      15. };

      这里使用了std::is_array来判断下一层类型是否仍旧是数组，如果是的话，则不输出括号。

      3.3 函数（Functions）的处理

      有了前面准备好的parameter，实现一个函数的特化处理非常轻松：

      1. template <typename T, bool IsBase, typename... P>
      2. struct check<T(P...), IsBase> : check<T, true>
      3. {
      4. using base_t = check<T, true>;
      5. using base_t::out_;
      6. parameter<true, P...> parameter_;
      7. bracket<IsBase>       bracket_;
      8. check(const output& out) : base_t(out)
      9. , parameter_(out_)
      10. , bracket_  (out_)
      11. {}
      12. };

      这里有一个小注意点：函数和数组一样，处于被继承的位置时需要加括号；parameter的构造时机应该在bracket的前面，这样可以保证它在bracket之后被析构，否则参数列表将被添加到错误位置上。
      我们可以打印一个变态一点的类型来验证下正确性：

      1. std::cout << check_type<char(* (* const)(const int(&)[10]) )[10]>() << std::endl;
      2. // 输出：char (* (* const) (int const (&) [10])) [10]
      3. // 这是一个常函数指针，参数是一个常int数组的引用，返回值是一个char数组的指针

      我们可以看到，函数指针已经被正确的处理掉了。这是因为一个函数指针会适配到指针上，之后去掉指针的类型将是一个正常的函数类型。
      这里我们没有考虑stdcall、fastcall等调用约定的处理，如有需要的话，读者可自行添加。

      3.4 类成员指针（Pointers to members）的处理

      类成员指针的处理非常简单：

      1. template <typename T, bool IsBase, typename C>
      2. struct check<T C::*, IsBase> : check<T, true>
      3. {
      4. using base_t = check<T, true>;
      5. using base_t::out_;
      6. check(const output& out) : base_t(out)
      7. {
      8. check<C> { out_ };
      9. out_.compact()("::*");
      10. }
      11. };

      显示效果：

      1. class Foo {};
      2. std::cout << check_type<int (Foo::* const)[3]>() << std::endl;
      3. // 输出：int (Foo::* const) [3]
      4. // 这是一个常类成员指针，指向Foo里的一个int[3]成员

      3.5 类成员函数指针（Pointers to member functions）的处理

      其实我们不用做什么特别的处理，通过T C::*已经可以适配无cv限定符的普通类成员函数指针了。只是在vc下，提取出来的T却无法适配上T(P...)的特化。
      这是因为vc中通过T C::*提取出来的函数类型带上了一个隐藏的thiscall调用约定。在vc里，我们无法声明或定义一个thiscall的普通函数类型，于是T C::*的特化适配无法完美的达到我们想要的效果。
      所以，我们还是需要处理无cv限定的类成员函数指针。通过一个和上面T C::*的特化很像的特化模板，就可以处理掉一般的类成员函数指针：

      1. template <typename T, bool IsBase, typename C, typename... P>
      2. struct check<T(C::*)(P...), IsBase> : check<T(P...), true>
      3. {
      4. using base_t = check<T(P...), true>;
      5. using base_t::out_;
      6. check(const output& out) : base_t(out)
      7. {
      8. check<C> { out_ };
      9. out_.compact()("::*");
      10. }
      11. };

      下面考虑带cv限定符的类成员函数指针。在开始书写后面的代码之前，我们需要先思考一下，cv限定符在类成员函数指针上的显示位置是哪里？答案当然是在函数的参数表后面。所以我们必须把cv限定符的输出时机放在T(P...)显示完毕之后。
      因此想要正确的输出cv限定符，我们必须调整T(P...)特化的调用时机：

      1. // Do output at destruct
      2. struct at_destruct
      3. {
      4. output&     out_;
      5. const char* str_;
      6. at_destruct(output& out, const char* str = nullptr)
      7. : out_(out)
      8. , str_(str)
      9. {}
      10. ~at_destruct(void)
      11. { out_(str_); }
      12. void set_str(const char* str = nullptr)
      13. { str_ = str; }
      14. };
      15. #define CHECK_TYPE_MEM_FUNC__(...) \
      16. template <typename T, bool IsBase, typename C, typename... P> \
      17. struct check<T(C::*)(P...) __VA_ARGS__, IsBase> \
      18. { \
      19. at_destruct cv_; \
      20. check<T(P...), true> base_; \
      21. output& out_ = base_.out_; \
      22. \
      23. check(const output& out) \
      24. : cv_(base_.out_) \
      25. , base_(out) \
      26. { \
      27. cv_.set_str(#__VA_ARGS__); \
      28. check<C> { out_ }; \
      29. out_.compact()("::*"); \
      30. } \
      31. };
      32. CHECK_TYPE_MEM_FUNC__()
      33. CHECK_TYPE_MEM_FUNC__(const)
      34. CHECK_TYPE_MEM_FUNC__(volatile)
      35. CHECK_TYPE_MEM_FUNC__(const volatile)

      上面这段代码先定义了一个at_destruct，用来在析构时执行“输出cv限定符”的动作；同时把原本处在基类位置上的T(P...)特化放在了第二成员的位置上，这样就保证了它将会在cv_之后才被析构。
      这里要注意的是，at_destruct的构造在base_和out_之前，所以如果直接给cv_传递out_时不行的，这个时候out_还没有初始化呢。但是在这个时候，虽然base_同样尚未初始化，但base_.out_的引用却是有效的，因此我们可以给cv_传递一个base_.out_。
      另外，at_destruct虽然定义了带str参数的构造函数，CHECK_TYPE_MEM_FUNC__宏中却没有使用它。原因是若在宏中使用#__VA_ARGS__作为参数，那么当变参为空时，#__VA_ARGS__前面的逗号在vc中不会被自动忽略掉（gcc会忽略）。

      最后，来一起看看输出效果吧：

      1. class Foo {};
      2. std::cout << check_type<int (Foo::* const)(int, Foo&&, int) volatile>() << std::endl;
      3. // 输出：int (Foo::* const) (int, Foo &&, int) volatile
      4. // 这是一个常类成员函数指针，指向Foo里的一个volatile成员函数

      尾声

      折腾C++的类型系统是一个很有意思的事情。当钻进去之后就会发现，一些原先比较晦涩的基本概念，在研究的过程中都清晰了不少。
      check_type的实用价值在于，可以利用它清晰的看见C++中一些隐藏的类型变化。比如完美转发时的引用折叠：

      1. class Foo {};
      2. template <typename T>
      3. auto func(T&&) -> T;
      4. std::cout << check_type<decltype(func<Foo>)>() << std::endl;
      5. std::cout << check_type<decltype(func<Foo&>)>() << std::endl;
      6. std::cout << check_type<decltype(func<Foo&&>)>() << std::endl;

      在上面实现check_type的过程中，用到了不少泛型，甚至元编程的小技巧，充分运用了C++在预处理期、编译期和运行期（RAII）的处理能力。虽然这些代码仅是学习研究时的兴趣之作，实际项目中往往typeid的返回结果就足够了，但上面的不少技巧对一些现实中的项目开发也有一定的参考和学习价值。

      顺便说一下：上面的代码里使用了大量C++11的特征。若想在老C++中实现check_type，大部分的新特征也都可以找到替代的手法。只是适配函数类型时使用的变参模板，在C++98/03下实现起来实在抽搐。论代码的表现力和舒适度，C++11强过C++98/03太多了。

      完整代码及测试下载请点击：check_type

      Wrote by mutouyun. (http://darkc.at/cxx-get-the-name-of-the-given-type/)

http://blog.csdn.net/markl22222/article/details/25928597

上一篇：[转]jni数据类型映射、域描述符说明


下一篇：Android 框架练成 教你打造高效的图片加载框架（转）