C++ 类型擦除（Type Erasure）的编译时实现：不依赖虚函数的多态

哈喽，各位好！今天咱们来聊聊C++里一个挺有意思的话题：类型擦除的编译时实现，而且是不依赖虚函数的那种。这玩意儿听起来高大上，其实说白了，就是一种实现多态的方式，但它不走寻常路，不用虚函数，而是靠模板和一些编译时的技巧来搞定。

1. 啥是类型擦除？为啥要用它？

先来简单说说类型擦除的概念。想象一下，你有一个函数，希望它可以处理不同类型的对象，但这些对象都提供类似的功能。比如，你有个“画图”的函数，能画圆形、矩形，甚至是自定义的形状。通常，我们会用虚函数来实现多态，定义一个基类，然后让圆形、矩形继承这个基类，再重写虚函数。

但是！虚函数是有开销的，每次调用都要查虚函数表，这在性能敏感的场景下可能不太划算。而且，如果你的类型（比如圆形）不是你设计的，而是来自第三方库，你可能没法让它继承你的基类。

这时候，类型擦除就派上用场了。它允许你把不同类型的对象，包装成一个统一的接口，隐藏掉底层的具体类型。这样，你的函数就能处理这些对象，而不用关心它们到底是什么类型。

2. 编译时类型擦除：不用虚函数也能飞

重点来了，咱们要讲的是编译时的类型擦除。这意味着，类型擦除的逻辑在编译期间就确定好了，运行时不需要查虚函数表，性能更高。

实现编译时类型擦除的关键在于：

• 模板（Templates）： C++模板的威力大家都懂，可以根据不同的类型生成不同的代码。
• 函数对象（Function Objects，也叫 Functors）： 把函数或者方法封装成对象，方便传递和调用。
• SFINAE（Substitution Failure Is Not An Error）： 一种编译时的技术，允许编译器在模板参数推导失败时，不报错，而是尝试其他的重载。

3. 实战演练：一个简单的例子

为了更好地理解，我们来写一个简单的例子。假设我们要实现一个可以存储不同类型数据的容器，并且可以对这些数据进行“打印”操作。

#include <iostream>
#include <type_traits> // for std::invoke_result_t

// 概念：要求类型 T 必须提供 Print 方法
template <typename T>
concept Printable = requires(T t) {
    { t.Print() } -> std::same_as<void>; // T 必须有 Print 方法，且返回 void
};

// 类型擦除的包装器
template <Printable T>
class AnyPrintable {
private:
    T data;

public:
    AnyPrintable(T obj) : data(obj) {}

    void Print() {
        data.Print();
    }
};

// 泛型包装器，实现真正的类型擦除
class Any {
private:
    // 存储函数指针，指向具体类型的 Print 函数
    void (*print_func)(void*);
    // 存储数据的指针
    void* data;
    // 用于析构数据的函数指针
    void (*dtor)(void*); // Destructor

    //使用模板函数完成构造
    template <typename T>
    Any(T obj) : data(new T(obj)),
                  print_func([](void* p){ static_cast<T*>(p)->Print(); }),
                  dtor([](void* p){ delete static_cast<T*>(p); })
    {}

public:
    // 构造函数模板，接受任意类型
    template <typename T>
    Any(T obj) : Any(std::move(obj)) {}

    // 析构函数
    ~Any() {
        if (dtor) {
            dtor(data);
        }
    }

    // 禁用拷贝构造和拷贝赋值
    Any(const Any&) = delete;
    Any& operator=(const Any&) = delete;

    // 移动构造和移动赋值
    Any(Any&& other) noexcept : data(other.data), print_func(other.print_func), dtor(other.dtor){
        other.data = nullptr;
        other.print_func = nullptr;
        other.dtor = nullptr;
    }

    Any& operator=(Any&& other) noexcept {
        if (this != &other) {
            std::swap(data, other.data);
            std::swap(print_func, other.print_func);
            std::swap(dtor, other.dtor);
        }
        return *this;
    }

    // 打印函数
    void Print() {
        if (print_func) {
            print_func(data);
        }
    }
};

