在 C++ 编程中，我们经常会遇到需要编写独立于其操作类型（包括不同函数类型和变量类型）的情况（类似于C语言中的回调函数，但是能适配任意类型）。这时，类型擦除 (Type Erasure) 就派上用场了，它让我们能够以统一的方式处理各种类型。本文将探讨类型擦除的定义、工作原理，并提供实现 std::function 和 std::any 的示例。

什么是类型擦除

类型擦除是一种无需继承或模板即可实现多态性的语言规范。它隐藏了对象的具体类型，只暴露一个统一的接口。这使我们能够通过一个通用接口存储、传递和操作不同类型的对象，而无需在编译时知道具体类型。

为什么使用类型擦除

类型擦除有几个主要优点：

灵活性：你可以通过一个接口处理不同类型的对象。

解耦：使用类型擦除对象的代码在编译时无需知道具体类型。

多态性：无需继承即可实现运行时的多态性，从而更容易地处理不共享公共基类的现有类型。

实现类型擦除：std::function 和 std::any

C++ 标准库提供了 std::function 和 std::any，它们是类型擦除的示例。一起看看它们的工作原理。

简化的 std::function

std::function 是一个多功能的可调用对象包装器。它可以存储函数、lambda 表达式或定义了()运算操作符的对象。std::function 的关键特性在于它隐藏了可调用对象的类型，从而统一了调用接口。

示例：

#include <iostream>
#include <memory>
#include <utility>

class CallableBase { //没有类型的接口类
public:
    virtual ~CallableBase() = default;
    virtual void call() const = 0; //纯虚函数
};

template <typename T>  //用这个子类对接口类重载，赋值具体类型的函数
class CallableWrapper : public CallableBase{
public:
    CallableWrapper(T callable) :callable_(std::move(callable)) {}
    void call() const override {
        callable_();
}

private:
    T callable_;
};

class SimpleFunction{
public:
template <typename T> 
SimpleFunction(T callable): //创建时赋值初始化
		callableImpl_(std::make_shared<CallableWrapper<T>>(std::move(callable))) {}
void operand() const {//（）操作符
    if(callableImpl_)
    		callableImpl_->call();
}

private:
    std::shared_ptr<CallableBase> callableImpl_; //无类型的接口变量
};

void helloFunction(){
    std::cout <<"Hello, function !!! \n";
}

int main(){
    SimpleFunction f1 = helloFunction;
    SimpleFunction f2 = [](){std::cout << "Hello, Lambda !!!\n";};
    f1(); //输出：Hello, Function !!!
    f2(); //输出：Hello, Lambda !!!
    return 0;
}

在此例中，SimpleFunction 用于存储常规函数和lambda 表达式。被调用函数的实际类型被擦除了，并且 SimpleFunction 提供了一种统一的方法来调用存储的函数。

简化的 std::any

std::any 是一个类型安全的容器，可容纳任何类型的单个值。它可以存储任何类型的对象，并且可以使用类型安全的强制类型转换来检索存储的值。

#include <iostream>
#include <memory>
#include <utility>
#include <typeinfo>
#include <typeindex>

class AnyBase{
public:
    virtual ~AnyBase() = default;
    virtual std::type_index type() const = 0;
    virtual std::unique_ptr<AnyBase> clone() = 0;
};

template <typename T>
class AnyWrapper : public AnyBase{
public:
    explicit AnyWrapper(T value) : value_(std::move(value)){}
    std::type_index type() const override { //存储了类型信息，类型转换时用
        return typeid(T);
    }

    std::unique_ptr<AnyBase> clone() override{
        return std::make_unique<AnyWrapper<T>>(value_);
    }
    T& get(){
        return value_;
    } 

private:
    T value_;
};

class SimpleAny{
public:
    SimpleAny() = default;

    template <typename T>
    SimpleAny(T value)
        : value_(std::make_unique<AnyWrapper<T>>(std::move(value))){}

    SimpleAny(const SimpleAny& other)
        : value_(other.value_ ? other.value_->clone() : nullptr){}
    
    SimpleAny& operator=(const SimpleAny& other) {
        if (this != &other) {
            value_ = other.value_ ? other.value_->clone() : nullptr;
        }
        return *this;
    }

    std::type_index type() const{
        return value_ ? value_->type() : typeid(void);
    }

    template <typename T>
    T& get(){
        if (type() != typeid(T)) { //类型转换时判断是否类型匹配
            throw std::bad_cast();
        }
        return static_cast<AnyWrapper<T>*>(value_.get())->get();
    }

private:
    std::unique_ptr<AnyBase> value_;
};

int main(){
    SimpleAny a(10);
    std::cout << "Stored int: " << a.get<int>() << "\n";

    a = std::string("Hello, Any!");
    std::cout << "Stored string: " << a.get<std::string>() << "\n";
    return 0;
}

本例中，“SimpleAny”用于存储一个 int 类型，然后存储一个 std::string 类型。