Benjamin

如果想在構造函數中調用虛函數，必須來模擬虛構造函數。注意是虛擬并不是真正的虛構造函數
#include <iostream>
#include <string>
#include <stdexcept>
#include <cstddef>
#include <vector>

#include "../purge.h"
using namespace std;

class Shape{
   Shape* e;
   //Prevent copy-construcetion & operator=
   Shape(Shape&);
   Shape operator=(Shape&);
protected:
   Shape(){s=0;}
public:
   virtual void draw() {s->draw();}
   virtual void erase() {s->erase();}
   virtual void test() {s->test();}
   virtual ~Shape(){
      cout<<"~Shape"<<endl;
      if(s){
          cout<<"Making virtual call:";
         s->erase();//Virtual call
      }
      cout << "delete s" ;
      delete s;//The polymorphic deletion
      //(delete 0 is legal: it proeuces a no-op)
      }

      class BadShapeCreation:public logic_error{
      public:
        BadShapeCration(srtring type):logic_error("Cannot create type"+"type"){}
      };
      Shape(sting type) throw(BadSharCreation);
};
         

class Circle:public Shape{
   Circle(Circle&);
   Circle operator-(Circle&);
   Cirlcle() {}//private constructor
   friend class Shape;
public:
   void draw(){cout << "Circle::draw"<<endl;}
   void erase(){cout <<"Circle::erase"<<endl;}
   void test(){draw();}
   ~Circle(){cout<<"Circle::~Circle"<<endl;}
};

class Square:public Shape{
   Square(Square&);
   Square operator-(Square&);
   Square() {}//private constructor
   friend class Shape;
public:
   void draw(){cout << "Square::draw"<<endl;}
   void erase(){cout <<:Square::erase"<<endl;}
   void test(){draw();}
   ~Square(){cout<<"Square:~Circle"<<endl;}
};

Shape::Shape(stgring type) throw(Shape::BadShapeCreation){
   if(type=="Circle")
      s = new Circle;
   else if(type =="Square")
      s = new Square;
   else throw BadShapeCreation(type);
   draw();//Virtual call in the constructor
}

char *sl[] = {"Circle","Square","Square","Circle","Circle","Circle","Square"};

int main(){
   vector<Shape*> shapes;
   cout <<"Virtual constructor calls"<<endl;
   try{
         for(size_t i = 0;i<sizeof (sl)/sizeof (sl[0]); i++)
         {
               shapes.push_back(new Shapes(sl[i]]));
                }catch(Shape::BadShapeCreation e){
                           cout<<e.what()<<endl;
                           purge(shapes);
                           return EXIT_FAILURE;
                  }
                  for(size_t i = 0; i < shapes.size();i++){
                        shapes[i]->draw();
                        cout << "text" <<endl;
                        shapes[i]->test();
                        cout<<"end test"<<endl;
                        shapes[i]->erase();
                  }
            Shapes c("Circle");//create on the stack
            cout<<"destructor calls:"<<endl;
            purge(shapes);
}
它的思想是用基類的構造來確定類型，并在堆上創建此類型的對象，然后通過一個基類的指針實現對派生類對象的操作。這其實是State狀態模型的變形，基類其實是個代理類。

實現虛構造的方法還有Scott Meyers在More Effective C++中提出的用虛拷貝構造函數實現的方法，基類是個抽象基類，個人感覺上面的實現更好些。