// 测试类型 1
struct Circle {
    int radius;
    void Print() {
        std::cout << "Circle with radius: " << radius << std::endl;
    }
};

// 测试类型 2
struct Rectangle {
    int width;
    int height;
    void Print() {
        std::cout << "Rectangle with width: " << width << ", height: " << height << std::endl;
    }
};

int main() {
    Any a = Circle{5};
    Any b = Rectangle{3, 4};

    a.Print(); // 输出：Circle with radius: 5
    b.Print(); // 输出：Rectangle with width: 3, height: 4

    return 0;
}

在这个例子中：

• Printable 是一个概念，用于约束类型 T 必须提供一个 Print 方法。
• AnyPrintable 是一个简单的包装器，它接受一个实现了 Printable 概念的类型，并提供一个 Print 方法，直接调用内部对象的 Print 方法。这部分不是必须的，只是方便理解。
• Any 是一个泛型包装器，它使用函数指针来存储和调用具体类型的 Print 方法。构造函数使用模板来接受任意类型，并将对象存储在堆上。析构函数负责释放堆上的内存。
• Circle 和 Rectangle 是两个测试类型，它们都实现了 Print 方法。

4. 代码分解：一步一步来看

让我们更深入地分析一下代码：

• 概念（Concept）: Printable 概念使用 requires 关键字来定义对类型 T 的要求。这是一种编译时的检查，确保只有满足 Printable 概念的类型才能被 AnyPrintable 包装。

• Any 类的实现：

  • void (*print_func)(void*): 这是一个函数指针，用于指向具体类型的 Print 函数。它接受一个 void* 参数，表示指向数据的指针。
  • void* data: 这是一个 void* 指针，用于存储数据的地址。由于我们不知道数据的具体类型，所以使用 void* 来存储。
  • void (*dtor)(void*): 这是一个函数指针，用于指向具体类型的析构函数。它接受一个 void* 参数，表示指向数据的指针。
  • 构造函数模板：构造函数模板接受任意类型 T 的对象，并将对象存储在堆上。它还初始化 print_func 和 dtor 函数指针，分别指向 T 类型的 Print 函数和析构函数。
  • 析构函数：析构函数负责释放堆上的内存。它首先检查 dtor 函数指针是否为空，如果不为空，则调用 dtor 函数来析构数据。
  • Print 函数：Print 函数调用 print_func 函数指针来执行具体类型的 Print 函数。

• 模板构造函数: 模板构造函数是关键，它负责接受不同类型的对象，并把它们转换成统一的接口。

  template <typename T>
  Any(T obj) : data(new T(obj)),
                print_func([](void* p){ static_cast<T*>(p)->Print(); }),
                dtor([](void* p){ delete static_cast<T*>(p); })
  {}

  这里，我们使用 new T(obj) 在堆上创建了一个 T 类型的对象，并把它的地址存储在 data 成员中。同时，我们使用一个 Lambda 表达式来捕获 Print 函数和析构函数，并把它们的地址分别存储在 print_func 和 dtor 成员中。

• Print() 方法: Print() 方法负责调用实际的打印函数。

  void Print() {
      if (print_func) {
          print_func(data);
      }
  }

  这里，我们首先检查 print_func 是否为空，如果不为空，则调用它，并把 data 传递给它。

5. 优点和缺点

这种编译时类型擦除的方法有很多优点：

• 性能： 没有虚函数调用，性能更高。
• 灵活性： 可以处理任何类型的对象，只要它们提供了相应的操作（比如 Print()）。
• 非侵入性： 不需要修改现有类型，就可以把它们包装成统一的接口。

当然，它也有一些缺点：

• 代码膨胀： 模板会生成多份代码，可能会导致代码体积增大。
• 复杂性： 实现起来比虚函数要复杂一些，需要用到模板、函数对象等高级技巧。
• 编译时错误： 如果类型不支持所需的操作，会在编译时报错，而不是运行时。

