c++中拷贝构造函数&赋值操作符的理解

20180206修订：将具体例子改为Ch09_Point类（作为指针变量使用），Ch09_CopyConstructor类（作为父类，包含Ch09_Point指针变量），Ch09_DeprivedClass类（作为子类）。通过这三个类的相互关系，介绍c++的拷贝构造函数和赋值操作符的使用。

拷贝构造函数（copy constructor）又称为复制构造函数，此函数经常用在函数调用时用户自定义类型的值传递及返回。如果没有定义拷贝构造函数，编译器会自动为我们创建一个，拷贝构造函数会逐个执行成员的初始化（按照类成员在类中声明的顺序）。对于基本类型数据默认拷贝构造函数可以正常创建一个副本并由被赋值对象持有；对于类类型数据直接调用数据的拷贝构造函数创建新的副本并由被赋值对象持有（有可能两个对象共同持有一个数据）；对于指针类数据，默认拷贝函数会让两个对象共同持有一个数据，导致修改A对象，B对象的值跟着变化，在程序中造成异常。

拷贝构造函数调用条件：

1）一个对象最为函数参数，以“值传递”的方式传入函数体。

2）一个对象作为函数返回值，以“值传递”的方式从函数返回。

3）一个对象对另一个对象进行初始化。

拷贝构造函数及赋值操作符（C++建议类的赋值操作符作为类方法出现，同样建议的还有“.”, "[]", "()"）格式：

Ch09_Point.h:

class Ch09_Point
{
public:
    explicit Ch09_Point();
    explicit Ch09_Point(int x, int y);

    /**
     *@author        qioawei
     *@date          2018-02-05
     *@version       1.0
     *@brief         拷贝构造函数
     *@called by
     *@param         p
     **/
    Ch09_Point(const Ch09_Point& p);

    void print() const;

    void SetPoint(int x, int y);

    int GetX() const;

    int GetY() const;

    /**
     *@author        qioawei
     *@date          2018-02-05
     *@version       1.0
     *@brief         = 赋值操作符
     *@called by
     *@param         rvalue 赋值变量
     *@return        赋值后
     **/
    Ch09_Point& operator = (const Ch09_Point& rvale);

    friend Ch09_Point operator + (const Ch09_Point& a, const Ch09_Point& b);

private:
    int x_;
    int y_;
};






Ch09_Point.cpp:

#include "ch09_point.h"

Ch09_Point::Ch09_Point() :
    x_(0),
    y_(0)
{

}

Ch09_Point::Ch09_Point(int x, int y) :
    x_(x),
    y_(y)
{

}

Ch09_Point::Ch09_Point(const Ch09_Point &p)
{
    x_ = p.x_;
    y_ = p.y_;
}

void Ch09_Point::print() const
{
    qDebug() << "x = " << x_ << ", y = " << y_ << endl;
}

void Ch09_Point::SetPoint(int x, int y)
{
    x_ = x;
    y_ = y;
}

int Ch09_Point::GetX() const
{
    return x_;
}

int Ch09_Point::GetY() const
{
    return y_;
}

Ch09_Point& Ch09_Point::operator = (const Ch09_Point &rvale)
{
    if (this != &rvale) {
        x_ = rvale.x_;
        y_ = rvale.y_;
    }

    return *this;
}

Ch09_Point operator + (const Ch09_Point &a, const Ch09_Point &b)
{
    return Ch09_Point(a.x_ + b.x_, a.y_ + b.y_);
}

使用情况：

Ch09_Point a1; //调用无参构造函数
Ch09_Point a2(a1); //调用拷贝构造函数
Ch09_Point a3 = a1; //调用拷贝构造函数
Ch09_Point a4;
a4 = a2 //赋值操作符

//特殊情况
Ch09_Point* a5(new A());
Ch09_Point  a6(*a5) //调用拷贝构造函数
Ch09_Point* p3 = new Ch09_Point(10, 20);   //构造函数
a6 = *p3; //赋值操作符
Ch09_Point p4(*p3);   //拷贝构造函数

“=”在对象声明语句中表示初始化，调用拷贝构造函数；在非声明语句中表示赋值，调用赋值构造函数。

 Ch09_CopyConstructor类作为容器类，保存Ch09_Point类型指针，具体如下：

ch09_copyconstructor.h

class Ch09_Point;

class Ch09_CopyConstructor
{
public:
    explicit Ch09_CopyConstructor();
    explicit Ch09_CopyConstructor(int x, int y);

