隔离变化

       软件设计的主要目标就是适应变化，在需求中去识别变化，从而进行抽象隔离变化，并且符合SOLID准则，良好的设计可以让程序员少加些班，好保住“猿类”们那珍惜的毛发。

      有过面向对象开发经验的同学自然能想到继承，通过抽象基类实现多态，来隔离不同派生类型进行差异处理：

用户依赖于抽象基类，与具体的实现类型解耦：

struct User {
    User(std::unique_ptr<Shape> shape) : m_shape (std::move(shape)) {}
    void Process()
    {
        m_shape->Draw();
    }
 private:
    std::unique_ptr<Shape> m_shape;
};  

int main()
{   
    User user(std::make_unique<Circle>());
    user->Process();
}

       User需要持有基类的指针并且需要负责其生命周期的管理；同时可以发现一个问题，当User需要进行拷贝时无法对Shape进行深拷贝，因为不知道其具体派生类型。

      而在C语言中，void*指针此时便承担了隔离依赖的作用，对此有过经验的同学都应该或多或少体会过被void *支配的恐惧，强转类型而导致内存越界、内存被异常改写等问题，曾经我们也为它付出过大好青春。

类型擦除

TypeErasure 提供了一种设计方法来优化上述的问题：

struct Shape {
    struct ShapeConcept {
        virtual ~ShapeConcept() {}
        virtual void Draw() const = 0;

        // The Prototype Design Pattern
        virtual std::unique_ptr<ShapeConcept> Clone() const = 0;
    };

    template <typename T>
    struct ShapeModel : ShapeConcept {

        ShapeModel(const T& value)
            : m_object{value} {
        }

        void Draw() const override
        {
            m_object.Draw();
        }

        // The Prototype Design Pattern
        std::unique_ptr<ShapeConcept> Clone() const override
        {
            return std::make_unique<ShapeModel>(*this);
        }

    private:
        T m_object;
    };

    // A constructor template to create a bridge. 
    template <typename T> requires requires(T t){ t.Draw(); }
    Shape(const T& x)
      : m_pimpl{std::make_unique<ShapeModel<T>>(x)} { }

    Shape(const Shape& s)
      : m_pimpl{s.m_pimpl->Clone()} { }

    void Draw()
    {
        m_pimpl->Draw();
    }
private:
    // The Bridge Design Pattern
    std::unique_ptr<ShapeConcept> m_pimpl;
};

struct Circle {
    void Draw() const { DBG_LOG(); }
};

struct User {
    User(const Shape &shape) : m_shape (std::move(shape)) {}
    void Process()
    {
        m_shape.Draw();
    }
 private:
    Shape m_shape;
};  

int main()
{
    User user(Circle{});
    user.Process();
}

对应的类图关系为：

其中Shape应用了桥接模式+原型模式，通过构造函数模板建立桥接，Shape擦除了类型之间的差异，用户同样不用依赖于具体类型；用户使用时更加简洁，减少了make_unique等调用，并且不需要对Circle和Square进行侵入式添加继承。

      同时这里还存在问题：创建Shape时需要动态申请内存，频繁的堆内存申请与释放会导致性能恶化及内存碎片化，这里可以应用SOO（小对象优化）进行改进，在下一节std::any的实现中同样使用了此优化手段。

STL源码分析

std::function

std::function可以接受各种类型的调用：函数指针、lambda、可调用对象等【1】，对具体调用对象类型进行了擦除。

template<typename F>
void Command(F f, int arg)
{
    // ...
    f(arg);
}

Command函数本意为通过模板参数F接受不同的可调用对象类型包括lambda等，但当Command函数实现代码量大的情况下将其改造成上述函数模板，对不同类型进行模板实例化时则造成最终的二进制代码膨胀；如果F修改为函数指针则无法接受lambda表达式，存在局限性；

此时使用std::function便可以解决上述问题；参考【2】中的简化实现代码进行说明：

template<typename R,typename... Args>
class FunctorBridge {
public:
    virtual ~FunctorBridge(){}
    virtual FunctorBridge* clone() const=0;
    virtual R invoke(Args... args) const=0;
};

template<typename Functor,typename R,typename... Args>
class SpecificFunctorBridge : public FunctorBridge<R,Args...> {
    Functor functor;
public:
    template<typename FunctorFwd>
    SpecificFunctorBridge(FunctorFwd&& functor):functor(std::forward<FunctorFwd>(functor))
    {}
    virtual SpecificFunctorBridge* clone() const override
    {
        return new SpecificFunctorBridge(functor);
    }
    virtual R invoke(Args... args) const override
    {
        return functor(std::forward<Args>(args)...);
    }
};

template<typename Signature>
class FunctionPtr;

template<typename R,typename... Args>
class FunctionPtr<R(Args...)>
{
private:
    FunctorBridge<R,Args...>* bridge;
public:
    FunctionPtr():bridge(nullptr) {}

    FunctionPtr(FunctionPtr &other)
        :FunctionPtr(static_cast<FunctionPtr const&>(other)) { }

    FunctionPtr(FunctionPtr&& other):bridge(other.bridge)
    {
        other.bridge=nullptr;
    }

    template<typename F>
    FunctionPtr(F&& f) : bridge(nullptr)
    {
        using Functor=std::decay_t<F>;
        using Bridge = SpecificFunctorBridge<Functor,R,Args...>;
        bridge = new Bridge(std::forward<F>(f));
    }

    FunctionPtr& operator=(FunctionPtr const& other)
    {
        FunctionPtr tmp(other);
        swap(*this,tmp);
        return *this;
    }

    FunctionPtr& operator=(FunctionPtr&& other)
    {
        delete bridge;
        bridge=other.bridge;
        other.bridge=nullptr;
        return *this;
    }

    template<typename F>
    FunctionPtr& operator=(F&& f)
    {
        FunctionPtr tmp(std::forward<F>(f));
        swap(*this,tmp);
        return *this;
    }

    ~FunctionPtr()
    {
        delete bridge;
    }

    friend void swap(FunctionPtr& fp1,FunctionPtr& fp2)
    {
        std::swap(fp1.bridge, fp2.bridge);
    }

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

    R operator()(Args... args) const
    {
        return bridge->invoke(std::forward<Args>(args)...);
    }
};

可以看到核心实现与第二节中说明的基本一致，不在赘述。

std::any

std::any为C++17引入的特性，any可以接受任意类型，擦除了具体类型；同时当使用any_cast<T>获取出实际类型时，如果T不是原来的类型，则会抛出异常。

同样我们可以使用上一节中介绍的实现来完成，但标准库中使用了SOO所以实现有所差别：

创建any对象

相关的关键代码已在上图的中标识，应用SOO即根据对象的大小决定是否使用堆内存申请，这样对于小对象可以获得更好的性能，例如在栈上创建一个any对象时，小对象就可以直接使用栈内存；

reset any对象

即调用any的reset方法，即：

struct Circle {
    ~Circle()
    { 
        DBG_LOG();
    }   
    // ...
};

int main()
{
    std::any a = std::make_any<Circle>();
    a.reset();
}

此时小对象则需要调用Circle的析构，大对象除了需要调用Circle的析构还要释放对应的堆内存。

通过函数指针隔离了具体类型的申请与销毁；

any_cast<T>

      在any对象创建代码中，Storage中TypeData存储了对应类型的typeid，此处any_cast会进行类型校验，校验失败则会抛出异常。

参考资料

【1】https://en.cppreference.com/w/cpp/utility/functional/function

【2】C++ Templates 2rd

【3】 Breaking Dependencies: Type Erasure - A Design Analysis