特性	虚函数	编译时类型擦除 (模板)
实现方式	运行时多态，通过虚函数表实现	编译时多态，通过模板、函数对象等实现
性能	运行时查虚函数表，有一定开销	编译时确定，无运行时开销，性能更高
灵活性	只能处理继承自同一基类的类型	可以处理任何提供所需操作的类型
代码体积	较小，虚函数表共享	较大，模板会生成多份代码
错误检测	运行时错误，可能导致程序崩溃	编译时错误，更容易发现和修复
侵入性	需要修改现有类型，让它们继承基类	不需要修改现有类型，非侵入性
复杂性	相对简单，易于理解和使用	相对复杂，需要用到模板、函数对象等高级技巧
适用场景	类型关系明确，需要运行时多态的场景	类型关系不明确，追求性能，不需要运行时多态的场景

6. 进阶：更多操作和状态

上面的例子只实现了简单的“打印”操作。实际上，你可以扩展这个方法，支持更多的操作和状态。

比如，你可以添加一个 Size() 方法，返回对象的大小：

class Any {
private:
    void (*print_func)(void*);
    size_t (*size_func)(void*); // 新增：获取大小的函数指针
    void* data;
    void (*dtor)(void*); // Destructor

    template <typename T>
    Any(T obj) : data(new T(obj)),
                  print_func([](void* p){ static_cast<T*>(p)->Print(); }),
                  size_func([](void* p){ return sizeof(T); }), // 初始化 size_func
                  dtor([](void* p){ delete static_cast<T*>(p); })
    {}

public:
    template <typename T>
    Any(T obj) : Any(std::move(obj)) {}

    ~Any() {
        if (dtor) {
            dtor(data);
        }
    }

    Any(const Any&) = delete;
    Any& operator=(const Any&) = delete;

    Any(Any&& other) noexcept : data(other.data), print_func(other.print_func), size_func(other.size_func), dtor(other.dtor){
        other.data = nullptr;
        other.print_func = nullptr;
        other.size_func = nullptr;
        other.dtor = nullptr;
    }

    Any& operator=(Any&& other) noexcept {
        if (this != &other) {
            std::swap(data, other.data);
            std::swap(print_func, other.print_func);
            std::swap(size_func, other.size_func);
            std::swap(dtor, other.dtor);
        }
        return *this;
    }

    void Print() {
        if (print_func) {
            print_func(data);
        }
    }

    size_t Size() { // 新增：获取大小的方法
        if (size_func) {
            return size_func(data);
        }
        return 0;
    }
};

// 测试类型 1
struct Circle {
    int radius;
    void Print() {
        std::cout << "Circle with radius: " << radius << std::endl;
    }
};

// 测试类型 2
struct Rectangle {
    int width;
    int height;
    void Print() {
        std::cout << "Rectangle with width: " << width << ", height: " << height << std::endl;
    }
};

int main() {
    Any a = Circle{5};
    Any b = Rectangle{3, 4};

    a.Print(); // 输出：Circle with radius: 5
    b.Print(); // 输出：Rectangle with width: 3, height: 4

    std::cout << "Size of a: " << a.Size() << std::endl; // 输出：Size of a: 4 (或 Circle 的实际大小)
    std::cout << "Size of b: " << b.Size() << std::endl; // 输出：Size of b: 8 (或 Rectangle 的实际大小)

    return 0;
}

注意：这里 size_func 直接使用了 sizeof(T)，这在某些情况下可能不准确，比如类型包含动态分配的内存。更复杂的实现可能需要为每个类型提供一个专门的 Size() 函数。

7. 总结：类型擦除，不止一种姿势

总而言之，编译时类型擦除是一种强大的技术，可以让你在C++中实现多态，而不用依赖虚函数。它通过模板、函数对象等技巧，在编译时确定类型擦除的逻辑，从而提高性能。虽然实现起来稍微复杂一些，但它可以让你写出更灵活、更高效的代码。

当然，类型擦除还有其他的实现方式，比如基于 std::function 的运行时类型擦除。选择哪种方式，取决于你的具体需求和场景。如果追求性能，并且类型关系不明确，那么编译时类型擦除可能是一个不错的选择。

希望今天的分享能帮助你更好地理解C++的类型擦除。下次再见！