Factory Methon 模式

Factory Methon  本质在于，基类提供一个虚函数“挂钩”，用于产生适当的“产品”。
每个派生类可以重写继承的虚函数，为自己产生适当的产品。实际上我们具备了一个未知对象来产生另一个未知对象的能力。《c++必知必会》

http://home.earthlink.net/~huston2/dp/FactoryMethodDemosCpp

#include  < iostream >
using   namespace  std;

/**/ /* Abstract base class declared by framework */
class  Document  ... {
public:
    Document( char* fn ) ...{ strcpy( name, fn ); }
    virtual void Open()  = 0;
    virtual void Close() = 0;
    char* GetName()      ...{ return name; }
private:
    char  name[20];
} ;

/**/ /* Concrete derived class defined by client */
class  MyDocument :  public  Document  ... {
public:
    MyDocument( char* fn ) : Document(fn) ...{ }
    void Open()   ...{ cout << "   MyDocument: Open()" << endl; }
    void Close()  ...{ cout << "   MyDocument: Close()" << endl; }
} ;


/**/ /* Framework declaration */
class  Application  ... {
public:
    Application() : _index(0) ...{ cout << "Application: ctor" << endl; }
    /**//* The client will call this "entry point" of the framework */
    void NewDocument( char* name )  ...{
        cout << "Application: NewDocument()" << endl;
        /**//* Framework calls the "hole" reserved for client customization */
        _docs[_index] = CreateDocument( name );
        _docs[_index++]->Open(); }
    void OpenDocument()  ...{ }
    void ReportDocs();
    /**//* Framework declares a "hole" for the client to customize */
    virtual Document* CreateDocument( char* ) = 0;
private:
    int        _index;
    /**//* Framework uses Document's base class */
    Document*  _docs[10];
} ;

void  Application::ReportDocs()  ... {
    cout << "Application: ReportDocs()" << endl;
    for (int i=0; i < _index; i++)
        cout << "   " << _docs[i]->GetName() << endl; }


/**/ /* Customization of framework defined by client */
class  MyApplication :  public  Application  ... {
public:
    MyApplication() ...{ cout << "MyApplication: ctor" << endl; }
    /**//* Client defines Framework's "hole" */
    Document* CreateDocument( char* fn ) ...{
        cout << "   MyApplication: CreateDocument()" << endl;
        return new MyDocument( fn ); }
} ;

int  main()  ... {
    /**//* Client's customization of the Framework */
    MyApplication  myApp;

    myApp.NewDocument( "foo" );
    myApp.NewDocument( "bar" );
    myApp.ReportDocs();
    return 0;
}

下面是创建对象，同上面的创建对象还是有差别的。

//  A factory method is a static method of a class that
//  returns an object of that class' type. But unlike a
//  constructor, the actual object it returns might be
//  an instance of a subclass. Another advantage of a
//  factory method is that it can return existing
//  instances multiple times. [Mark Davis]

#include < iostream >
#include < vector >
using  std::vector;
using  std::cout;
using  std::endl;
using  std::cin;

class  Stooge  ... {
public:
   // Factory Method
   static Stooge* make_stooge( int choice );
   virtual void slap_stick() = 0;
} ;
class  Larry :  public  Stooge  ... {
public:
   void slap_stick() ...{
      cout << "Larry: poke eyes "; }
} ;
class  Moe :  public  Stooge  ... {
public:
   void slap_stick() ...{
      cout << "Moe: slap head "; }
} ;
class  Curly :  public  Stooge  ... {
public:
   void slap_stick() ...{
      cout << "Curly: suffer abuse "; }
} ;

Stooge *  Stooge::make_stooge(  int  choice )  ... {
   if (choice == 1)
      return new Larry;
   else if (choice == 2)
      return new Moe;
   else
      return new Curly;
}
int  main(  void  )  ... {
   vector<Stooge*> roles;
   int    choice;
   while (true) ...{
      cout << "Larry(1) Moe(2) Curly(3) Go(0): ";
      cin >> choice;
      if (choice == 0)
         break;
      roles.push_back( Stooge::make_stooge( choice ) );
   }
   for (int i=0; i < roles.size(); i++)
      roles[i]->slap_stick();
   for (int i=0; i < roles.size(); i++)
      delete roles[i];
   return 0;
}