《C++20设计模式》学习笔记——第10章外观模式-CSDN博客

本文链接：https://blog.csdn.net/qq_41668147/article/details/136211569

Generator（发生器）：生成指定个数的随机数字序列的组件。
Splitter（分离器）：接受矩形矩阵，并输出一组表示矩阵中所有行、列和对角线的列表的组件；
Verifier（验证器）：检查列表中的每个行、列和对角线的元素的和是否相等。

（注意：用这种方法生成幻方当然是不切实际的，只是为了介绍外观模式而举的例子）

Generator通过特定的算法，生成一个包含指定数量随机数的序列，并以向量的形式返回。为保持代码简介，这里使用的是rand()函数。为生成幻方，我们调用N次generate()函数，生成N行数字序列，最后得到一个NxN的方阵。

//发生器
struct Generator
{
    virtual std::vector<int> generate(const int count) const
    {
        std::vector<int> result(count);
        std::generate(result.begin(), result.end(), [&](){return 1 + std::rand()%9;});  //伪随机：每次运行结果相同！！
        return result;
    }
};

组件Splitter接受已生成的二维矩阵，并使用它生成表示矩阵的所有行、列和对角线的唯一元素。
实现代码相当冗长，此处省略。

//分离器
struct Splitter
{
    std::vector<std::vector<int> > split(std::vector<std::vector<int> > array) const
    {
        //implimentation omitted
        return {};
    }
};

最后一个组件Verifier检查上述各行、列、对角线所有元素的和是否像等。

//验证器
struct Verifier
{
    bool verify(std::vector<std::vector<int> > array) const
    {
        if(array.empty()) 
        {
            std::cout << "[verifier]: array is empty!" << std::endl; 
            return false;
        }
        auto expected = std::accumulate(array[0].begin(), array[0].end(), 0);
        return std::all_of(array.begin(), array.end(), [=](auto& inner)
        {
            return std::accumulate(inner.begin(), inner.end(),0) == expected;
        });
    }
};

现在我们有了三个不同的子系统，它们将协同工作，以生成随机幻方。但是如果我们将这些类提供给客户，客户将很难正确使用它们。于是我们可以创建一个外观类，本质上是一个隐藏了内部所有实现细节并对外只提供一个简单接口的包装类。

//幻方外观类
struct MagicSquareGenerator
{
    std::vector<std::vector<int> > generate(int size)
    {
        Generator g;
        Splitter s;
        Verifier v;
        std::vector<std::vector<int> > square;
        int count = 0;
        const uint64_t MAX_COUNTS = 1e6; 
        bool verified = false;
        do {
            square.clear();
            for(int i = 0; i<size; ++i)
            {
                square.emplace_back(g.generate(size));
            } 
            for(auto item : square)
            {
                for(auto value : item)
                {
                    std::cout << value << " ";
                }
                std::cout << std::endl;
            }
            count++;
            auto splited = s.split(square);
            verified = v.verify(splited); 
        }
        while(!verified && count<MAX_COUNTS);

        if(count < MAX_COUNTS) 
        {
            std::cout << "count = " << count << std::endl;
            return square;
        }
        else
        {
            std::cout << "over max counts, no result!!" << std::endl;
            return {{}};
        }
    }
};

为了允许高级用户使用附加功能自定义和扩展外观类的行为，我们将每个子系统作为模板参数传入MagicSquareGenerator:

//允许高级用户提供各个组件
template <typename G = Generator,
    typename S = Splitter,
    typename V = Verifier>
struct MagicSquareGenerator2
{
    std::vector<std::vector<int> > generate(int size)
    {
        G g;
        S s;
        V v;
        //rest of code as before;
    }
};

如果愿意，我们可以进一步添加限制，要求参数G、S和V从相应的类继承。
现在，可以创建一个UniqueGenerator，以确保生成的集合中的所有数字都是唯一的：

struct UniqueGenerator : Generator
{
    std::vector<int> generate(const int count) const override
    {
        std::vector<int> result;
        do
        {
            result = Generator::generate(count);
        } while(std::set<int>(result.begin(), result.end()).size() != result.size());
        return result;
    }
};