More Effective C++ （虚拟构造函数）

在了解代码之前，请先仔细阅读这些概念：

<1>虚构造函数：

一种允许你做一些 C++不直接支持的事情的用法。

你可能通过虚函数 virtual clone()（对于默认拷贝构造函数）或虚函数 virtual create()（对于默认构造函数），得到虚构造函数产生的效果。

<2>虚拟拷贝构造函数：

一种特殊的虚拟构造函数――虚拟拷贝构造函数――也有着广泛的用途。

虚拟拷贝构造函数能返回一个指针，指向调用该函数的对象的新拷贝。

因为这种行为特性，虚拟拷贝构造函数的名字一般都是copySelf，cloneSelf或者是像下面这样就叫做clone。


<3>协变返回类型：

注意:下述代码的实现利用了被采纳的较宽松的虚拟函数返回值类型规则。

被派生类重定义的虚拟函数不用必须与基类的虚拟函数具有一样的返回类型。

如果函数的返回类型是一个指向基类的指针（或一个引用），那么派生类的函数可以返回一个派生类的指针（或引用）。

这不是C++的类型检查上的漏洞，它使得有可能声明像虚拟构造函数这样的函数。

这就是为什么Circle 的clone函数能够返回Circle * 和 Square 的clone也能够返回Square *的原因，即使Shape 的clone返回值类型却为Shape *。

备注：根据坊间记录，以前的编译器是不支持这个东东的。

<4>虚拟构造函数

因为它能建立新对象，它的行为与构造函数相似，而且因为它能建立不同类型的对象，我们称它为虚拟构造函数。

虚拟构造函数是指能够根据输入给它的数据的不同而建立不同类型的对象。

虚拟构造函数在很多场合下都有用处，从磁盘（或者通过网络连接，或者从磁带机上）读取对象信息只是其中的一个应用。

示例代码1如下：

#include<iostream>
using  namespace std;
class Shape 
{
public:
    virtual ~Shape() { }                  // 虚析构函数
     
//  使用默认拷贝构造函数 ,more effective c++中成为虚拟拷贝构造函数  。涉及"协变返回类型"
    virtual Shape* clone()  const = 0;  
//  使用默认构造函数
    virtual Shape* create() const = 0;     
};

class Circle : public Shape 
{                
public:
    Circle()
    {
        cout<<"Construction   Circle  "<<this<<endl;
    }
public:
    //在 clone() 成员函数中，代码 new Circle(*this) 调用 Circle 的默认拷贝构造函数来复制this的状态到新创建的Circle对象
    Circle* clone()  const 
    { 
        return new Circle(*this);
    }   
    //在 create()成员函数中，代码 new Circle() 调用Circle的默认构造函数。
    Circle* create() const 
    { 
        return new Circle();
    }   
    //析构函数
    ~Circle()
    {
        cout<<"Destroy  Circle  "<<this<<endl;
    }

};

class Square : public Shape 
{
public:    
    Square()
    {
        cout<<"Construction   Square  "<<this<<endl;
    }
public:
    //在clone()成员函数中，代码 new Square(*this) 调用Square的默认拷贝构造函数来复制this的状态到新创建的Square对象
    Square* clone()  const 
    { 
        return new Square(*this);
    }
    //在 create()成员函数中，代码 new Square() 调用Square的默认构造函数。
    Square* create() const 
    { 
        return new Square();
    }
    //析构函数
    ~Square()
    {
        cout<<"Destroy  Square  "<<this<<endl;
    }

};
//虚构造函数
void userCode(Shape &s)
{
    Shape* s2 = s.create();     
    Shape* s3 = s.clone();   

    delete s2;    // 在此处，需要虚析构函数
    delete s3;
}

int main() 
{
    Circle c;
    userCode(c);
    
    Square s;
    userCode(s);
}

/*
 *运行结果与分析：
Construction   Circle  003EF8D8  调用Circle构造函数创建对象c
Construction   Circle  00234B98  userCode函数中s.create()函数调用Circle构造函数创建新对象
Destroy  Circle  00234B98  析构新构造对象
Destroy  Circle  00234BD8  析构克隆对象
Construction   Square  003EF8CC  调用Square构造函数创建对象s
Construction   Square  00234B98  userCode函数中s.create()函数调用Square构造函数创建新对象
Destroy  Square  00234B98  析构新构造对象
Destroy  Square  00234BD8  析构克隆对象
Destroy  Square  003EF8CC  析构对象s
Destroy  Circle  003EF8D8  析构对象c
*/

 示例代码2如下：

#include<iostream>
using  namespace std;

class Object
{
public:
    Object()
    {}
    virtual ~Object()
    {}
    virtual void print() const = 0;
public:
    virtual Object* CloneSelf()  const = 0; 
    virtual Object* CopySelf() const = 0;
};

class Int:public Object
{
private:
    int value;
public:
    Int(int x = 0):value(x)
    {}
    ~Int()
    {}
    void print() const
    {
        cout<<value<<endl;
    }
public:
    Int* CloneSelf() const 
    { 
        return new Int();
    }
    Int* CopySelf() const  
    {
        return new Int(*this);
    }
};
class Char:public Object
{
private:
    char value;
public:
    Char(char x='h'):value(x)
    {}
    ~Char()
    {}
    void print() const
    {
        cout<<value<<endl;
    }
public:
    Char* CloneSelf() const 
    { 
        return new Char();
    }
    Char* CopySelf() const  
    {
        return new Char(*this);
    }
};
class Double:public Object
{
private:
    double value;
public:
    Double(double x=12.34):value(x)
    {}
    ~Double()
    {}
    void print() const
    {
        cout<<value<<endl;
    }
public:
    Double* CloneSelf() const 
    { 
        return new Double();
    }
    Double* CopySelf() const  
    {
        return new  Double(*this);
    }
};

class SeqList
{
    Object *data[10];
    int MaxSize;
    int len;
public:
    //虚拟构造函数
    Object * CloneObj(Object &ob)
    {
        return ob.CloneSelf();
    }
    //虚拟拷贝构造
    Object * CopyObj(Object &ob)
    {
        return ob.CopySelf();
    }
public:
    SeqList()
    {
        MaxSize = 10;
        for(int i = 0; i < MaxSize; ++i)
        {
            data[i]=NULL;
        }
        len = 0; 
    }

    ~SeqList()
    {}
    void pushClone(Object &ob)
    {
        data[len++] = CloneObj(ob);
    }
    void pushCopy(Object &ob)
    {
        data[len++] = CopyObj(ob);
    }
    void print() const
    {
        for(int i = 0; i < len; ++i)
        {
            data[i]->print();
        }
        cout<<endl;
    }
};
void main()
{
    SeqList mylist;
    Int intObj;
    Char charObj;
    Double douObj;
    mylist.pushClone(intObj);
    mylist.pushClone(charObj);
    mylist.pushClone(douObj);
    mylist.pushCopy(intObj);
    mylist.pushCopy(charObj);
    mylist.pushCopy(douObj);
    mylist.print();
}
/*
0
h
12.34
0
h
12.34
 */

Good Good Study, Day Day Up.

顺序  选择  循环  坚持