深入了解C++中基于模板的类型擦除

#include <iostream>
#include <memory>

// 抽象基类TaskBase作为公共接口不变；其子类TaskModel写成类模板的形式，其把一个任意类型F的函数对象function_作为数据成员。
struct TaskBase
{
    virtual ~TaskBase() {}
    virtual void operator()() const = 0;
};

template <typename F>
struct TaskModel : public TaskBase
{
    F functor_;

    template <typename U> // 构造函数是函数模板
    TaskModel(U &&f) : functor_(std::forward<U>(f))
    {
    }

    void operator()() const override
    {
        functor_();
    }
};

// 对TaskModel的封装
class MyTask
{
    std::unique_ptr<TaskBase> ptr_;

public:
    template <typename F>
    MyTask(F &&f)
    {
        using ModelType = TaskModel<F>;
        ptr_ = std::make_unique<ModelType>(std::forward<F>(f));
    }

    void operator()() const
    {
        ptr_->operator()();
    }
};

/////////////测试代码/////////////////

// 普通函数
void func1()
{
    std::cout << "type erasure 1" << std::endl;
}

// 重载括号运算符的类
struct func2
{
    void operator()() const
    {
        std::cout << "type erasure 2" << std::endl;
    }
};
int main()
{
    // 普通函数
    MyTask t1{&func1};
    t1(); // 输出"type erasure 1"

    // 重载括号运算符的类
    MyTask t2{func2{}};
    t2(); // 输出"type erasure 2"

    // Lambda
    MyTask t3{
        []()
        { std::cout << "type erasure 3" << std::endl; }};
    t3(); // 输出"type erasure 3"

    return 0;
}

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

// 图形的概念接口
struct ShapeConcept
{
    virtual void Draw() const = 0;
};

// 图形概念的具体实现
template <typename T>
struct ShapeModel : ShapeConcept
{
    ShapeModel(T &&val) : shape_{std::forward<T>(val)} {}
    void Draw() const override
    {
        shape_.Draw(); // 这里假设具体图形有Draw()成员函数。如果没有，需要特化该模板。
    }

private:
    // 这里直接存储具体图形的值
    T shape_;
};

// 父类
class Shape
{
public:
    template <typename T>
    Shape(T &&val) : pimpl_{new ShapeModel<T>(std::forward<T>(val))} {}
    inline void Draw() const
    {
        pimpl_->Draw();
    }

private:
    std::unique_ptr<ShapeConcept> pimpl_;
};

//---------------------正方形-------------------------
class Square
{
public:
    explicit Square(float side) : side_(side) {}
    // 正方形的绘图函数是一个成员函数
    void Draw() const
    {
        std::cout << "Draw square of side: " << side_ << std::endl;
    }

private:
    float side_;
};

//---------------------圆-----------------------------
class Circle
{
public:
    explicit Circle(float radius) : radius_(radius) {}
    float GetRadius() const { return radius_; }

private:
    float radius_;
};
// 圆的绘图是一个全局函数
void DrawCircle(const Circle &circle)
{
    std::cout << "Draw circle of radius: " << circle.GetRadius() << std::endl;
}
// 因为圆的绘图函数是一个全局函数，所以需要特化
template <>
struct ShapeModel<Circle> : ShapeConcept
{
    ShapeModel(Circle &&val) : shape_(std::move(val)) {}
    void Draw() const override
    {
        DrawCircle(shape_);
    }

private:
    Circle shape_;
};

int main()
{
    std::vector<Shape> shapes;
    shapes.push_back(Circle(1.0));
    shapes.push_back(Square(2.0));
    for (const auto &shape : shapes)
    {
        shape.Draw();
    }
    return 0;
}