Abstract Factory(抽象工厂模式)

1. 意图

        旨在提供对象创建管理接口，对一系列相关或相互依赖的对象提供统一创建接口，避免在软件中使用各类创建其对象。

2. 适用性

        《Gof 设计模式-可复用面向对象软件的基础》中对此模式的适用性描述如下：

• 一个系统要独立于它的产品的创建、组合和表示时。
• 一个系统要由多个系列产品中的一个来配置时。
• 要强调一系列相关的产品对象的设计以便进行联合使用时。
• 提供一个产品类库，而只想显示他们的接口而不是实现时。

3. 实现

• 简单工厂模式：实现相对简单，类成员函数可以根据不同的参数创建不同的对象，被创建的类对象一般都拥有相同的基类。

class Computer {
public:
  virtual ~Computer (){}
  virtual void Print() = 0;
};

class Memory : public Computer {
  virtual void Print() override { std::cout << "Memory" << std::endl; }
};
class Cpu : public Computer {
  virtual void Print() override { std::cout << "Cpu" << std::endl; }
};
class Screen : public Computer {
  virtual void Print() override { std::cout << "Screen" << std::endl; }
};

class SimpleFactory {
public:
  enum class EnumCreateType { kMemory, kCpu, kScreen };
  Computer *Create(const EnumCreateType &type) {
    switch (type) {
    case EnumCreateType::kMemory:
      return new Memory;
      break;
    case EnumCreateType::kCpu:
      return new Cpu;
      break;
    case EnumCreateType::kScreen:
      return new Screen;
      break;
    default:;
    }
    return nullptr;
  }
};

void Test() {
  SimpleFactory factor;
  Computer *ptr = factor.Create(SimpleFactory::EnumCreateType::kMemory);
  if (ptr) {
    ptr->Print();
    delete ptr;
  }
  ptr = factor.Create(SimpleFactory::EnumCreateType::kCpu);
  if (ptr) {
    ptr->Print();
    delete ptr;
  }
  ptr = factor.Create(SimpleFactory::EnumCreateType::kScreen);
  if (ptr) {
    ptr->Print();
    delete ptr;
  }
}

int main() {
  Test();
  return 0;
}

执行输出

简单工厂模式模板实现

class Computer {
public:
  virtual ~Computer (){}
  virtual void Print() = 0;
};

class Memory : public Computer {
public:
  Memory(int id) : Computer(), m_id(id) {}
  virtual void Print() override { std::cout << "Memory " << m_id << std::endl; }

private:
  int m_id;
};
class Cpu : public Computer {
public:
  Cpu(int id) : Computer(), m_id(id) {}
  virtual void Print() override { std::cout << "Cpu " << m_id << std::endl; }

private:
  int m_id;
};
class Screen : public Computer {
public:
  Screen(int id) : Computer(), m_id(id) {}
  virtual void Print() override { std::cout << "Screen " << m_id << std::endl; }

private:
  int m_id;
};

class SimpleFactory {
public:
  enum class EnumCreateType { kMemory, kCpu, kScreen };

  template <typename... Args>
  Computer *Create(const EnumCreateType &type, Args &&...args) {
    switch (type) {
    case EnumCreateType::kMemory:
      return new Memory(std::forward<Args>(args)...);
      break;
    case EnumCreateType::kCpu:
      return new Cpu(std::forward<Args>(args)...);
      break;
    case EnumCreateType::kScreen:
      return new Screen(std::forward<Args>(args)...);
      break;
    default:;
    }
    return nullptr;
  }
};

void Test() {
  SimpleFactory factor;
  Computer *ptr = factor.Create(SimpleFactory::EnumCreateType::kMemory, 10);
  if (ptr) {
    ptr->Print();
    delete ptr;
  }
  ptr = factor.Create(SimpleFactory::EnumCreateType::kCpu, 20);
  if (ptr) {
    ptr->Print();
    delete ptr;
  }
  ptr = factor.Create(SimpleFactory::EnumCreateType::kScreen, 30);
  if (ptr) {
    ptr->Print();
    delete ptr;
  }
}

int main() {
  Test();
  return 0;
}

执行输出

• 工厂方法模式：使用多个工厂类来创建多种类对象。

class Computer {
public:
  virtual ~Computer() {}
  virtual void Print() = 0;
};

class Memory : public Computer {
  virtual void Print() override { std::cout << "Memory" << std::endl; }
};
class Cpu : public Computer {
  virtual void Print() override { std::cout << "Cpu" << std::endl; }
};
class Screen : public Computer {
  virtual void Print() override { std::cout << "Screen" << std::endl; }
};

class FactoryMethod {
public:
  virtual ~FactoryMethod() {}
  virtual Computer *Create() = 0;
};

class MemoryFactory : public FactoryMethod {
public:
  virtual Computer *Create() override { return new Memory; }
};

