#include <iostream>
#include <memory>

// 抽象基類TaskBase作為公共接口不變；其子類TaskModel寫成類模板的形式，其把一個任意類型F的函數(shù)對象function_作為數(shù)據(jù)成員。
struct TaskBase
{
    virtual ~TaskBase() {}
    virtual void operator()() const = 0;
};

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

    template <typename U> // 構(gòu)造函數(shù)是函數(shù)模板
    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()();
    }
};

/////////////測試代碼/////////////////

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

// 重載括號運算符的類
struct func2
{
    void operator()() const
    {
        std::cout << "type erasure 2" << std::endl;
    }
};
int main()
{
    // 普通函數(shù)
    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;
};

// 圖形概念的具體實現(xiàn)
template <typename T>
struct ShapeModel : ShapeConcept
{
    ShapeModel(T &&val) : shape_{std::forward<T>(val)} {}
    void Draw() const override
    {
        shape_.Draw(); // 這里假設具體圖形有Draw()成員函數(shù)。如果沒有，需要特化該模板。
    }

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) {}
    // 正方形的繪圖函數(shù)是一個成員函數(shù)
    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_;
};
// 圓的繪圖是一個全局函數(shù)
void DrawCircle(const Circle &circle)
{
    std::cout << "Draw circle of radius: " << circle.GetRadius() << std::endl;
}
// 因為圓的繪圖函數(shù)是一個全局函數(shù)，所以需要特化
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;
}