用具体类型代替void指针

名称

用具体类型代替void指针

动机

最近有人问我c++有没有一种方法可以让一个数组包含不同类型的元素。我的第一反应是他python写得多了。不过转念一想，静态语言C/C++也是有解的。
一个常见的方法是利用C/C++弱类型的特点，将数组类型退化为void *：

struct A a = {1, 2};
void *voids[3];
voids[0] = 1;
voids[1] = "abc";
voids[2] = &a;

printf("#0:%d, #1:%s, #2:%d-%d\n", (int)voids[0], (char *)voids[1], 
                ((struct A*)voids[2])->a, ((struct A*)voids[2])->b);

退化的意思有两个：

• 从voids取出东西，编译器不知道这东西是什么。于是需要人肉翻译器（也就是你）强转成正确的类型。至于强转的类型是不是正确的，编译器爱莫能助，毕竟C语言的哲学之一就是程序员知道自己在做什么并且总是对的。但是强转多了也会有阴沟翻船的时候，实际上程序员不一定是对的，特别是把这个当做模块间的接口时。

• 另外一个问题是编译告警。voids[0] = 1;用gcc 6.2.0编译会产生编译告警，提示赋值时将整数赋给指针，未作类型转换 [-Wint-conversion]。加上强转（voids[0] = (void *)1;）可以消除这个告警。

  但是printf那行的(int)voids[0]还有编译告警：将一个指针转换为大小不同的整数 [-Wpointer-to-int-cast]。编译环境是X64，int长度是32位，而指针长度是64位。这也算不上难题，可以把类型改成long来解决。还得同步把%d改成%ld，不然又会报另外一个告警。

  说了这么大堆编译告警，也许有点吹毛求疵。但是也可以看出整型和指针其实是不相容的，这种写法多少显得有点格格不入。
  当然也可以把int换成int *，这样大家都是指针。这相当于增加一层薄薄的中间层，开销值不值得尚且不论，单单是这个指针的生命周期管理也得好好想想。

如果前面两个问题尚且还可以忍受，稍有不慎就会抛异常—这点相信大家都接受不了。究其原因，这个方法在setter和getter之间形成了一个关于类型的契约，不过这个契约却是若有若无。因为人为跳过了静态语言的一大优势--类型检查，只能依赖不靠谱的人肉编译器（没错，还是你）来检查。当脆弱的契约在不经意间被打破，BUG会在运行时伺机而动，有时甚至会潜伏起来,等待在关键时刻给你当头棒喝。
如下代码，编译能通过，甚至都没有编译告警，但是在运行时却抛出了一个段错误。

    voids[0] = (void *)1;
    int x = *((int *)voids[0]);

在代码初期，这类问题一般很少发生。随着新需求带来的增量开发，架构腐化，代码由原作者转交其他人维护，这类问题逐渐显现出来。

机制

void指针数组的优势在于前期写代码很方便，但是成本却悄悄的累积到后期的维护工作中。但是对于大型软件来说，前期开发只占整个软件生命周期很小一部分，后期维护占绝大部分。所以这个方案并不可取。这是一种短视的行为，对长期的成本却视而不见。这是一种常见的人性的弱点。正如一个大牛所说的『开发有时候是反人性的』，只有不断的克服人性的弱点，才能开发出优秀的软件。宁可开始慢一些，也要开发出可持续演进的代码。
最简单直接的方案是把void指针数组替换成结构体，每个类型对应一个结构体成员。例如，前面的void指针数组可以改为下面的结构体：

struct B {
    int a;
    char *b;
    struct A c;
};

C++11引入了tuple，可以类似数组一样使用：

struct A a = {1, 2};
auto t = std::make_tuple(1, "abc", a);
auto ta = std::get<2>(t);
std::cout << "#1:" << typeid(std::get<0>(t)).name() << "/" << std::get<0>(t) << "\n"
            << "#2:" << typeid(std::get<1>(t)).name() << "/" << std::get<1>(t) << "\n"
            << "#3:" << typeid(ta).name() << "/" << ta.a << "-" << ta.b << std::endl;

输出为：

#1:i/1
#2:PKc/abc
#3:1A/1-2

C++17还把any转正了，any+vector用起来很方便：

    std::vector<std::any> v;
    v.push_back(1);
    v.push_back("abc");
    v.push_back(a);
    std::cout << "#1:" <<  v[0].type().name() << "/" << std::any_cast<int>(v[0]) << "\n"
              << "#2:" <<  v[1].type().name() << "/" << std::any_cast<const char *>(v[1]) << "\n"
              << "#3:" <<  v[2].type().name() << "/" << std::any_cast<A>(v[2]).a << std::endl;

但是any方案也不是很完美。一方面是因为取用还是要用any_cast强转，另一方面，编译时不会报错。
例如下面代码：

std::any_cast<float>(v[0]);

编译时没有报出错误，而是在运行时抛出异常：

terminate called after throwing an instance of 'std::bad_any_cast'
  what():  bad any_cast

any只能算作void *的运行时安全版本（运行时检查类型）。
而C++17引入的另一个新类型variant则是枚举类型的运行时安全版本。variant也存在any的两个问题：

• 获取时也需要指定类型（std::get<类型>）；
• 如果类型不对，也会在运行时抛一个异常（std::bad_variant_access），而不是编译告警。

C++如果用基类指针数组，在运行时通过type_info进行类型检查，可参考cppmock的实现。

例子