3.2拷贝构造函数调用时机

第一种：用对象1 初始化 对象2

第二种：用对象1 初始化 对象2--括号法

注意：初始化操作 和 等号操作 是两个不同的概念

第三种：形参是一个元素，函数调用，会执行实参t7变量初始化形参obj变量

第四种：匿名对象的去和留

关键点：如果接匿名对象

结论1：函数的返回值是一个元素对象（复杂类型的），

返回的是一个新的匿名对象，所以会调用此对象类的copy构造函数

结论2：有关匿名对象的去和留

 如果用匿名对象 初始化 另外一个同类型的对象 匿名对象 转成有名对象

如果用匿名对象 赋值（=）给 另外一个同类型的对象 匿名对象 被析构

1、如果用匿名对象 初始化 另外一个同类型的对象 匿名对象 转成有名对象

2、如果用匿名对象 赋值（=）给 另外一个同类型的对象 匿名对象 被析构

#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <windows.h>

using namespace std;

class Test1{
public:
    //无参构造函数
    Test1()
    {
        this->a = 0;
        this->b = 0;
        cout<<"无参构造函数"<<endl;
    }

    Test1(int a,int b)
    {
        this->a = a;
        this->b = b;
        cout<<"有参构造函数"<<endl;
    }
    Test1(int a)
    {
        this->a = a;
        this->b = 0;
        cout<<"一个参数的有参构造函数"<<endl;
    }

    //copy构造函数
    Test1(const Test1& obj)
    {
        cout<<"COPY构造函数"<<endl;
        this->a = obj.a +100;
        this->b = obj.b +100;
    }
    
    ~Test1()
    {
         cout<<"我是析构函数，被执行了"<<endl;
    }
public:
    void print(){
        cout<<this->a<<endl;
        cout<<this->b<<endl;
        cout<<"普通成员函数"<<endl;
    }
    int getA(){return a;}
    int getB(){return b;}
private:
    int a;
    int b;
};

//业务函数:形参是一个元素
void f(Test1 p)
{
        cout<<"******************************"<<endl;
        cout<<p.getA()<<endl;
        cout<<p.getB()<<endl;
        cout<<"******************************"<<endl;
}

//g函数 返回一个元素

Test1 g()
{
    Test1 A(1,3);//这里调用A的有参构造函数
    // 返回的是一个新的匿名对象，所以会调用明对象类的copy构造函数
    return A;//？？？？？不知道为什么没有调用自己的copy构造函数，调用的默认的
}
// 结论2：有关匿名对象的去和留
// 如果用匿名对象 初始化 另外一个同类型的对象 匿名对象 转成有名对象
// 如果用匿名对象 赋值（=）给 另外一个同类型的对象 匿名对象 被析构
void playObj4()
{
   //把匿名对象=给m
   //用匿名对象初始化m,此时c++编译器直接把匿名对象转成m (相当于转正)，从匿名转成有名字了
   Test1 m2(5,6) ;
   m2= g();
   cout<<"因为匿名对象=号给m2 所以匿名对象会被析构"<<endl;
   cout<<m2.getA()<<endl;;
}
//结论1：函数的返回值是一个元素对象（复杂类型的），
//----- 返回的是一个新的匿名对象，所以会调用明对象类的copy构造函数
// 匿名对象的去和留
void playObj3()
{
   //直接把匿名对象初始化给m
   //用匿名对象初始化m,此时c++编译器直接把匿名对象转成m (相当于转正)，从匿名转成有名字了
   Test1 m = g();
   cout<<"匿名对象不会被析构了"<<endl;
    cout<<m.getA()<<endl;;
}




void playObj()
{
    Test1 T7(3,5);
    f(T7);//T7实参去初始化形参p,会调用copy构造函数
}

int main()
{
    //括号法
    Test1 t1(1,2);
    t1.print();
    //第一种调用时机：用t1初始化t2,调用拷贝构造函数
    Test1 t5 = t1;

    //第二种调用时机：用t1初始化t2,调用拷贝构造函数
    //定义变量并初始化 //括号法
    Test1 t6(t1);
    t5.print();
    t6.print();

    playObj();
    playObj3();
    playObj4();


    //等号法,这里的等号，C++进行了功能性增强
    Test1 t2 = (3,4);//出错是因为逗号表达式，相当于t2 = 4;所以这里要有一个，一个参数的构造函数
    Test1 t3 = 5;

    Test1 t4 = Test1(1,2);
    //用t1来=号给t2 编译器给我们提供的浅copy
    t1 = t4; //把t4 copy 给 t1; 赋值操作

    cout<<"hello...."<<endl;
    system("pause");
    return 0;
}