标签：copy 匿名对象 拷贝 析构函数 运算 tor 杂类 back mes
有关构造函数
1构造函数定义及调用
1）C++中的类可以定义与类名相同的特殊成员函数，这种与类名相同的成员函数叫做构造函数；
2）构造函数在定义时可以有参数；
3）没有任何返回类型的声明。
2构造函数的调用
自动调用：一般情况下C++编译器会自动调用构造函数
手动调用：在一些情况下则需要手工调用构造函数
有关析构函数
析构函数定义及调用
1）C++中的类可以定义一个特殊的成员函数清理对象，这个特殊的成员函数叫做析构函数
语法：~ClassName()
2）析构函数没有参数也没有任何返回类型的声明
3）析构函数在对象销毁时自动被调用
4）析构函数调用机制
C++编译器自动调用
先创建的对象 后释放
Q对象销毁是发生在什么时候？
A对象的析构函数在的对象销毁前被调用，对象何时销毁也与其作用域有关。
例如，全局对象是在程序运行结束时销毁，自动对象是在离开其搜索作用域时销毁，而动态对象则是在使用delete运算符时销毁。
#include <iostream> using namespace std; class Test2 { public: //无参数构造函数 Test2() { m_a = 0; m_b = 0; cout<<"无参数构造函数"<<endl; } //有参数构造函数 Test2(int a) { m_a = a; m_b = 0; } Test2(int a, int b) { m_a = a; m_b = b; cout<<"有参数构造函数"<<endl; } //赋值构造函数 (copy构造函数) Test2(const Test2& obj) { cout<<"我也是构造函数 " <<endl; } public: void printT() { cout<<"普通成员函数"<<endl; } private: int m_a; int m_b; }; int main01() { Test2 t1; //调用无参数构造函数 cout<<"hello..."<<endl; return 0; } //调用 调用有参数构造函数 3 int main(void) { //1括号法 Test2 t1(1, 2); //调用参数构造函数 c++编译器自动的调用构造函数 t1.printT(); // 2 =号法[但这是一个很鸡肋的用法] Test2 t2 = (3, 4); // = c++对等号符 功能增强 c++编译器自动的调用构造函数 //对象的初始化 和 对象的赋值 是两个不同的概念 //3 对象的初始化 Test2 t4 = Test2(1, 2); //匿名对象 t1 = t4; //把t4 copy给 t1 //赋值操作
//4 赋值构造函数 (copy构造函数) Test2 t5 = Test2(t1); //等价于Test2 t5(t1); 等价于 Test2 t5 = t1;
//☆ Test2 t5 = Test2(t1);是程序员手工的调用构造函数
cout<<"hello..."<<endl; return 0; } /*============================================== END File ==============================================*/
有参数构造函数
普通成员函数
有参数构造函数
我也是构造函数
hello...
赋值构造函数的4种应用场景
这是初始化的两种； Test t2 = t1; Test t2(t1);
第三种是功能函数的形参是一个元素的时候{非指针，非引用}，这个时候实参给形参的时候必然调用拷贝构造
第四种是你说的返回，返回一个对象的时候，但这个时候返回的是匿名对象，
如果是初始化，是直接会转换为要初始化的那个对象的，
如果是赋值操作，这个时候确实会调用copy构造，但是这个对象的生命周期只有那么一行，用完立即被析构
#include <iostream> using namespace std; class Test4 { public: Test4() //无参数构造函数 { m_a = 0; m_b = 0; cout<<"无参数构造函数"<<endl; } Test4(int a) { m_a = a; m_b = 0; } Test4(int a, int b) //有参数构造函数 { m_a = a; m_b = b; cout<<"有参数构造函数"<<endl; } Test4(const Test4& obj )//赋值构造函数 (copy构造函数) { cout<<"赋值构造函数 " <<endl; m_b = obj.m_b + 100; m_a = obj.m_a + 100; } public: void printT() { cout<<"普通成员函数"<<endl; cout<<"m_a"<<m_a<<" m_b"<<m_b<<endl; } private: int m_a; int m_b; }; //1 赋值构造函数 用1个对象去初始化另外一个对象 int main(void) { Test4 t0(1, 2); Test4 t1(1, 2); /*赋值操作 和 初始化是两个不同的概念 =的赋值操作 不会调用构造函数 =的初始化操作 会调用构造函数 */ //operator=()//抛砖 t0 = t1; //用t1 给 t0赋值 //第1种调用方法 Test4 t2 = t1; //用t1来初始化 t2 【one】 t2.printT(); //第2种调用方法 Test4 t3(t1); //用t1对象 初始化 t2对象 【two】 t2.printT(); cout<<"hello..."<<endl; return 0; }
[Three]
#include <iostream> using namespace std; class Location { public: Location( int xx = 0 , int yy = 0 ) { X = xx ; Y = yy ; cout << "None Param Constructor Func.\n" ; } //copy构造函数 完成对象的初始化 Location(const Location & obj) //copy构造函数 { cout << "Copy Constructor func.\n" ; X = obj.X; Y = obj.Y; } ~Location() { cout << X << "," << Y << " Object destroyed." << endl ; } int GetX () { return X ; } int GetY () { return Y ; } private: int X , Y ; }; //业务函数 形参是一个元素 void f(Location p) { cout<<"业务函数"<<endl; cout<<p.GetX()<<endl; } void playobj() { Location a(1, 2); Location b = a; cout<<"b对象已经初始化完毕"<<endl; f(b); //实参b传给形参p会调用copy构造函数 } int main() { playobj(); cout<<"hello..."<<endl; return 0; }
None Param Constructor Func.
Copy Constructor func.
b对象已经初始化完毕
Copy Constructor func.
业务函数
1
1,2 Object destroyed.
1,2 Object destroyed.
1,2 Object destroyed.
hello...
[Four]
#include <iostream> #include <cstdio> using namespace std; class Location { public: Location( int xx = 0 , int yy = 0 ) { X = xx ; Y = yy ; cout << "Constructor Object.\n" ; } //copy构造函数 完成对象的初始化 Location(const Location & obj) //copy构造函数 { X = obj.X; Y = obj.Y; } ~Location() { cout << X << "," << Y << " Object destroyed." << endl ; } int GetX () { return X ; } int GetY () { return Y ; } private : int X , Y ; } ; /******************************************************************************************************************* g函数 返回一个元素 结论1 : 函数的返回值是一个元素 (复杂类型的), 返回的是一个新的匿名对象(所以会调用匿名对象类的copy构造函数) 结论2: 有关 匿名对象的去和留 如果用匿名对象 初始化 另外一个同类型的对象, 匿名对象 转成有名对象 如果用匿名对象 赋值给 另外一个同类型的对象, 匿名对象 被析构 你这么写代码,设计编译器的大牛们: 我就给你返回一个新对象(没有名字 匿名对象) *******************************************************************************************************************/ Location g() { Location A(1, 2); return A; } // void objplay2() { g(); } // void objplay3() { //用匿名对象初始化m 此时c++编译器 直接把匿名对转成m;(扶正) 从匿名转成有名字了m Location m = g(); printf("\r\n匿名对象,被扶正,不会析构掉\n"); cout<<m.GetX()<<endl; } void objplay4() { //用匿名对象 赋值给 m2后, 匿名对象被析构 Location m2(1, 2); m2 = g(); printf("\r\n因为用匿名对象=给m2, 匿名对象,被析构\n"); cout<<m2.GetX()<<endl;; } int main(void) { objplay2(); // objplay3(); // objplay4(); cout<<"hello..."<<endl; return 0; }
二个特殊的构造函数
1） 默认无参构造函数
当类中没有定义构造函数时，编译器默认提供一个无参构造函数，并且其函数体为空
2） 默认拷贝构造函数
当类中没有定义拷贝构造函数时，编译器默认提供一个默认拷贝构造函数，简单的进行成员变量的值复制
1）当类中没有定义任何一个构造函数时， c++编译器会提供默认无参构造函数和默认拷贝构造函数
2）当类中定义了拷贝构造函数时， c++编译器不会提供无参数构造函数
3）当类中定义了任意的非拷贝构造函数（即：当类中提供了有参构造函数或无参构造函数）， c++编译器不会提供默认无参构造函数
4 ）默认拷贝构造函数成员变量简单赋值
总结：只要你写了构造函数，那么你必须用。
构造析构阶段性总结
1）构造函数是C++中用于初始化对象状态的特殊函数
2）构造函数在对象创建时自动被调用， 在对象离开其作用域时候自动销毁
3）构造函数和普通成员函数都遵循重载规则
4）拷贝构造函数是对象正确初始化的重要保证
5） 必要的时候，必须手工编写拷贝构造函数
标签：copy 匿名对象 拷贝 析构函数 运算 tor 杂类 back mes
原文地址：http://www.cnblogs.com/-Mr-y/p/7801892.html
