临时对象专题

学习临时对象时的相关代码：

例1：

/*
 *第一种情况：分步解析
*/
#include<iostream>
using namespace std;

class B
{
public:
    B()
    {
        cout<<"Default  Construct"<<"  "<<this<<endl;
    }
    B(int i):data(i)
    {
        cout<<"Construct  By: "<<this<<"  "<<data<<endl;
    }
    B(const B &b)
    {
        cout<<"Copy  Construct"<<"  "<<this<<"   "<<&b<<endl;
        data = b.data;
    }
    B &operator=(const B &obj)
    {
        if(this!=&obj)
        {
            cout<<" operator= "<<this<<"  "<<&obj<<endl;
            data=obj.data;
        }
        return *this;
    }
    ~B()
    {
        cout<<"Destructed"<<"   "<<this<<"  "<<data<<endl;
    }
private:
    int data;
};

B Func(B b)
{
    return b;
}

void main()
{
    B t1 = Func(5);
}

//Out  put   
/*
Construct  By: 0x0012FF20  5  //隐式类型转换构建临时对象
Copy  Construct  0x0012FF7C   0x0012FF20  //拷贝构造函数进行传参(b = 临时对象)
Destructed   0x0012FF20  5   //摧毁临时对象
Destructed   0x0012FF7C  5   //摧毁对象t1
*/ 

例2：

/*
 *第二种情况：分步解析
*/
#include<iostream>
using namespace std;

class B
{
public:
    B()
    {
        cout<<"Default  Construct"<<"  "<<this<<endl;
    }
    B(int i):data(i)
    {
        cout<<"Construct  By: "<<this<<"  "<<data<<endl;
    }
    B(const B &b)
    {
        cout<<"Copy  Construct"<<"  "<<this<<"   "<<&b<<endl;
        data = b.data;
    }
    B &operator=(const B &obj)
    {
        if(this!=&obj)
        {
            cout<<" operator= "<<this<<"  "<<&obj<<endl;
            data=obj.data;
        }
        return *this;
    }
    ~B()
    {
        cout<<"Destructed"<<"   "<<this<<"  "<<data<<endl;
    }
private:
    int data;
};

B Func(B b)
{
    return b;
}

void main()
{
    B t1;
    t1 = Func(5);
}

//Out  put 
/*
Default  Construct:  0012FF58   //默认构造创建t1
Construct  By: 0012FE5C  5      //隐式类型转换创建临时对象
Copy  Construct  0012FE8C   0012FE5C  //拷贝构造函数传参(b=临时对象)
Destructed   0012FE5C  5        //摧毁临时对象
operator=   0012FF58   0012FE8C//赋值函数进行赋值（t1=b）
Destructed   0012FE8C  5    //摧毁对象b
Destructed   0012FF58  5    //摧毁对象t1
*/

例3：

/*
 *第三种情况：分步解析
*/
#include<iostream>
using namespace std;

class B
{
public:
    B()
    {
        cout<<"Default  Construct"<<"  "<<this<<endl;
    }
    B(int i):data(i)
    {
        cout<<"Construct  By: "<<this<<"  "<<data<<endl;
    }
    B(const B &b)
    {
        cout<<"Copy  Construct"<<"  "<<this<<"   "<<&b<<endl;
        data = b.data;
    }
    B &operator=(const B &obj)
    {
        if(this!=&obj)
        {
            cout<<" operator= "<<this<<"  "<<&obj<<endl;
            data=obj.data;
        }
        return *this;
    }
    ~B()
    {
        cout<<"Destructed"<<"   "<<this<<"  "<<data<<endl;
    }
private:
    int data;
};

B Func(B b)
{
    return b;
}

void main()
{
    B t1(1);
    t1 = Func(t1);
}

//Out  put
/*
Construct  By: 0012FF58  1   //构造函数创建t1
Copy  Construct  0012FE5C   0012FF58   //拷贝构造创建临时对象
Copy  Construct  0012FE8C   0012FE5C   //拷贝构造函数进行传参(构建对象b)
Destructed   0012FE5C  1     //摧毁临时对象
operator=   0012FF58   0012FE8C  //赋值函数进行赋值(t1=b)
Destructed   0012FE8C  1     //摧毁对象b
Destructed   0012FF58  1     //摧毁对象t1
*/

