读《C++沉思录》心得：拷贝构造函数

读《C++沉思录》心得：拷贝构造函数

　　在读《C++沉思录》中第53页的下面这段代码时，突然看不懂了：

int num=0;
VehicleSurrogate parking_lot[3];
Automobile x;
parking_lot[num++]=x;
//最后一天语句等价于下句
//parking_lot[num++]=VehicleSurrogate(x);

　　书上是这么解释上面这段的：

• 　　“这个语句创建了一个关于对象x的副本，并将VehicleProxy对象绑定到该副本，然后将这个对象赋值给parking_lot的一个元素。当最后销毁parking_lot数组时，所有这些副本也被清除。”

　　对于书上的这段解释，我可以理解它是解释代码中的第6行，但是完全不能理解它可以解释第4行。对于第4行，我的理解是：它调用了拷贝构造函数。之后我就在网上搜索了一下拷贝构造函数的使用，于是得出如下三处使用拷贝构造函数的地方：

1. 一个对象以值传递的方式传入函数体 
2. 一个对象以值传递的方式从函数返回
3. 一个对象需要通过另外一个对象进行初始化

　　而拷贝构造函数三处所使用的地方，都不能说是此时代码第4句的这种情形。就算是那也只能说第4句它肯定调用了拷贝构造函数，并且它使用的是拷贝构造函数使用情况的第三种情况。但是那个“=”是怎么回事呢，带着这种疑惑我决定亲自写代码测试一下，看能不能发现什么。

　　以下为我将《C++沉思录》中的这段代码的例子简易写下来为了测试的代码：

 //class Vehicle
 //Vehicle.h 
 1 #include<iostream>
using namespace std;
class Vehicle
{
public:    
    virtual Vehicle* copy() const=0;
    virtual ~Vehicle()
    {
        cout<<"this is class Vehicle::~Vehicle()"<<endl;

    }
};

 //class Automobile
 //Automobile.h
 1 #include<vehicle.h>
#include<iostream>
using namespace std;
class Automobile : public Vehicle
{
public:
    Automobile();
    Vehicle* copy() const;
    ~Automobile();
};

 //class Automobile
 //Automobile.cpp
 1 #include "automobile.h"

Automobile::Automobile()
{
    cout<<"this is class Automobile::Automobile()"<<endl;
}

Vehicle *Automobile::copy() const
{
    cout<<"this is class Automobile::copy() const"<<endl;
    return new Automobile(*this);
}

Automobile::~Automobile()
{
    cout<<"this is class Automobile::~Automobile()"<<endl;
}

 //class VehicleSurrogate
 //VehicleSurrogate.h
 1 #include"vehicle.h"
#include<iostream>
using namespace std;
class VehicleSurrogate
{
public:
    VehicleSurrogate();
    VehicleSurrogate(const Vehicle& v);
    VehicleSurrogate(const VehicleSurrogate&v);
    VehicleSurrogate&operator=(const VehicleSurrogate&v);
    ~VehicleSurrogate();
private:
    Vehicle *vp;
};

 //class VehicleSurrogate
 //VehicleSurrogate.cpp
 1 #include "vehiclesurrogate.h"

VehicleSurrogate::VehicleSurrogate():vp(0)
{
    cout<<"this is class VehicleSurrogate::VehicleSurrogate()"<<endl;
}

VehicleSurrogate::VehicleSurrogate(const Vehicle &v)//:vp(v.copy)
{
    vp=v.copy();
    cout<<"this is class VehicleSurrogate::VehicleSurrogate(const Vehicle &v)"<<endl;
}

VehicleSurrogate::VehicleSurrogate(const VehicleSurrogate & v):vp(v.vp?v.vp->copy():0)
{
    cout<<"this is class VehicleSurrogate::VehicleSurrogate(const VehicleSurrogate & v)"<<endl;
}

VehicleSurrogate &VehicleSurrogate::operator =(const VehicleSurrogate &v)
{
    cout<<"this is class VehicleSurrogate::operator =(const VehicleSurrogate &v)"<<endl;
    if(this!=&v)
    {
        delete vp;
        vp=(v.vp?v.vp->copy():0);
    }
    return *this;
}

VehicleSurrogate::~VehicleSurrogate()
{
    cout<<"this is class VehicleSurrogate::~VehicleSurrogate()"<<endl;
    delete vp;
}

 //main.cpp
 1 #include <iostream>
#include"vehiclesurrogate.h"
#include"vehicle.h"
#include"automobile.h"
using namespace std;

int main()
{
    int num=0;
    VehicleSurrogate parking_lot[3];
    Automobile x;
    parking_lot[num++]=x;
    //parking_lot[num++]=VehicleSurrogate(x);

    return 0;
}

　　通过对上面代码的运行，得出运行结果如下图1：

图 1

　　由运行结果的第5,6,7,8行可以看出，在调用“parking_lot[num++]=x”时，函数依次执行了：

1. VehicleSurrogate的拷贝构造函数VehicleSurrogate(const Vehicle &v);
2. Automobile的拷贝函数copy()const;
3. VehicleSurrogate的“=”赋值操作符operator=(const VehicleSurrogate&v);
4. Automobile的拷贝函数copy()const;

　　而将上面这句“parking_lot[num++]=x”换为“parking_lot[num++]=VehicleSurrogate(x)”时，执行的效果是一样的，见下图2：

 图 2

　　至此，我们可以得出：parking_lot[num++]=x这句代码，依次执行了VehicleSurrogate的拷贝构造函数和赋值操作符。