class CpuFactory : public FactoryMethod {
public:
  virtual Computer *Create() override { return new Cpu; }
};

class ScreenFactory : public FactoryMethod {
public:
  virtual Computer *Create() override { return new Screen; }
};

void Test() {
  try {
    FactoryMethod *factor = new MemoryFactory;
    Computer *ptr = factor->Create();
    if (ptr) {
      ptr->Print();
      delete ptr;
      delete factor;
    }

    factor = new CpuFactory;
    ptr = factor->Create();
    if (ptr) {
      ptr->Print();
      delete ptr;
      delete factor;
    }

    factor = new ScreenFactory;
    ptr = factor->Create();
    if (ptr) {
      ptr->Print();
      delete ptr;
      delete factor;
    }

  } catch (const std::bad_alloc &err) {
    std::cout << err.what() << std::endl;
  }
}

int main() {
  Test();
  return 0;
}

执行输出

• 抽象工厂模式：一个工厂子类不止能创建一种具有相同规则的对象，相对于工厂模式就可以有效的减少创建工厂子类的数量。

#include <iostream>

class Memory {
public:
  virtual ~Memory() {}
  virtual void Print() = 0;
};
class CMemory : public Memory {
public:
  virtual void Print() override { std::cout << "CMemory" << std::endl; }
};
class RMemory : public Memory {
public:
  virtual void Print() override { std::cout << "RMemory" << std::endl; }
};
class FMemory : public Memory {
public:
  virtual void Print() override { std::cout << "FMemory" << std::endl; }
};

class Cpu {
public:
  virtual ~Cpu() {}
  virtual void Print() = 0;
};
class CCpu : public Cpu {
public:
  virtual void Print() override { std::cout << "CCpu" << std::endl; }
};
class RCpu : public Cpu {
public:
  virtual void Print() override { std::cout << "RCpu" << std::endl; }
};
class FCpu : public Cpu {
public:
  virtual void Print() override { std::cout << "FCpu" << std::endl; }
};

class Screen {
public:
  virtual ~Screen() {}
  virtual void Print() = 0;
};
class CScreen : public Screen {
public:
  virtual void Print() override { std::cout << "CScreen" << std::endl; }
};
class RScreen : public Screen {
public:
  virtual void Print() override { std::cout << "RScreen" << std::endl; }
};
class FScreen : public Screen {
public:
  virtual void Print() override { std::cout << "FScreen" << std::endl; }
};

class AbstractFactory {
public:
  virtual ~AbstractFactory() {}

  virtual Memory *CreateMemory() = 0;
  virtual Cpu *CreateCpu() = 0;
  virtual Screen *CreateScreen() = 0;
};

class CFactory : public AbstractFactory {
public:
  virtual Memory *CreateMemory() override { return new CMemory; }
  virtual Cpu *CreateCpu() override { return new CCpu; }
  virtual Screen *CreateScreen() override { return new CScreen; }
};

class RFactory : public AbstractFactory {
public:
  virtual Memory *CreateMemory() override { return new RMemory; }
  virtual Cpu *CreateCpu() override { return new RCpu; }
  virtual Screen *CreateScreen() override { return new RScreen; }
};

class FFactory : public AbstractFactory {
public:
  virtual Memory *CreateMemory() override { return new FMemory; }
  virtual Cpu *CreateCpu() override { return new FCpu; }
  virtual Screen *CreateScreen() override { return new FScreen; }
};

class Computer {
public:
  void Assemble(Memory *memory, Cpu *cpu, Screen *screen) {
    memory->Print();
    cpu->Print();
    screen->Print();
  }
};

void Test() {
  AbstractFactory *factor1 = new CFactory;
  Memory *m1 = factor1->CreateMemory();
  Cpu *c1 = factor1->CreateCpu();
  Screen *s1 = factor1->CreateScreen();

  AbstractFactory *factor2 = new RFactory;
  Memory *m2 = factor2->CreateMemory();
  Cpu *c2 = factor2->CreateCpu();
  Screen *s2 = factor2->CreateScreen();

  AbstractFactory *factor3 = new FFactory;
  Memory *m3 = factor3->CreateMemory();
  Cpu *c3 = factor3->CreateCpu();
  Screen *s3 = factor3->CreateScreen();

  Computer computer;
  computer.Assemble(m1, c2, s3);
  computer.Assemble(m2, c3, s2);
  computer.Assemble(m3, c1, s1);

  delete factor1;
  delete factor2;
  delete factor3;
  delete m1;
  delete m2;
  delete m3;
  delete c1;
  delete c2;
  delete c3;
  delete s1;
  delete s2;
  delete s3;
}

int main() {
  Test();
  return 0;
}

执行输出

4. 优缺点

• 它分离了具体的类
• 有利于产品的一致性
• 难以支持新种类的产品