例4：

/*
 *第四种情况：分步解析
*/
#include<iostream>
using namespace std;

class B
{
public:
    B()
    {
        cout<<"Default  Construct"<<"  "<<this<<endl;
    }
    B(int i):data(i)
    {
        cout<<"Construct  By: "<<this<<"  "<<data<<endl;
    }
    B(const B &b)
    {
        cout<<"Copy  Construct"<<"  "<<this<<"   "<<&b<<endl;
        data = b.data;
    }
    B &operator=(const B &obj)
    {
        if(this!=&obj)
        {
            cout<<" operator= "<<this<<"  "<<&obj<<endl;
            data=obj.data;
        }
        return *this;
    }
    ~B()
    {
        cout<<"Destructed"<<"   "<<this<<"  "<<data<<endl;
    }
private:
    int data;
};

B Func(B b)
{
    return b;
}

void main()
{
    B t1(1);
    B t2 = Func(t1);
}

//Out  put  
/*
Construct  By: 0012FF58  1   //构造函数创建对象t1
Copy  Construct  0012FE60   0012FF58   //拷贝构造函数创建临时对象
Copy  Construct  0012FF4C   0012FE60   //拷贝构造函数传参(b=t1)
Destructed   0012FE60  1    //摧毁临时对象
Destructed   0012FF4C  1    //摧毁对象b
Destructed   0012FF58  1    //摧毁对象t1
*/

例5：

/*
 *第五种情况：分步解析
*/
#include<iostream>
using namespace std;

class B
{
public:
    B()
    {
        cout<<"Default  Construct"<<"  "<<this<<endl;
    }
    B(int i):data(i)
    {
        cout<<"Construct  By: "<<this<<"  "<<data<<endl;
    }
    B(const B &b)
    {
        cout<<"Copy  Construct"<<"  "<<this<<"   "<<&b<<endl;
        data = b.data;
    }
    B &operator=(const B &obj)
    {
        if(this!=&obj)
        {
            cout<<" operator= "<<this<<"  "<<&obj<<endl;
            data=obj.data;
        }
        return *this;
    }
    ~B()
    {
        cout<<"Destructed"<<"   "<<this<<"  "<<data<<endl;
    }
private:
    int data;
};

B Func(B &b)
{
    return b;
}
void main()
{
    B t1(1);
    B t2 = Func(t1);
}

//Out  put  
/*
Construct  By: 0012FF58  1   //构造函数创建对象t1
Copy  Construct  0012FF4C   0012FF58   //拷贝构造函数进行赋值(t2=b)
Destructed   0012FF4C  1     //摧毁对象t2
Destructed   0012FF58  1     //摧毁对象t1
*/

例6：

/*
 *第六种情况：分步解析
*/
#include<iostream>
using namespace std;

class B
{
public:
    B()
    {
        cout<<"Default  Construct"<<"  "<<this<<endl;
    }
    B(int i):data(i)
    {
        cout<<"Construct  By: "<<this<<"  "<<data<<endl;
    }
    B(const B &b)
    {
        cout<<"Copy  Construct"<<"  "<<this<<"   "<<&b<<endl;
        data = b.data;
    }
    B &operator=(const B &obj)
    {
        if(this!=&obj)
        {
            cout<<" operator= "<<this<<"  "<<&obj<<endl;
            data=obj.data;
        }
        return *this;
    }
    ~B()
    {
        cout<<"Destructed"<<"   "<<this<<"  "<<data<<endl;
    }
private:
    int data;
};

B & Func(B b)
{
    return b;
}
void main()
{
    B t1 = 5;
    B t2 = Func(t1);
}

//Out  put      
/*
Construct  By: 0012FF58  5       //隐式类型转换创建对象t1
Copy  Construct  0012FE60   0012FF58  //拷贝构造创建临时对象
Destructed   0012FE60  5         //摧毁临时对象
Copy  Construct  0012FF4C   0012FE60  //拷贝构造函数进行赋值(t2 = b)
Destructed   0012FF4C  1244768   //摧毁对象t2  //注意这个特殊启示
Destructed   0012FF58  5         //摧毁对象t1
*/

