怎样在C++中获得完整的类型名称

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

地球人都知道C++里有一个typeid操作符能够用来获取一个类型/表达式的名称：

std::cout << typeid(int).name() << std::endl;

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

int // vc
i   // gcc

一个略微长一点的类型名称。比方：

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

打出来是这个效果：

class Foo * [10] // vc
A10_P3Foo        // gcc

（话说gcc您的返回结果真是。。

）
当然了，想在gcc里得到和微软差点儿相同显示效果的方法也是有的。那就是使用__cxa_demangle：

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

显示效果：

Foo* [10]

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

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

显示效果：

int // vc
int // gcc

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

一、怎样检查C++中的类型

我们须要一个泛型类，用特化/偏特化机制静态检查出C++中的各种类型，而且不能忽略掉类型限定符（type-specifiers）和各种声明符（declarators）。

先来考虑一个最简单的类模板：

template <typename T>
struct check
{
    // ...
};

假如在它的基础上特化，须要写多少个版本号呢？我们能够略微实现下试试：

template <typename T> struct check<T &>;
template <typename T> struct check<T const &>;
template <typename T> struct check<T volatile &>;
template <typename T> struct check<T const volatile &>;
 
template <typename T> struct check<T &&>;
template <typename T> struct check<T const &&>;
template <typename T> struct check<T volatile &&>;
template <typename T> struct check<T const volatile &&>;
 
template <typename T> struct check<T *>;
template <typename T> struct check<T const *>;
template <typename T> struct check<T volatile *>;
template <typename T> struct check<T const volatile *>;
template <typename T> struct check<T * const>;
template <typename T> struct check<T * volatile>;
template <typename T> struct check<T * const volatile>;
 
template <typename T> struct check<T []>;
template <typename T> struct check<T const []>;
template <typename T> struct check<T volatile []>;
template <typename T> struct check<T const volatile []>;
template <typename T, size_t N> struct check<T [N]>;
template <typename T, size_t N> struct check<T const [N]>;
template <typename T, size_t N> struct check<T volatile [N]>;
template <typename T, size_t N> struct check<T const volatile [N]>;
 
// ......

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

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

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

只是正因为类型事实上是嵌套的。我们能够用模板元编程的基本思路来搞定这个问题：

template <typename T> struct check<T const> : check<T>;
template <typename T> struct check<T volatile> : check<T>;
template <typename T> struct check<T const volatile> : check<T>;
 
template <typename T> struct check<T & > : check<T>;
template <typename T> struct check<T &&> : check<T>;
template <typename T> struct check<T * > : check<T>;
 
// ......

一个简单的继承，就让特化变得simple非常多。由于当我们萃取出一个类型。比方T *，之后的T事实上是携带上了除*之外全部其它类型信息的一个类型。

那么把这个T再反复投入check中，就会继续萃取它的下一个类型特征。

能够先用指针、引用的萃取来看看效果：

#include <iostream>
 
template <typename T>
struct check
{
    check(void)  { std::cout << typeid(T).name(); }
    ~check(void) { std::cout << std::endl; }
};
 
#define CHECK_TYPE__(OPT) 
    template <typename T> 
    struct check<T OPT> : check<T> 
    { 
        check(void) { std::cout << " "#OPT; } 
    };
 
CHECK_TYPE__(const)
CHECK_TYPE__(volatile)
CHECK_TYPE__(const volatile)
CHECK_TYPE__(&)
CHECK_TYPE__(&&)
CHECK_TYPE__(*)
 
int main(void)
{
    check<const volatile void * const*&>();
    system("pause");
    return 0;
}

输出结果（vc）：

void const volatile * const * &

非常美丽，是不是？当然，在gcc里这样输出，void会变成v，所以gcc以下要这样写check模板：

template <typename T>
struct check
{
    check(void)
    {
        char* real_name = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
        std::cout << real_name;
        free(real_name);
    }
    ~check(void) { std::cout << std::endl; }
};

二、保存和输出字符串

我们能够简单的这样改动check让它同一时候支持vc和gcc：

template <typename T>
struct check
{
    check(void)
    {
#   if defined(__GNUC__)
        char* real_name = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
        std::cout << real_name;
        free(real_name);
#   else
        std::cout << typeid(T).name();
#   endif
    }
    ~check(void) { std::cout << std::endl; }
};

可是到眼下为止，check的输出结果都是无法保存的。比較好的方式是可以像typeid(T).name()一样返回一个字符串。

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

class output
{
    bool is_compact_ = true;
 
    template <typename T>
    bool check_empty(const T&) { return false; }
    bool check_empty(const char* val)
    {
        return (!val) || (val[0] == 0);
    }
 
    template <typename T>
    void out(const T& val)
    {
        if (check_empty(val)) return;
        if (!is_compact_) sr_ += " ";
        using ss_t = std::ostringstream;
        sr_ += static_cast<ss_t&>(ss_t() << val).str();
        is_compact_ = false;
    }
 
    std::string& sr_;
 
public:
    output(std::string& sr) : sr_(sr) {}
 
    output& operator()(void) { return (*this); }
 
    template <typename T1, typename... T>
    output& operator()(const T1& val, const T&... args)
    {
        out(val);
        return operator()(args...);
    }
 
    output& compact(void)
    {
        is_compact_ = true;
        return (*this);
    }
};

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

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

这样的写法比cout的流操作符舒服多了。

二是operator()和compact的返回值。当然，这里能够直接使用void，可是这会造成一些限制。
比方说，我们想在使用operator()之后立即compact呢？若让函数返回自身对象的引用，就能够让output用起来很顺手：

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

check的定义和CHECK_TYPE__宏仅仅须要略作改动就能够使用output类：

template <typename T>
struct check
{
    output out_;
    check(const output& out) : out_(out)
    {
#   if defined(__GNUC__)
        char* real_name = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
        out_(real_name);
        free(real_name);
#   else
        out_(typeid(T).name());
#   endif
    }
};
 
#define CHECK_TYPE__(OPT) 
    template <typename T> 
    struct check<T OPT> : check<T> 
    { 
        using base_t = check<T>; 
        using base_t::out_; 
        check(const output& out) : base_t(out) { out_(#OPT); } 
    };

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

template <typename T>
inline std::string check_type(void)
{
    std::string str;
    check<T> { str };
    return std::move(str);
}
 
int main(void)
{
    std::cout << check_type<const volatile void * const*&>() << std::endl;
    system("pause");
    return 0;
}

假设我们想实现表达式的类型输出，使用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()的结果。

一种健壮的写法能够像这样：

template <typename T>
struct check
{
    output out_;
    check(const output& out) : out_(out)
    {
#   if defined(__GNUC__)
        const char* typeid_name = typeid(T).name();
        auto deleter = [](char* p)
        {
            if (p) free(p);
        };
        std::unique_ptr<char, decltype(deleter)> real_name
        {
            abi::__cxa_demangle(typeid_name, nullptr, nullptr, nullptr), deleter
        };
        out_(real_name ?
 real_name.get() : typeid_name);
#   else
        out_(typeid(T).name());
#   endif
    }
};

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

三、输出有效的类型定义

3.1 一些准备工作

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

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

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