讨论构造拷贝构造函数的N种调用情况

讨论构造拷贝构造函数的N种调用情况

拷贝构造函数

• 该函数可以用一个对象去构造另一个对象，或者说，用另一个对象值初始化一个新构造的对象
• 对象作为函数参数传递时，也要涉及对象的拷贝。

    void fn(Student fs)
    {
    //...
    }
    int main()
    {
        Student ms;
        fn(ms);
    }

• 函数fn()的参数传递方式是传值，参数类型是Student，调用时，实参ms传给了形参fs。
• ms在传递的过程中是不会改变的，形参fs是ms的一个拷贝。

临时对象

• 当函数返回一个对象时，要创建一个临时对象以存放返回的对象。
• 在下面的代码中，返回的ms对象将产生一个临时对象

Student fn()
{
    //...
    Student ms("Evey")；
    return ms;
}

int main()
{
    Student s;
    s = fn();
    //...
}

• 系统调用拷贝构造函数将ms拷贝到新创建的临时对象中
  
  

  
  
  

• 一般规定，创建的临时对象，在整个创建它们的外部表达式范围内有效，否则无效。

  • 也就是说，”s = fn();”这个外部表达式，当fn()返回时产生的临时对象拷贝给s后，临时对象就被析构了。

下面的例子中，引用refs则不再有效：

int main()
{
    Student& refs = fn();
    //...
}

• 因为外部表达式”Student& refs = fn()”到分号处结束，以后从fn()返回的临时对象便不再有效，这就意味着，引用refs的实体已不存在，所以接下去的任何对refs的引用都是错的。

无名对象（匿名对象）

• 可以直接调用构造函数产生无名对象
• 在下面的代码中，函数fn()里，创建了一个无名对象

class Student
{
public:
    Student(char*);
    //...
    void fn()
    {   
        Student("Evey");//此处为无名对象
        //...
    }
}

• 无名对象可以作为实参传递给函数，可以拿来拷贝构造一个新对象，也可以初始化一个引用的声明。
• 下面列举无名对象典型的三种用法：

void fn(Student& s);

int main()
{
    Student& refs = Student("Evey");//初始化引用
    Student s = Student("JS");//初始化对象定义
    fn(Student("Remai"));//函数参数
}

• 第一个执行的是拿无名对象初始化一个引用。
  
  • 在函数内部，无名对象作为局部对象产生在栈空间中。
  • 从作用域上看，该引用与无名对象是相同的。
  • 其完全等价于，”Student refs = “Evey”“。
  • 所以该做法，略显多余。
• 第二个执行的是用无名对象拷贝构造一个对象s。
  
  • 按理说，C++先调用构造函数”Student(char* );”创建一个无名对象，然后再调用一个拷贝构造函数”Student(Student&);”创建对象s。
  • 但由于用无名对象去拷贝构造一个对象，所以拷贝完成之后，无名对象就失去了任何作用。
  • 对于这种情况，C++特别地将其看作为”Student s= “JS”“。
  • 效果相同，且可以省略创建无名对象这一步。
• 第三个执行的是无名对象作为实参传递给形参s。
  
  • C++先调用构造函数创建一个无名对象，然后将该无名对象初始化给了引用形参s对象。
  • 由于实参是在主函数中，所以无名对象实在主函数的栈区中创建。
  • 函数fn()的形参s引用的是主函数栈空间中的一个对象。

小结

• 在从C++中，传参和传返回值时，如果是引用类型，则不用调用拷贝构造函数，直接返回别名。
• 当语句为一个表达式时，编译器会选择优化，将构造函数与拷贝构造合并。
• 在C++中，调用几次构造函数和拷贝构造函数，就会相应的调用几次析构函数。
  只有当一个对象已经存在时，d=f（）才调用赋值运算符重载，如果对象不存在，调用的则是构造函数。

练习

嘻嘻，我们接下来看一下一道简单的关于拷贝构造函数的题目吧

题目：
Test1中调用了___次AA的拷贝构造函数,___次AA的赋值运算符函数的重载。 
Test2中调用了___次AA的拷贝构造函数,___次AA的赋值运算符函数的重载。 
Test3中调用了___次AA的拷贝构造函数,___次AA的赋值运算符函数的重载。 

class AA 
    {}; 
AA f (AA a) 
{ 
    return a ; 
} 
void Test1 () 
{ 
    AA a1 ; 
    a1 = f(a1); 
} 
void Test2 () 
{ 
    AA a1 ; 
    AA a2 = f(a1); 
} 

void Test3 () 
{ 
    AA a1 ; 
    AA a2 = f(f(a1)); 
} 

当当当当~~公布答案啦！你做对了么？

Test1中调用了2次AA的拷贝构造函数,1次AA的赋值运算符函数的重载。
Test2中调用了2次AA的拷贝构造函数,0次AA的赋值运算符函数的重载。
Test3中调用了3次AA的拷贝构造函数,0次AA的赋值运算符函数的重载。

接下来我们来分析一下答案是如何得出的吧~
* 代码测试

#include<iostream>
using namespace std;

class AA
{
public:
    AA()
    {
        cout << "构造函数" << endl;
    }

    AA(const AA& a)
    {
        cout << "拷贝构造函数" << endl;
    }

    ~AA()
    {
        cout << "析构函数" << endl;
    }

    AA& operator=(AA& a)
    {
        cout << "重载运算符" << endl;
        return a;
    }
};
AA f(AA a)
{
    return a;
}

• Test 1 的代码测试

    void Test1()
    {
        AA a1;//构造
        a1 = f(a1);//拷贝构造*2 & 运算符重载
    }

运行结果如下：

• Test 2的代码测试

 void Test2()
{
    AA a1;//构造
    AA a2 = f(a1);//拷贝构造*2
}

运行结果如下：

• Test 3 的代码测试

void Test3()
{
    AA a1;//构造
    AA a2 = f(f(a1));//拷贝构造*3
}

运行结果如下：

题目到这里就结束啦~

天公作美，许我半途而吠
所以，天真人类

很喜欢的话，送给大家2333
学编程的也可以有文艺情怀好嘛~