C++ Type Erasure：擦除类型信息，实现运行时多态的另一种方式

好的，各位观众，欢迎来到今天的“C++黑魔法讲座”。今天我们要聊的是一个听起来高深莫测，但其实非常实用的技术——Type Erasure，也就是“类型擦除”。

引子：多态的烦恼

我们都知道，C++里实现多态最常用的手段就是虚函数。这玩意儿好用是好用，但也有它的局限性。比如，你得用继承，而且要在编译期就确定好继承关系。

想象一下，你写了一个图形库，里面有一堆形状类，比如圆形、矩形、三角形等等。你希望用户可以自己定义新的形状，并且能无缝地融入你的图形库。如果用虚函数，那就意味着用户必须继承你预先定义好的基类。这限制了用户的自由度，而且也可能让你的代码变得臃肿不堪，因为你得考虑各种各样的可能性。

再比如，你有一个容器，你想往里面放各种各样的东西，只要它们能被“绘制”就行。如果用虚函数，你就得定义一个抽象的“可绘制”基类，然后让所有能被绘制的类都继承它。这听起来还好，但如果你的容器里要放的是来自第三方库的类，而这些类又没有继承你的“可绘制”基类呢？你就得自己写适配器，这又是一堆代码。

那么，有没有一种方法，既能实现多态，又能摆脱继承的束缚呢？答案是肯定的，那就是Type Erasure。

Type Erasure：擦掉类型，保留行为

Type Erasure的核心思想是：我们不关心对象的具体类型，只关心它能做什么。就像你雇佣了一个工人，你并不关心他是哪里人，多大了，你只关心他能不能把活干好。

具体来说，Type Erasure通过以下几个步骤来实现：

1. 定义一个接口（Concept）： 这个接口描述了我们关心的行为。比如，对于“可绘制”的对象，我们可能关心它有没有一个draw()方法。
2. 创建一个内部的“桥接”类： 这个桥接类负责将具体的类型转换为接口的行为。它内部会保存一个指向实际对象的指针，并且会将接口的调用转发给这个对象。
3. 创建一个外部的“包装”类： 这个包装类是用户直接使用的类。它内部会保存一个指向桥接类的指针。当用户调用包装类的接口方法时，包装类会将调用转发给桥接类。

这样一来，用户就可以使用包装类来操作各种各样的对象，而不需要关心这些对象的具体类型。只要这些对象能够提供包装类所需要的接口，就可以被包装起来使用。

代码示例：一个简单的可绘制对象

让我们用一个简单的例子来说明一下。假设我们要实现一个可以绘制各种形状的系统。

#include <iostream>
#include <memory>

// 1. 定义接口（Concept）
class Drawable {
public:
    virtual void draw() = 0;
    virtual ~Drawable() = default;
};

// 2. 创建桥接类
template <typename T>
class DrawableImpl : public Drawable {
public:
    DrawableImpl(T obj) : obj_(std::move(obj)) {}

    void draw() override {
        obj_.draw();
    }

private:
    T obj_;
};

// 3. 创建包装类
class AnyDrawable {
public:
    // 构造函数，接受任何可以draw的对象
    template <typename T>
    AnyDrawable(T obj) : impl_(std::make_unique<DrawableImpl<T>>(std::move(obj))) {}

    void draw() {
        impl_->draw();
    }

private:
    std::unique_ptr<Drawable> impl_;
};

// 示例形状类
class Circle {
public:
    void draw() {
        std::cout << "Drawing a circle!" << std::endl;
    }
};

class Square {
public:
    void draw() {
        std::cout << "Drawing a square!" << std::endl;
    }
};

int main() {
    Circle circle;
    Square square;

    AnyDrawable drawableCircle(circle);
    AnyDrawable drawableSquare(square);

    drawableCircle.draw();
    drawableSquare.draw();

    return 0;
}

在这个例子中，Drawable是我们的接口，定义了一个draw()方法。DrawableImpl是桥接类，它将具体的类型T转换为Drawable接口。AnyDrawable是包装类，它接受任何可以draw()的对象，并将其包装成一个Drawable对象。