    /**
     *@author        qioawei
     *@date          2018-02-05
     *@version       1.0
     *@brief         拷贝构造函数
     *@called by
     *@param         cc
     **/
    Ch09_CopyConstructor(const Ch09_CopyConstructor& cc);

    ~Ch09_CopyConstructor();

    Ch09_CopyConstructor& operator = (const Ch09_CopyConstructor& rvalue);

    void Print() const;

private:
    Ch09_Point* p_;
};

ch09_copyconstructor.cpp

#include "ch09_copyconstructor.h"

#include "ch09_point.h"

Ch09_CopyConstructor::Ch09_CopyConstructor() :
    p_(new Ch09_Point(0, 0))
{

}

Ch09_CopyConstructor::Ch09_CopyConstructor(int x, int y) :
    p_(new Ch09_Point(x, y))
{
}

Ch09_CopyConstructor::Ch09_CopyConstructor(const Ch09_CopyConstructor &cc)
{
    if (this != &cc) {
        delete p_;

        //调用Ch09_Point的拷贝构造函数
        p_ = new Ch09_Point(*(cc.p_));
    }
}

Ch09_CopyConstructor::~Ch09_CopyConstructor()
{
    delete p_;

    //qDebug() << "from base class" << endl;
}

Ch09_CopyConstructor& Ch09_CopyConstructor::operator =(const Ch09_CopyConstructor& rvalue)
{
    if (this != &rvalue) {
        delete p_;
        //调用Ch09_Point拷贝构造函数?
        p_ = new Ch09_Point(*(rvalue.p_));
    }

    return *this;
}

void Ch09_CopyConstructor::Print() const
{
    p_->print();
}

因为p_变量在构造函数中进行初始化，在进行拷贝构造或者赋值操作时需要先判断，如与所赋对象不一致，则需要先delete p_的实例，随后创建新实例保存所赋对象中数据。

Ch09_DeprivedClass类作为Ch09_CopyConstructor的子类，同时在Ch09_DeprivedClass类中保存一个Ch09_Point类作为变量保存。

Ch09_DeprivedClass.h

class Ch09_Point;

class Ch09_DeprivedClass : public Ch09_CopyConstructor
{
public:
    explicit Ch09_DeprivedClass();
    explicit Ch09_DeprivedClass(int x, int y);

    Ch09_DeprivedClass(const Ch09_DeprivedClass& dc);

    virtual ~Ch09_DeprivedClass();

    Ch09_DeprivedClass& operator =(const Ch09_DeprivedClass& dc);

    void PrintDeprivedClass();

public:
    Ch09_Point* deprived_p_;
};

Ch09_DeprivedClass.cpp

#include "ch09_deprivedclass.h"

#include "ch09_point.h"

Ch09_DeprivedClass::Ch09_DeprivedClass() :
    Ch09_CopyConstructor(),
    deprived_p_(new Ch09_Point(0, 0))
{
    qDebug() << deprived_p_ << endl;
}

Ch09_DeprivedClass::Ch09_DeprivedClass(int x, int y) :
   Ch09_CopyConstructor(x, y),
   deprived_p_(new Ch09_Point(x + 11, y + 22))
{
    qDebug() << deprived_p_ << endl;
}

Ch09_DeprivedClass::Ch09_DeprivedClass(const Ch09_DeprivedClass &dc) :
    Ch09_CopyConstructor(dc)        //调用基类拷贝构造函数
{
    if (this != &dc) {
        delete deprived_p_;

        deprived_p_ = new Ch09_Point(*(dc.deprived_p_));
        //deprived_p_ = new Ch09_Point(dc.deprived_p_->GetX(), dc.deprived_p_->GetY());
    }
}

Ch09_DeprivedClass::~Ch09_DeprivedClass()
{
    delete deprived_p_;

    //qDebug() << "from deprived class" << endl;
}

Ch09_DeprivedClass &Ch09_DeprivedClass::operator =(const Ch09_DeprivedClass &dc)
{
    if (this != &dc) {
        delete this;

        //调用基类赋值操作符，完成基类private变量的赋值
        Ch09_CopyConstructor::operator =(dc);
        deprived_p_ = new Ch09_Point(*(dc.deprived_p_));
    }

    return *this;
}

void Ch09_DeprivedClass::PrintDeprivedClass()
{
    Print();

    qDebug() << " deprived x = " << deprived_p_->GetX()
             << ", deprived y = " << deprived_p_->GetY() << endl;
}

在拷贝构造函数中需要调用基类的拷贝构造函数；在赋值操作符中调用基类赋值操作符，给基类中保存的private变量赋值。