C++第六节:拷贝构造函数

拷贝构造函数

拷贝构造函数:通过拷贝一个已有对象来创建一个新的对象

1、声明一个对象，并用另一个已经存在的对象初始化：

     1.1把已经存在的对象作为新声明对象的构造函数的参数

     1.2声明一个对象，并用赋值表达式，用一个已有对象来初始化它

     1.3用new运算符，在堆上创建对象，并用一个已有对象对其进行初始化时

2、传值的方式，从函数返回一个对象：

     2.1向函数传参时，传值调用时，形参是实参的拷贝

     2.2从函数传值返回对象时，创建一个临时对象，接受返回值，会调用拷贝构造函数

三大件：拷贝构造函数、析构函数、赋值运算符的重载

Vector.h

#ifndef __C__No731Class__Vector__
#define __C__No731Class__Vector__

#include <iostream>
using namespace std;
class Vector
{
public:
    int * rep;
    int size;
    
    Vector (int s = 0);
    Vector (int *r, int s);
    Vector (const Vector & v);  //拷贝构造函数
    ~Vector();
    const Vector & operator = (const Vector & v);  //重载赋值运算符
    void print();
};
#endif /* defined(__C__No731Class__Vector__) */

Vector.cpp

#include "Vector.h"
Vector::Vector (int s) : size(s)
{
    if (size <= 0)
        rep = NULL;
    else
    {
        rep = new int[size];
        for (int count = 0; count < size; ++count)
            rep[count] = 0;
    }
    cout << "默认构造函数" << endl;
}
Vector::Vector (int *r, int s)
{
    size = s;
    rep = new int[s];
    for (int count = 0; count < size; ++count)
        rep[count] = r[count];
    cout << "非默认构造函数" << endl;
}
Vector::Vector (const Vector &v)
{
    size = v.size;
    rep = new int[size];
    for (int count = 0; count < size; ++count)
        rep[count] = v.rep[count];
    cout << "重载构造函数" << endl;
}
Vector::~Vector()
{
    if(rep)
    {
        delete [] rep;
        rep = NULL;
    }
    cout << "析构Vector" << endl;
}
const Vector & Vector::operator = (const Vector & v)
{
    if (this != &v)
    {
        delete [] rep;
        rep = new int[v.size];
        for (int i = 0; i < v.size; ++i)
            rep[i] = v.rep[i];
        size = v.size;
    }
    cout << "重载=" << endl;
    return *this;
}
void Vector::print()
{
    cout << "size = " << size << endl;
    for (int i = 0; i < size; ++i)
        cout << rep[i] << " ";
    cout << endl;
}

main.cpp

#include <iostream>
#include "Vector.h"
int main(int argc, const char * argv[])
{
    Vector v1;
    v1.print();
    
    int array[5] = {1, 2, 3, 4, 5};
    Vector v2 (array, 5);
    v2.print();
    
    Vector v3(v2);
    v3.print();
    Vector v5 = v2;
    v5.print();
    
    Vector v4;
    v4 = v3;
    v4.print();
    
    return 0;
}

运行结果：

默认构造函数

size = 0

非默认构造函数

size = 5

1 2 3 4 5 

重载构造函数

size = 5

1 2 3 4 5 

重载构造函数

size = 5

1 2 3 4 5 

默认构造函数

重载=

size = 5

1 2 3 4 5 

析构Vector

析构Vector

析构Vector

析构Vector

析构Vector

临时对象的系统开销很大，传值（包括参数、返回值）分别需要形参和返回值的临时对象调用拷贝构造函数和析构函数，传引用就显得效率，传参不需拷贝构造函数，返回时也不需要临时变量和析构。

B、测试何时调用拷贝构造函数

Demo.h

#ifndef __C__No731Class__Demo__
#define __C__No731Class__Demo__

#include <iostream>
using namespace std;
class Demo
{
private:
    int i;
public:
    Demo (int n = 0);
    Demo (const Demo & a);
    ~Demo();
    const Demo & operator = (const Demo & a);
};
#endif /* defined(__C__No731Class__Demo__) */

Demo.cpp

#include "Demo.h"
Demo::Demo (int n)
{
    i = n;
    cout << "默认构造函数" << endl;
}
Demo::Demo (const Demo & a)
{
    i = a.i;
    cout << "拷贝构造函数" << endl;
}
Demo::~Demo()
{
    cout << "析构Demo" << endl;
}
const Demo & Demo::operator = (const Demo & a)
{
    i = a.i;
    cout << "重载=" << endl;
    return * this;
}

main.cpp

#include "Demo.h"
Demo foo(Demo x)   //a传给x，拷贝构造函数
{
    Demo d;        //默认构造函数
    return d;      //开辟一个临时的形参空间Nu接收d，d传给Nu,拷贝构造函数（优化省略）
}
int main()
{
    Demo a (2);    //默认构造函数
    {
        Demo b;    //默认构造函数
        b = foo(a);//重载=，析构d，析构x
    }//析构b
    Demo c = a;    //拷贝构造函数
    return  0;     //析构c，析构a
}

运行结果：

默认构造函数

默认构造函数

拷贝构造函数

默认构造函数

重载=

析构Demo

析构Demo

析构Demo

拷贝构造函数

析构Demo

析构Demo