构造函数constructor 与析构函数destructor（四）

拷贝构造函数：拷贝构造函数就是在用一个类对象来创建另外一个类对象时被调用的构造函数，如果我们没有显示的提供拷贝构造函数，编译器会隐式的提供一个默认拷贝构造函数。

拷贝构造函数的定义是X(const X& ){}

1 class Test{
2    int m_i;
3 public:
4     Test(int i):m_i(i){}
5      Test(const Test& vt):m_i(vt.m_i){}//拷贝构造函数
      int getI()const {return m_i;}

6 
7 };

int main(){

   Test t(12);
    Test t2(t);//调用拷贝构造函数来初始化t2对象
    Test t3=t;//等价于t3(t)，也是调用拷贝构造函数
    return 0；
}

记住拷贝构造函数的只有一个参数，并且这个参数是类类型的const引用，参数不能是普通的值传递，必须是引用。原因有二

一：如果参数是const Test vt，那么实参在传递给形参的时候，还是会给形参创建对象，分配内存。这时把实参传递给形参，仍然是是用类对象初始化类对象，还是会调用拷贝构造函数，就会形成递归调用。

二：如果传递引用，实际上是传递的一个地址，不会创建新的对象，而拷贝时也只是拷贝的一个地址大小的空间，会增加程序的效率。

当函数的形参是类的对象，调用函数时，进行形参与实参结合时使用。这时要在内存新建立一个局部对象，并把实参拷贝到新的对象中。理所当然也调用拷贝构造函数。

void fun(Test vt){

    cout<<vt.,getI()<<endl;

}

这个函数的参数是类的对象，会调用拷贝构造函数的

int main(){

    Test t(12);
    Test t2 = t;//调用一次拷贝构造函数
    Test t3(t);//调用一次拷贝构造函数
    fun(t);//调用拷贝构造函数
    return 0;
}

fun的参数变成对象的引用时，就不会再调用拷贝构造函数了。

返回值为Const 引用 以及类对象的区别

当函数的返回值是类对象，函数执行完成,返回到调用者时也会调用拷贝构造函数。理由也是要建立一个临时对象中，从函数返回的对象来初始化产生的临时对象。

//test.h
#ifndef TEST_H
#define TEST_H
class Test
{
    int m_i;
public:
    Test(int i=0);
    Test(const Test& vt);
    ~Test();
    int getI()const;
};
#endif //TEST_H


//test.cpp
#include "Test.h"
#include<iostream>
using std::cout;
using std::endl;

Test::Test(int i) :m_i(i)
{
    cout << "default constructor" << endl;
}

Test::Test(const Test& vt):m_i(vt.m_i){
    cout << "copy constructor" << endl;
}

Test::~Test()
{
}

int Test::getI()const{
    return m_i;
}

//demo.cpp

#include<iostream>
#include"Test.h"
using std::endl;
using std::cout;
void fun1(Test& vt){

    cout << "m_i=" << vt.getI() << endl;
}
void fun2(Test vt){
    cout << "m_i=" << vt.getI() << endl;
}

Test fun3(const Test& vt){
    return vt;
}
int main(){

    Test t;
    fun3(t);//因为fun3函数的参数是类的引用，因此不用产生临时对象。但是返回值类型为类对象会产生临时对象，
           // 所以要调用一个拷贝构造函数，把从函数返回的值，拷贝到生成的临时对象中
    return 0;
}

我们还可以在析构函数中添加代码，来测试临时对象时什么时候释放的。

在析构函数~Test（）中添加打印代码，main函数如下所示：

int main(){

    Test t;
    fun3(t);//因为fun3函数的参数是类的引用，因此不用产生临时对象。但是返回值类型为类对象会产生临时对象，
           // 所以要调用一个拷贝构造函数，把从函数返回的值，拷贝到生成的临时对象中
    cout << "........." << endl;
    return 0;
}

我们可以看到，临时对象产生后，如果没有别的对象接受，马上就销毁。如果有别的对象接受，再复制完成后销毁。但是如果mia函数中添加一句如下的代码

int main(){

    Test t;
    Test t2=fun3(t);//因为fun3函数的参数是类的引用，因此不用产生临时对象。但是返回值类型为类对象会产生临时对象，
           // 所以要调用一个拷贝构造函数，把从函数返回的值，拷贝到生成的临时对象中
    cout << "........." << endl;
    return 0;
}

此时临时对象被Test t2接受，就没有马上释放，而是当t2的生命周期完时释放。

现在增加一个函数fun4，它的返回值类型和传递的参数类型都是类的引用

const Test& fun4(const Test& vt){
     return vt;
}

然后把main的代码修改成如下的;

int main(){

    Test t;//创建t对象，调用默认构造函数
    const Test& t1=fun4(t);//传参，和返回值都没有产生临时对象。
    cout << "........." << endl;
    return 0;
}

运行结果

我们可以看到，当返回值为类的引用时，并不会产生临时对象。这是一个非常好的改变程序效率的方法。

所以从上面的一系列代码中，我们可以看到，传参和返回值类型会影响程序的效率，因为传参类型是值类型的话，会产生临时对象，临时对象的产生，释放，拷贝，都会产生消耗，从而导致程序效率降低。