Any 的原理以及实现

序言

在 C++17 的更新中引入了一个特别有意思的类型，它提供了一种通用的方式来存储任何类型的数据而不需要提前指定类型， 该类型就是 any。
any 允许你将任意类型的数据存储在一个容器中，并且能够在运行时动态地访问该数据。话不多说，让我们一睹为快吧😊！

首先大家需要注意 any 是 C++17更新的内容，如果大家需要使用，那么至少 17 及以上的版本！

Any 的使用

在刚开始使用 any 时，我总认为他是一个万能类型，但是之后，我更认为它是一种容器，能存储任何类型的值。先简单使用一下吧：

int main()
{
	std::any A = 1;
	std::any B = std::string("ABC");	
	
	A = B;

	return 0;
}

可以看到 any 不仅可以接受任意类型，还可以进行不同类型的转化。为什么我说 any 更像是一种容器呢？

首先，一个标准库实现的类型，通常都是会重载流插入流提取，但是 any 不能直接使用：
在这里插入图片描述

那我就是想要打印 any 存储的值该怎么办呢？std::any_cast 提供了类型安全的访问方法（不正确的类型访问抛出异常）：
在这里插入图片描述

其次 any 实现的方法也很像一个容器的操作：

// 查看 any 是否存储了值
A.has_value();

// 清空 any 的值
A.reset();

总之，封装到 std::any 中的对象可以是任何类型的对象，只要它是有效的 C++ 类型（例如内置类型、用户自定义类型、类对象等）。

Any 的原理和实现

计算机的世界没有魔法。 any 是怎么实现的类型擦除的呢？大家可能第一时间想到模板。确实，模板帮助了我们进行泛型编程。但是，只是模板肯定是不行的，模板在编译时就确定了一个容器存储的类型，但是我们在执行代码时可以看到：

std::any A = 1;
std::any B = std::string("ABC");	

A = B;

在运行时，这里 A 的存储的类型可是从 int -> string，这可不是模板能够做到的。这里还使用到了多态。

抽象基类

std::any 的核心是一个抽象基类 holder，它定义了存储对象的接口，例如复制和销毁等。所有实际存储对象的类都会继承自这个基类，并实现其接口：

class holder {
public:
    virtual ~holder() = default;  // 析构函数，确保正确释放内存
    virtual holder* clone() const = 0;  // 用于复制
    virtual void* data() = 0;  // 用于访问存储的值
    virtual const std::type_info& type() = 0; // 存储的值的类型
};

关于多态我们觉得使用水果的例子总是很贴切：我们的抽象基类就像是水果一样，他并没有实体，只是一个概念。但是我们的香蕉，苹果，橘子等就是实打实的水果继承了水果的特性…

模板派生类

派生类不能是特定的类型，而是使用了模板，代表可以接受任意类型：

template <typename T>
class placeholder : public holder {
public:
    placeholder(const T& value) 
        : _value(value)
    {}

    placeholder* clone() override 
    {
        return new placeholder(_value);
    }

    void* data() override 
    {
        return &_value;
    }
    
    const std::type_info& type()
    {
        return typeid(_value);
    }

private:
    T _value;
};

在这里：

_value: 存储了实际的数据。
clone(): 返回一个新的 placeholder 对象，以支持复制。
data(): 返回存储对象的地址，供 any 获取实际的数据。

现在前置任务已经达成了，就差实现 any 了。

any 类实现

首先该类的成员变量应该是什么呢？我们需要使用 placeholder 接受需要存储的数据，那么成员变量就是 placeholder 咯。肯定不行涩，如果这样，那么我们的类型就固定了，没有达到类型擦除的效果。所以我们需要使用到 holder：

private:
    std::unique_ptr<holder> _holder; // 使用智能指针便于内存管理

构造和析构

之后就需要考虑构造函数和析构函数了：

 Any() = default; // 无参的

 template <class T> // 这里需要模板函数接受任意类型
 Any(const T& val)
     : _val(std::make_unique<placeholder<T>>(val)) // 别忘了传递类型，placeholder 是一个模板类
 {}

 ~Any() = default;  // 智能指针管理内存，方便了很多

拷贝构造

现在基本的框架已经搭好了，准备拓展功能了，先实现拷贝构造和运算符重载吧，在这里我们就直接使用到了 clone 函数，再次构造一个对象然后交给智能指针管理：

Any(const Any& other)
    : _holder(other._holder->clone())
{}

赋值运算符重载

赋值运算符重载直接使用只拷贝传递一个参数，然后将参数的成员变量的值和我们的交换：

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

这样的操作好处有两个：

我们原来存储的值交给局部变量后，局部变量销毁，自动释放我们原来的值
std::swap 会高效地交换两个 _holder，避免了不必要的对象复制

返回保存的值

现在我们最后需要完成返回我们 any 存储的值，这里就要用上我们实现的返回类型了：

template <class T >
    T& any_cast() 
    {
    	// 判断返回的类型是否合法
        if (typeid(T) == _holder->type())
        {
            return *static_cast<T*>(_holder->data()); // static_cast 更为安全的类型转换
        }
        else
        {
            throw std::bad_cast();
        }
    }