c++如何实现类型擦除(Type Erasure)_c++ std::any与std::function原理解析

#include <memory>
#include <typeinfo>
#include <stdexcept>

class any {
private:
    struct base_holder {
        virtual ~base_holder() = default;
        virtual const std::type_info& type() const = 0;
        virtual std::unique_ptr<base_holder> clone() const = 0;
    };

    template<typename T>
    struct holder : base_holder {
        T value;
        holder(const T& v) : value(v) {}
        holder(T&& v) : value(std::move(v)) {}

        const std::type_info& type() const override {
            return typeid(T);
        }

        std::unique_ptr<base_holder> clone() const override {
            return std::make_unique<holder>(value);
        }
    };

    std::unique_ptr<base_holder> content;

public:
    any() = default;

    template<typename T>
    any(const T& value) : content(std::make_unique<holder<T>>(value)) {}

    any(const any& other) 
        : content(other.content ? other.content->clone() : nullptr) {}

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

    any(any&&) = default;
    any& operator=(any&&) = default;

    bool has_value() const { return content != nullptr; }

    const std::type_info& type() const {
        return content ? content->type() : typeid(void);
    }

    template<typename T>
    T& get() {
        if (!content || content->type() != typeid(T)) {
            throw std::bad_cast();
        }
        return static_cast<holder<T>&>(*content).value;
    }

    template<typename T>
    const T& get() const {
        if (!content || content->type() != typeid(T)) {
            throw std::bad_cast();
        }
        return static_cast<const holder<T>&>(*content).value;
    }
};

#include <memory>
#include <utility>

template<typename Signature>
class function;

template<typename Ret, typename... Args>
class function<Ret(Args...)> {
private:
    struct callable_base {
        virtual ~callable_base() = default;
        virtual Ret call(Args... args) = 0;
        virtual std::unique_ptr<callable_base> clone() const = 0;
    };

    template<typename F>
    struct callable_wrapper : callable_base {
        F func;
        callable_wrapper(F f) : func(std::move(f)) {}
        
        Ret call(Args... args) override {
            return func(std::forward<Args>(args)...);
        }

        std::unique_ptr<callable_base> clone() const override {
            return std::make_unique<callable_wrapper>(func);
        }
    };

    std::unique_ptr<callable_base> impl;

public:
    function() = default;

    function(const function& other)
        : impl(other.impl ? other.impl->clone() : nullptr) {}

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

    function(function&&) = default;
    function& operator=(function&&) = default;

    template<typename F>
    function(F f) : impl(std::make_unique<callable_wrapper<F>>(std::move(f))) {}

    explicit operator bool() const { return impl != nullptr; }

    Ret operator()(Args... args) {
        if (!impl) throw std::bad_function_call();
        return impl->call(std::forward<Args>(args)...);
    }
};