C++ 팩토리 메서드

#include <iostream>
using namespace std;

// LIBRARY/PARENT(Wire_Sizes) CLASS WITH Two_mm and Four_mm sub-classes
class Wire_Sizes {
 public:
  virtual void Diameter() = 0;
};
class Two_mm : public Wire_Sizes {
 public:
  void Diameter() { cout << "This wire is 2mm in diameter" << endl; }
};
class Four_mm : public Wire_Sizes {
 public:
  void Diameter() { cout << "This wire is 4mm in diameter" << endl; }
};

// CLIENT(User) CLASS
// One thing to note here is that object creation takes place inside the User
// class, which can affect the whole program if changes are to be made to the
// parent class - like adding a new category of wire diameter.

// In this client class, adding a new type will mean adding a new category to
// the existing if-else ladder.
class User {
 public:
  User(int type) {
    // Client explicitly creates classes according to type
    if (type == 1)
      pDiameter = new Two_mm();
    else if (type == 2)
      pDiameter = new Four_mm();
    else
      pDiameter = NULL;
  }
  ~User() {
    if (pDiameter) {
      delete[] pDiameter;
      pDiameter = NULL;
    }
  }
  Wire_Sizes *getDiameter() { return pDiameter; }

 private:
  Wire_Sizes *pDiameter;
};

// MAIN FUNCTION
int main() {
  User *pClient = new User(2);
  Wire_Sizes *pDiameter = pClient->getDiameter();
  pDiameter->Diameter();
  return 0;
}

This wire is 4mm in diameter

#include <iostream>
using namespace std;

// The three derived classes, Size_two_mm, Size_three_mm, and Size_four_mm,
// contains the printDiameter() method, which is overloaded in all the
// subclasses
enum Size { Size_two_mm, Size_three_mm, Size_four_mm };
class Wire_Sizes {
 public:
  virtual void printDiameter() = 0;
  static Wire_Sizes* Create(Size type);
};
class Twomm : public Wire_Sizes {
 public:
  void printDiameter() { cout << "This wire is 2mm in diameter" << endl; }
};
class Threemm : public Wire_Sizes {
 public:
  void printDiameter() { cout << "This wire is 3mm in diameter" << endl; }
};
class Fourmm : public Wire_Sizes {
 public:
  void printDiameter() { cout << "This wire is 4mm in diameter" << endl; }
};

Wire_Sizes* Wire_Sizes::Create(Size type) {
  if (type == Size_two_mm)
    return new Twomm();
  else if (type == Size_three_mm)
    return new Threemm();
  else if (type == Size_four_mm)
    return new Fourmm();
  else
    return NULL;
}

class user {
 public:
  user() {
    Size type = Size_three_mm;
    pDiameter = Wire_Sizes::Create(type);
  }
  ~user() {
    if (pDiameter) {
      delete[] pDiameter;
      pDiameter = NULL;
    }
  }
  Wire_Sizes* getDiameter() { return pDiameter; }

 private:
  Wire_Sizes* pDiameter;
};

int main() {
  user* pClient = new user();
  Wire_Sizes* pDiameter = pClient->getDiameter();
  pDiameter->printDiameter();
  return 0;
}

This wire is 3mm in diameter

#include <iostream>
using namespace std;

// BASE CLASS
class Concrete_Example {
 public:
  virtual ~Concrete_Example() {}
  virtual std::string Operation() const = 0;
};
class ExampleProduct1 : public Concrete_Example {
 public:
  std::string Operation() const override {
    return "{Product 1 is instantiated}";
  }
};

class ExampleProduct2 : public Concrete_Example {
 public:
  std::string Operation() const override {
    return "{Product 2 is instantiated}";
  }
};

// CREATOR CLASS
class Create {
 public:
  virtual ~Create(){};
  virtual Concrete_Example* FactoryMethod() const = 0;
  std::string SomeOperation() const {
    Concrete_Example* concrete_Example = this->FactoryMethod();
    std::string result = "Client Code" + concrete_Example->Operation();
    delete concrete_Example;
    return result;
  }
};

class ExampleCreator1 : public Create {
 public:
  Concrete_Example* FactoryMethod() const override {
    return new ExampleProduct1();
  }
};

class ExampleCreator2 : public Create {
 public:
  Concrete_Example* FactoryMethod() const override {
    return new ExampleProduct2();
  }
};

// USER CLASS
void User(const Create& create) {
  std::cout << "User Method is called\n" << create.SomeOperation() << std::endl;
}

// MAIN FUNCTION
int main() {
  std::cout << "App: Launched with the ConcreteCreator1.\n";
  Create* create = new ExampleCreator1();
  User(*create);
  std::cout << std::endl;
  std::cout << "App: Launched with the ConcreteCreator2.\n";
  Create* create2 = new ExampleCreator2();
  User(*create2);

  delete create;
  delete create2;
  return 0;
}

App: Launched with the ConcreteCreator1.
User Method is called
Client Code{Product 1 is instantiated}

App: Launched with the ConcreteCreator2.
User Method is called
Client Code{Product 2 is instantiated}