例7：

/*
 *第七种情况：分步解析
*/
#include<iostream>
using namespace std;

class B
{
public:
    B()
    {
        cout<<"Default  Construct"<<"  "<<this<<endl;
    }
    B(int i):data(i)
    {
        cout<<"Construct  By: "<<this<<"  "<<data<<endl;
    }
    B(const B &b)
    {
        cout<<"Copy  Construct"<<"  "<<this<<"   "<<&b<<endl;
        data = b.data;
    }
    B &operator=(const B &obj)
    {
        if(this!=&obj)
        {
            cout<<" operator= "<<this<<"  "<<&obj<<endl;
            data=obj.data;
        }
        return *this;
    }
    ~B()
    {
        cout<<"Destructed"<<"   "<<this<<"  "<<data<<endl;
    }
private:
    int data;
};

B & Func(B b)
{
    B t(3);
    return t;
}

void main()
{
    B t1(1);
    B t2(5);
    t2 = Func(t1);
}

//Out  put     
/*
Construct  By  :0012FF58  1   //构造函数创建对象t1
Construct  By  :0012FF4C  5   //构造函数创建对象t2
Copy  Construct  0012FE60   0012FF58   //拷贝构造函数创建临时对象
Construct  By  :0012FE44  3   //构造函数创建对象t
Destructed   0012FE44  3      //摧毁对象t
Destructed   0012FE60  1      //摧毁临时对象
operator=    0012FF4C   0012FE44  //拷贝构造函数进行赋值(t2=t)
Destructed   0012FF4C  -858993460 //摧毁对象t2
Destructed   0012FF58  1      //摧毁对象t1
*/

例8：

/*
 *第八种情况：分步解析
*/
#include<iostream>
using namespace std;

class B
{
public:
    B()
    {
        cout<<"Default  Construct"<<"  "<<this<<endl;
    }
    B(int i):data(i)
    {
        cout<<"Construct  By: "<<this<<"  "<<data<<endl;
    }
    B(const B &b)
    {
        cout<<"Copy  Construct"<<"  "<<this<<"   "<<&b<<endl;
        data = b.data;
    }
//     B &operator=(const B &obj)
//     {
//         if(this!=&obj)
//         {
//             cout<<" operator= "<<this<<"  "<<&obj<<endl;
//             data=obj.data;
//         }
//         return *this;
//     }
    ~B()
    {
        cout<<"Destructed"<<"   "<<this<<"  "<<data<<endl;
    }
private:
    int data;
};

B & Func(B b)
{
    B t(3);
    return t;
}

void main()
{
    B t1(1);
    B t2(5);
    t2 = Func(t1);   //?? 有无赋值函数的区别
}

//Out  put
/*
Construct  By  :0012FF58  1   //构造函数创建对象t1
Construct  By  :0012FF4C  5   //构造函数创建对象t2
Copy  Construct  0012FE60   0012FF58   //拷贝构造函数创建临时对象
Construct  By  :0012FE44  3   //构造函数创建对象t
Destructed   0012FE44  3      //摧毁对象t
Destructed   0012FE60  1      //摧毁临时对象
Destructed   0012FF4C  3      //摧毁对象t2
Destructed   0012FF58  1      //摧毁对象t1
*/

例9：

/*
 *第九种情况：分步解析
*/
#include<iostream>
using namespace std;

class B
{
public:
    B()
    {
        cout<<"Default  Construct"<<"  "<<this<<endl;
    }
    B(int i):data(i)
    {
        cout<<"Construct  By: "<<this<<"  "<<data<<endl;
    }
    B(const B &b)
    {
        cout<<"Copy  Construct"<<"  "<<this<<"   "<<&b<<endl;
        data = b.data;
    }
    B &operator=(const B &obj)
    {
        if(this!=&obj)
        {
            cout<<" operator= "<<this<<"  "<<&obj<<endl;
            data=obj.data;
        }
        return *this;
    }
    ~B()
    {
        cout<<"Destructed"<<"   "<<this<<"  "<<data<<endl;
    }
private:
    int data;
};