注意，Circle和Square类并没有继承任何基类。它们只是提供了draw()方法，就可以被AnyDrawable包装起来使用。

更强大的Type Erasure：使用函数对象

上面的例子虽然简单，但不够灵活。如果我们想要支持更多的操作，比如resize()、move()等等，就需要为Drawable接口添加更多的方法。这会让接口变得臃肿，而且也限制了我们能支持的操作。

一个更强大的Type Erasure方法是使用函数对象。我们可以将每个操作都封装成一个函数对象，然后将这些函数对象存储在桥接类中。这样一来，我们就可以支持任意的操作，而不需要修改接口。

#include <iostream>
#include <memory>
#include <functional>

// 包装类
class Any {
public:
    // 构造函数，接受任意类型的对象
    template <typename T>
    Any(T obj) : impl_(std::make_unique<Model<T>>(std::move(obj))) {}

    // 模仿一个函数调用操作
    template <typename... Args>
    auto operator()(Args&&... args) -> decltype(impl_->invoke(std::forward<Args>(args)...)) {
        return impl_->invoke(std::forward<Args>(args)...);
    }

private:
    // 抽象基类，定义了invoke接口
    class Concept {
    public:
        virtual ~Concept() = default;
        virtual auto invoke() -> void = 0; // 默认无参数
        template <typename... Args>
        virtual auto invoke(Args&&... args) -> void = 0;
    };

    // 模板类，负责类型擦除和函数调用
    template <typename T>
    class Model : public Concept {
    public:
        Model(T obj) : obj_(std::move(obj)) {}

        auto invoke() -> void override {
            // 假设对象有一个默认的无参draw方法
            obj_.draw();
        }

        template <typename... Args>
        auto invoke(Args&&... args) -> decltype(obj_.draw(std::forward<Args>(args)...)) override {
            // 假设对象有一个带参数的draw方法
            return obj_.draw(std::forward<Args>(args)...);
        }

    private:
        T obj_;
    };

    std::unique_ptr<Concept> impl_;
};

// 示例类
class Circle {
public:
    void draw() {
        std::cout << "Drawing a circle!" << std::endl;
    }

    void draw(int color) {
        std::cout << "Drawing a circle with color: " << color << std::endl;
    }
};

int main() {
    Circle circle;
    Any anyCircle(circle);

    // 调用无参数的draw方法
    anyCircle();

    // 调用带参数的draw方法
    anyCircle(10);

    return 0;
}

在这个例子中，Any类可以包装任何类型的对象，并且可以调用这些对象的任意方法。我们只需要在Model类中定义相应的invoke方法即可。

Type Erasure的优点

• 解耦： Type Erasure可以让你在不知道具体类型的情况下操作对象，从而实现解耦。
• 灵活性： Type Erasure可以让你支持任意的操作，而不需要修改接口。
• 可扩展性： Type Erasure可以让你轻松地添加新的类型和操作，而不需要修改现有的代码。

Type Erasure的缺点

• 性能： Type Erasure会引入额外的间接层，可能会影响性能。
• 复杂性： Type Erasure的代码相对复杂，需要仔细设计。
• 调试： Type Erasure可能会使调试更加困难，因为你需要在运行时才能确定对象的具体类型。

Type Erasure的应用场景

Type Erasure在很多场景下都有应用，比如：

• 事件处理： 你可以使用Type Erasure来实现一个通用的事件处理系统，可以处理各种各样的事件。
• 插件系统： 你可以使用Type Erasure来实现一个插件系统，允许用户自定义插件，并且能无缝地集成到你的应用程序中。
• 泛型编程： 你可以使用Type Erasure来实现一些泛型算法，这些算法可以操作各种各样的数据类型。
• GUI 框架： 在GUI框架中，Type Erasure可以用来处理各种各样的控件，而不需要为每个控件都定义一个基类。
• 数据库访问： Type Erasure可以用来访问各种各样的数据库，而不需要为每个数据库都编写特定的代码。

