伪工厂抽象类

Question

所以我有这样的要求：

• 客户端不应该知道实际的类是如何实现或构造的。
• 类实现了一个公共接口。

因此，我使用Factory类来满足1，使用抽象类来实现第二点。

因此，我想出了类似的东西(简化了我的课堂设计)：

#include <iostream>
#include <cstddef>

enum variety{
    oolong,
    green,
};

class T
{
    public:
        virtual void drink() = 0;
        virtual ~T() {};
};

class T1: public T
{
    T1() = delete;
    public:
        T1(int a):
          sugar(a)
          {
              std::cout<<"T1 ctor\n";
          }
        void drink()
        {
            std::cout<<"Sipping oolong with sugar: "<<sugar<<'\n';
        }
        ~T1()
        {
            std::cout<<"T1 dtor\n";
        }
    private:
        int sugar;
};

class T2: public T
{
    T2() = delete;
    public:
        T2(int a):
          sugar(a)
          {
              std::cout<<"T2 ctor\n";
          }
        void drink()
        {
            std::cout<<"Sipping green with sugar: "<<sugar<<'\n';
        }
        ~T2()
        {
            std::cout<<"T2 dtor\n";
        }
    private:
        int sugar;
};

class TFactory
{
    TFactory() = delete;
    public:
        static T* brew(variety v, int sugar){
            if(v == oolong)
                return new T1(sugar);
            else if (v== green)
                return new T2(sugar);
            else
                return nullptr;
        }
};

int main(){
    T* t1 = TFactory::brew(oolong, 5);
    t1->drink();
    delete t1;
}

这是设计我的需求的最佳方法吗？或者，是否有其他现有的设计模式已经涵盖了我的需求？如果是这样的话，我的代码中有哪些缺陷使它成为一个糟糕的设计？

Answer 1

我想您的应用程序的核心是使用抽象类T和TFactory。

在这种情况下，您希望将非易失性核心与T的子类型的频繁更改分离开来，但是您将直接依赖于违反依赖反转原则/开放封闭原则的TFactory。结果是，每次添加或更改T的子类型时，使用Factory的代码都会受到更改的影响，至少需要重新编译。

为了解决这个问题，您可以将您的TFactory放在一个额外的接口(抽象工厂)后面，以使代码解耦。