B Func(B &b)
{
    B t3(b);
    return t3;
}
void main()
{
    B t1=5;
    B t2=Func(t1);
}

//Out  put    //分步解析
/*
Construct  By: 0012FF58  5   //隐式类型转换创建对象t1
Copy  Construct  0012FE54   0012FF58  //拷贝构造函数创建临时对象
Copy  Construct  0012FF4C   0012FE54  //拷贝构造函数创建局部对象t3
Destructed   0012FE54  5   //摧毁临时对象
Destructed   0012FF4C  5   //摧毁局部对象t3
Destructed   0012FF58  5   //摧毁对象t1
*/

例10：

/*
 *第十种情况：分步解析
*/
#include<iostream>
using namespace std;

class B
{
public:
    B()
    {
        cout<<"Default  Construct"<<"  "<<this<<endl;
    }
    B(int i):data(i)
    {
        cout<<"Construct  By: "<<this<<"  "<<data<<endl;
    }
    B(const B &b)
    {
        cout<<"Copy  Construct"<<"  "<<this<<"   "<<&b<<endl;
        data = b.data;
    }
    B &operator=(const B &obj)
    {
        if(this!=&obj)
        {
            cout<<" operator= "<<this<<"  "<<&obj<<endl;
            data=obj.data;
        }
        return *this;
    }
    ~B()
    {
        cout<<"Destructed"<<"   "<<this<<"  "<<data<<endl;
    }
private:
    int data;
};

B Func(B &b)
{
    B t3(b);
    return t3;
}
void main()
{
    B t1 = 5;
    B t2;
    t2 = Func(t1);
}

//Out   put   
/*
Construct  By: 0012FF58  5   //隐式类型转换创建对象t1
Default  Construct:  0012FF4C//默认创建对象t2
Copy  Construct  0012FE40   0012FF58  //拷贝构造函数创建局部对象t3
Copy  Construct  0012FE80   0012FE40  //拷贝构造函数创建临时对象
Destructed   0012FE40  5   //函数结束摧毁对象t3
operator=   0012FF4C   0012FE80  //赋值函数进行赋值(t2=临时对象)
Destructed   0012FE80  5  //摧毁临时对象
Destructed   0012FF4C  5  //摧毁对象t2
Destructed   0012FF58  5  //摧毁对象t1
*/

例11：

/*
 *第十一种情况：分步解析
*/
#include<iostream>
using namespace std;

class B
{
public:
    B()
    {
        cout<<"Default  Construct"<<"  "<<this<<endl;
    }
    B(int i):data(i)
    {
        cout<<"Construct  By: "<<this<<"  "<<data<<endl;
    }
    B(const B &b)
    {
        cout<<"Copy  Construct"<<"  "<<this<<"   "<<&b<<endl;
        data = b.data;
    }
    B &operator=(const B &obj)
    {
        if(this!=&obj)
        {
            cout<<" operator= "<<this<<"  "<<&obj<<endl;
            data=obj.data;
        }
        return *this;
    }
    ~B()
    {
        cout<<"Destructed"<<"   "<<this<<"  "<<data<<endl;
    }
private:
    int data;
};

B & Func(B &b)
{
    B t3(b);
    return t3;
}
void main()
{
    B t1 = 5;
    B t2;
    t2 = Func(t1);
}

//Out  put     
/*
Construct  By: 0012FF58  5  //隐式类型转换构建对象t1
Default  Construct:  0012FF4C  //默认构造函数构建对象t2
Copy  Construct  0012FE64   0012FF58  //拷贝构造函数创建局部对象t3
Destructed   0012FE64  5   //函数结束摧毁局部对象t3
operator=   0012FF4C   0012FE64  //赋值函数进行赋值(t2=局部对象)
Destructed   0012FF4C  1245004  //摧毁对象t2  //? ?
Destructed   0012FF58  5   //摧毁对象t1
*/

例12：

/*
 *第十二种情况：分步解析
*/
#include<iostream>
using namespace std;