Type Erasure与虚函数的比较

特性	Type Erasure	虚函数
继承	不需要继承	需要继承
编译期/运行时	运行时多态	编译期多态（静态绑定），运行时多态（动态绑定）
灵活性	更灵活，可以支持任意的操作	相对固定，需要在编译期确定接口
性能	可能会有额外的性能开销	性能通常更好
代码复杂度	更复杂	相对简单

高级技巧：完美转发和SFINAE

在实际使用Type Erasure时，我们经常会用到一些高级技巧，比如完美转发和SFINAE。

• 完美转发： 完美转发可以让你将参数原封不动地传递给内部的对象，避免不必要的拷贝和类型转换。
• SFINAE： SFINAE（Substitution Failure Is Not An Error）可以让你在编译期检查类型是否满足某些条件，从而选择不同的实现。

#include <iostream>
#include <memory>
#include <functional>
#include <type_traits>

// 包装类
class Any {
public:
    // 构造函数，接受任意类型的对象
    template <typename T, typename = std::enable_if_t<!std::is_same_v<std::decay_t<T>, Any>>> // 避免无限递归
    Any(T&& obj) : impl_(std::make_unique<Model<std::decay_t<T>>>(std::forward<T>(obj))) {}

    // 模仿一个函数调用操作，使用完美转发
    template <typename... Args>
    auto operator()(Args&&... args) -> decltype(impl_->invoke(std::forward<Args>(args)...)) {
        return impl_->invoke(std::forward<Args>(args)...);
    }

private:
    // 抽象基类，定义了invoke接口
    class Concept {
    public:
        virtual ~Concept() = default;
        virtual auto invoke() -> void = 0; // 默认无参数
        template <typename... Args>
        virtual auto invoke(Args&&... args) -> void = 0;
    };

    // 模板类，负责类型擦除和函数调用
    template <typename T>
    class Model : public Concept {
    public:
        Model(T obj) : obj_(std::move(obj)) {}

        auto invoke() -> void override {
            if constexpr (requires { obj_.draw(); }) {
                obj_.draw();
            } else {
                std::cout << "Object does not have a draw() method without arguments." << std::endl;
            }
        }

        template <typename... Args>
        auto invoke(Args&&... args) -> decltype(obj_.draw(std::forward<Args>(args)...)) override {
            if constexpr (requires { obj_.draw(std::forward<Args>(args)...); }) {
                return obj_.draw(std::forward<Args>(args)...);
            } else {
                std::cout << "Object does not have a draw() method with the given arguments." << std::endl;
                return; // 或者抛出一个异常
            }
        }

    private:
        T obj_;
    };

    std::unique_ptr<Concept> impl_;
};

// 示例类
class Circle {
public:
    void draw() {
        std::cout << "Drawing a circle!" << std::endl;
    }

    void draw(int color) {
        std::cout << "Drawing a circle with color: " << color << std::endl;
    }
};

class Rectangle {
public:
    void print(){
        std::cout << "Printing a rectangle!" << std::endl;
    }
};

int main() {
    Circle circle;
    Any anyCircle(circle);

    // 调用无参数的draw方法
    anyCircle();

    // 调用带参数的draw方法
    anyCircle(10);

    Rectangle rectangle;
    Any anyRectangle(rectangle);

    // 调用 print方法
    //anyRectangle(); //编译不过，因为Rectangle没有draw方法，但是编译期不会报错，直到调用的时候才会报错
}

在这个例子中，我们使用了std::forward来实现完美转发，使用了std::enable_if来避免无限递归，使用了requires表达式在编译期检查类型是否满足某些条件。

总结

Type Erasure是一种强大的技术，可以让你实现运行时多态，而不需要继承的束缚。虽然它的代码相对复杂，但它可以带来更大的灵活性和可扩展性。希望今天的讲座能让你对Type Erasure有更深入的了解。

Q&A环节

现在是Q&A环节，大家有什么问题可以提出来，我会尽力解答。感谢大家的收听！