class B
{
public:
    B()
    {
        cout<<"Default  Construct"<<"  "<<this<<endl;
    }
    B(int i):data(i)
    {
        cout<<"Construct  By: "<<this<<"  "<<data<<endl;
    }
    B(const B &b)
    {
        cout<<"Copy  Construct"<<"  "<<this<<"   "<<&b<<endl;
        data = b.data;
    }
    B &operator=(const B &obj)
    {
        if(this!=&obj)
        {
            cout<<" operator= "<<this<<"  "<<&obj<<endl;
            data=obj.data;
        }
        return *this;
    }
    ~B()
    {
        cout<<"Destructed"<<"   "<<this<<"  "<<data<<endl;
    }
private:
    int data;
};

B & Func(B &b)
{
    B t3(b);
    return t3;
}
void main()
{
    B t1(5);
    B t2 = Func(t1);
}

//Out  put   
/*
Construct  By: 0012FF58  5    //构造函数创建对象t1
Copy  Construct  0012FE64   0012FF58  //拷贝构造函数创建局部对象t3
Destructed   0012FE64  5  //摧毁局部对象t3
Copy  Construct  0012FF4C   0012FE64  //拷贝构造函数进行赋值(t2=t3)
Destructed   0012FF4C  1245004  //摧毁对象t2   //? 思考
Destructed   0012FF58  5    //摧毁对象t1 
*/

例13：综合运用类中函数的示范程序：

/*
 *第十三种情况：分步解析
*/
#include<iostream>
using namespace std;

class B
{
public:
    B()
    {
        cout<<"Default  Construct"<<"  "<<this<<endl;
    }
    B(int i):data(i)
    {
        cout<<"Construct  By: "<<this<<"  "<<data<<endl;
    }
    B(const B &b)
    {
        cout<<"Copy  Construct"<<"  "<<this<<"   "<<&b<<endl;
        data = b.data;
    }
    B &operator=(const B &obj)
    {
        if(this!=&obj)
        {
            cout<<" operator= "<<this<<"  "<<&obj<<endl;
            data=obj.data;
        }
        return *this;
    }
    ~B()
    {
        cout<<"Destructed"<<"   "<<this<<"  "<<data<<endl;
    }
private:
    int data;
};

void Func(B &b)
{
    B t3(b);
}

void main()
{
    cout<<"B  t1执行结果:"<<endl;
    B t1;
    cout<<"B  t2(5)执行结果:"<<endl;
    B t2(5);
    cout<<"B  t3(t2)执行结果:"<<endl;
    B t3(t2);
    cout<<"B  t4=6执行结果:"<<endl;
    B t4=6;
    cout<<"B  t5=t4执行结果:"<<endl;
    B t5=t4;
    cout<<"B  t6执行结果:"<<endl;
    B t6;
    cout<<"t6 = t5执行结果:"<<endl;
    t6=t5;
    cout<<"Func(t6)执行结果:"<<endl;
    Func(t6);
}

//Out  put
/*
B  t1执行结果:
Default  Construct:  0x0012FF70
B  t2(5)执行结果:
Construct  By: 0x0012FF6C  5
B  t3(t2)执行结果:
Copy  Construct  0x0012FF68   0x0012FF6C
B  t4=6执行结果:
Construct  By: 0x0012FF64  6 //饮食类型转换
B  t5=t4执行结果:
Copy  Construct  0x0012FF60   0x0012FF64
B t6执行结果:
Default  Construct:  0x0012FF5C
t6 = t5执行结果:
operator=   0x0012FF5C   0x0012FF60
Func(t6)执行结果:
Copy  Construct  0x0012FF00   0x0012FF5C
Destructed   0x0012FF00  6   //摧毁局部对象t3
Destructed   0x0012FF5C  6   //摧毁局部对象t6
Destructed   0x0012FF60  6   //摧毁局部对象t5
Destructed   0x0012FF64  6   //摧毁局部对象t4
Destructed   0x0012FF68  5   //摧毁局部对象t3
Destructed   0x0012FF6C  5   //摧毁局部对象t2
Destructed   0x0012FF70  0   //摧毁局部对象t1
*/

 备注：前十二种示例完全可以说明传参与返回时，使用值与引用的区别。后一种主要解释一下类中函数的使用情况，在不同的情况下的调用区别。