C++深度解析教程学习笔记（6）对象的构造和销毁
1. 对象的初始化
(1)从程序设计的角度看,对象只是变量,因此:
①在栈上创建对象时,成员变量初始化为随机值
②在堆上创建对象时,成员变量初始化为随机值
③在静态存储区创建对象时,成员变量初始化为 0 值
成员变量的初始化
#include <stdio.h> class Test { private: int i; int j; public: int getI(){return i;} int getJ(){return j;} }; Test gt; //全局对象 int main() { //全局区，初始化为0 printf("gt.i = %d\n", gt.getI()); printf("gt.j = %d\n", gt.getJ()); //栈上的对象，初始化为随机值 Test st; printf("st.i = %d\n", st.getI()); printf("st.j = %d\n", st.getJ()); //堆上创建对象，初始化为随机值 Test* pt = new Test; printf("pt->i = %d\n", pt->getI()); printf("pt->j = %d\n", pt->getJ()); delete pt; return 0; }
(2)生活中的对象都是初始化了的
(3)初始状态是对象普遍存在一个状态
2. 构造函数
(1)C++中可以定义与类名相同的特殊成员函数,这个函数叫构造函数
①构造函数是没有任何返回类型(连 void 都没有,因为这个函数是编译器在创建对象时插入二进制代码用的,即由编译器来调用的)
②构造函数在对象定义时自动被调用
#include <stdio.h> class Test { private: int i; int j; public: int getI(){return i;} int getJ(){return j;} //构造函数 Test() { printf("Test() Begin\n"); i = 0;//成员变量初始化 j = 0;//成员变量初始化 printf("Test() End\n"); } }; Test gt; //全局对象 int main() { //全局区的对象 printf("gt.i = %d\n", gt.getI());//0 printf("gt.j = %d\n", gt.getJ());//0 //栈上的对象 Test st; printf("st.i = %d\n", st.getI());//0 printf("st.j = %d\n", st.getJ());//0 //堆上的对象 Test* pt = new Test; printf("pt->i = %d\n", pt->getI());//0 printf("pt->j = %d\n", pt->getJ());//0 delete pt; return 0; }
3.带参数的构造函数
(1)构造函数可以根据需要定义参数
(2)一个类中可以存在多个重载的构造函数
(3)构造函数的重载遵循 C++重载规则
对象的定义和声明不同
①对象定义:申请对象的空间并调用构造函数(如 Test t;//定义并调用构造函数)
②对象声明:告诉编译器己经存在一个对象,并不调用构造函数(如 extern Test t;)
4.构造函数的调用
(1)一般情况下,编译器会根据给定的参数情况自动调用相应的构造函数
带参数的构造函数
#include <stdio.h> class Test { public: //不带参的构造函数 Test() { printf("Test()\n"); } Test(int v) { printf("Test(int v), v = %d\n", v); } }; int main() { Test t; //调用Test(); Test t1(1); //调用Test(int v); Test t2 = 2; //调用Test(int v); int i(100); printf("i = %d\n", i); return 0; }
(2)一些特殊情况下,需要手工调用构造函数
构造函数的手动调用
#include <stdio.h> class Test { private: int m_value; public: //不带参的构造函数 Test() { m_value = 0; printf("Test()\n"); } Test(int v) { m_value = v; printf("Test(int v), v = %d\n", v); } int getValue(){return m_value;} }; int main() { //Test ta[3] = {1, 2, 3};//编译器自动调用带参构造函数 //定义数组对象，并手动调用带参构造函数来初始化各个对象 Test ta[3] ={Test(), Test(1), Test(2)}; for(int i = 0;i< 3;i++) { printf("ta[%d].getValue() = %d\n", i, ta[i].getValue()); } Test t = Test(100); //定义并手动调用构造函数来初始化对象 return 0; }
5.特殊的构造函数
|
无参构造函数 |
拷贝构造函数 |
|
|
参数形式 |
没有参数的构造函数 |
参数为const class_name&的构造函数 |
|
默认情况 |
当类中没有定义构造函数时，编译器默认提供一个无参构造函数，并且其函数体为空 |
当类中没有定义拷贝构造函数时，编译器默认提供一个拷贝构造函数，简单的进行成员变量的值复制 |
|
注意： |
当类中定义了构造函数（含带参、不带参、或拷贝构造函数），则系统就不再提供默认的无参构造函数。而拷贝构造函数只有在我们定义时，系统才不提供。 |
|
特殊的构造函数
#include <stdio.h> class Test { private: int i; int j; public: int getI(){return i;} int getJ(){return j;} /* //拷贝构造函数 Test(const Test& t) { i = t.i; j = t.j; } */ //无参构造函数 Test() { } }; int main() { //调用无参构造函数，注意如果我们定义了构造函数（含无参、带参或拷贝 //构造函数时）系统就不再提供默认的，需自己定义无参构造函数。 Test t1; //调用Test() Test t2 = t1;//调用拷贝构造函数，如果我们不定义，系统会提供默认的 printf("t1.i = %d, t1.j = %d\n",t1.getI(),t1.getJ()); printf("t2.i = %d, t2.j = %d\n",t2.getI(),t2.getJ()); return 0; }
6.拷贝构造函数
(1)拷贝构造函数的意义
①兼容 C 语言的初始化方式,即利用己经存在的对象去创建新的对象。(因为 C++中初始化会涉及到拷贝构造函数的调用。注意初始化与赋值是不同的,赋值时“=”运算符会被调用)
如:int a = b; //C 中,用一个变量来初始化另一个变量;
Student s2 = s1;//利用己经存在的 s1 对象来初始化,很像 C 的初始化方式
②初始化行为能够符合预期的逻辑
(2)浅拷贝和深拷贝
①拷贝后对象的物理状态相同→编译器提供的拷贝构造函数只进行浅拷贝
②拷贝后对象的逻辑状态相同
对象的初始化
#include <stdio.h> class Test { private: int i; int j; int* p; public: int getI(){return i;} int getJ(){return j;} int* getP(){return p;} /* //拷贝构造函数 Test(const Test& t) { i = t.i; j = t.j; p = new int; *p = *t.p; } */ //带参构造函数 Test(int v) { i = 1; j = 2; p = new int; *p = v; } ~Test(){delete p;} }; int main() { Test t1(3); //调用Test(int v); Test t2(t1); //调用Test(const Test& t) //t1.p和t2.p指向了同一个堆内存地址,析构的时候会释放两次p printf("t1.i = %d, t1.j = %d, *t1.p = %d\n", t1.getI(), t1.getJ(), *t1.getP()); printf("t2.i = %d, t2.j = %d, *t2.p = %d\n", t2.getI(), t2.getJ(), *t2.getP()); return 0; }
(3)什么时候需要进行深拷贝
①对象中有成员指代了系统中的资源
②如成员指向了动态内存空间、打开了外存中的文件或使用了系统中的网络端口等
③自定义拷贝构造函数时,必然需要实现深拷贝
自定义数组类
//IntArray.h #ifndef _INTARRAY_H_ #define _INTARRAY_H_ class IntArray { private: int m_length; int* m_pointer; public: IntArray(int len); IntArray(const IntArray& obj); ~IntArray(); int length(); bool get(int index, int& value); bool set(int index, int value); }; #endif
//IntArray.cpp #include "IntArray.h" IntArray::IntArray(int len) { m_pointer = new int[len]; for(int i = 0; i<len; i++) { m_pointer[i] = 0; } m_length = len; } IntArray::IntArray(const IntArray& obj) { m_length = obj.m_length; m_pointer = new int[obj.m_length]; for (int i = 0;i < obj.m_length; i++) { m_pointer[i] = obj.m_pointer[i]; } } IntArray::~IntArray() { if(m_pointer) { delete[] m_pointer; } } int IntArray::length() { return m_length; } bool IntArray::get(int index, int& value) { bool bRet = (0 <= index) && (index <m_length); if(bRet) { value = m_pointer[index]; } return bRet; } bool IntArray::set(int index, int value) { bool bRet = (0 <= index) && (index <m_length); if(bRet) { m_pointer[index] = value; } return bRet; }
//main.cpp #include <stdio.h> #include "IntArray.h" int main() { IntArray a(5);//调用带参构造函数 for(int i=0; i<a.length(); i++) { a.set(i, i + 1); } for(int i=0; i<a.length(); i++) { int value = 0; if(a.get(i, value)) { printf("a[%d] = %d\n", i, value); } } IntArray b = a; //调用拷贝构造函数 for(int i=0; i<b.length();i++) { int value = 0; if(b.get(i, value)) { printf("b[%d] = %d\n", i, value); } } return 0; }
7.初始化列表
7.1.类成员的初始化
(1)C++中提供了初始化列表,可以对成员变量进行初始化
(2)语法规则:
ClassName::ClassName():m1(v1), m2(v2,v3),m3(v3) { //其它初始化操作 }
(3)注意事项
①成员的初始化顺序与成员的声明顺序相同。而与初始化列表中的位置无关
②初始化列表先于构造函数的函数体执行
#include <stdio.h> class Value { private: int mi; public: Value(int i) { printf("i = %d\n", i); mi = i; } int getI(){return mi;} }; class Test { private: Value m2; Value m3; Value m1; public: //初始化顺序只与声明顺序有关，与初始化列表次序无关 //即初始化顺序为：m2,m3,m1。最后才是调用构造函数 Test():m1(1), m2(2), m3(3) //成员变量的初始化 { printf("Test::Test()\n"); } }; int main() { Test t; return 0; }
7.2.类中的const成员
(1)类中的 const 成员会被分配空间。但本质上是个只读变量,因为编译器无法直接得到const 成员的初始值,因此无法进入符号表成为真正意义上的常量。
类中的 const 成员(值为多少,存储在哪里?)
#include <stdio.h> class Test { private: //const成员，会分配空间。其存储空间与对象存储位置一样 //可在栈上、堆或全局区等 //但编译期间无法确定初始化，所以不会进入符号表 const int ci; public: Test() { //ci = 10; //不能这样初始化，ci是只读变量，不能作为左值 } int getCI(){return ci;} } int main() { Test t; //会提示ci变量未被初始化 printf("t.ci = %d\n", t.getCI()); return 0; }
(2)类中的 const 成员只能在初始化列表中指定初始值。而不能在其他地方(如构造函数的内部,因为形如 c = 1 的赋值语句,意味着要给 const 变量赋值这是不允许的)
只读成员变量
#include <stdio.h> class Value { private: int mi; public: Value(int i) { printf("i = %d\n", i); mi = i; } int getI(){return mi;} }; class Test { private: const int ci; Value m2; Value m3; Value m1; public: Test():m1(1), m2(2), m3(3), ci(100) //成员变量的初始化 { printf("Test::Test()\n"); } int getCI(){return ci;} int setCI(int v) { //说明ci是个只读变量，可以通过指针修改内存值 int* p = const_cast<int*>(&ci); *p = v; } }; int main() { Test t; printf("t.ci = %d\n", t.getCI()); //100 t.setCI(10); printf("t.ci = %d\n", t.getCI()); //10 return 0; }
(3)初始化与赋值不同
①初始化:对正在创建的对象进行初值设置(如 int a = 1;或初始化列表的形式)
②赋值:对己经存在的对象进行值设置(如 a = 1;)
类中可以使用初始化列表对成员进行初始化，初始化列表先于构造函数体执行，const 成员变量必须在初始化列表中指定初值，const 成员变量为只读变量。
8. 对象的构造顺序
(1)对于局部对象:当程序执行流到达对象的定义语句时进行构造
#include <stdio.h> class Test { private: int mi; public: Test(int i) { mi = i; printf("Test(int i): %d\n", mi); } Test(const Test& obj) { mi = obj.mi; printf("Test(const Test& obj): %d\n", mi); } ~Test() { printf("~Test(): %d\n", mi); } }; int main() { int i = 0; Test a1 = i;//Test(int i):0，执行到这里时构造a1 while(i < 3) { //注意：a2的作用域只在这个大括号内 //所以，每执行1次，构造一次a2 Test a2 = ++i;//Test(int i):1、2、3 } goto LabelEnd; //因跳转，所以下列的a不会被构造 if (i < 4) { Test a = a1;//Test(const Test&):0。但因goto，该对象不会被构造 } else { Test a(100);//不会被执行，所以不会调用Test(int i) } LabelEnd: return 0; }
(2)对于堆对象
①当程序执行流到达 new 语句时创建对象
②使用 new 创建对象将自动触发构造函数的调用
#include <stdio.h> class Test { private: int mi; public: Test(int i) { mi = i; printf("Test(int i): %d\n", mi); } Test(const Test& obj) { mi = obj.mi; printf("Test(const Test& obj): %d\n", mi); } ~Test() { //printf("~Test(): %d\n", mi); } }; int main() { int i = 0; Test* a1 = new Test(i); //Test(int i):0 while(++i < 10) if (i % 2) //i % 2 !=0 new Test(i);//Test(int i):1、3、5、7、9 if (i < 4) { new Test(*a1);//Test(const& Test):0 } else { new Test(100);//Test(int i):100 } return 0; }
(3)对于全局对象
①对象的构造顺序是不确定的
②不同的编译器使用不同的规则确定构造顺序
//test.h #ifndef _TEST_H_ #define _TEST_H_ #include<stdio.h> class Test { public: Test(const char* s) { printf("%s\n", s); } }; #endif
//t1.cpp #include "test.h" Test t1("t1");//全局变量
//t2.cpp #include "test.h" Test t2("t2");//全局变量
//t3.cpp #include "test.h" Test t3("t3");//全局变量
//main.cpp #include <stdio.h> #include "test.h" //注意：全局变量会先于main函数执行，因此 //4个全局变量t1-t4会被先构造，再其顺序是不确定的， //要依赖于编译器。 //当构造完全局对象后，会执行main函数，可以发现 //t5是最后一个被构造的。 Test t4("t4");//全局变量 int main() { Test t5("t5");//局部变量 return 0; }
9.对象的销毁
9.1.析构函数
(1)C++的类中可以定义一个特殊的清理函数,叫析构函数
(2)析构函数的功能与构造函数相反
(3)定义:~ClassName();//注意,无参无返回值;对象销毁时会被自动调用
#include <stdio.h> class Test { private: int mi; public: Test(int i) { mi = i; printf("Test(): %d\n", mi); } //析构函数 ~Test() { printf("~Test(): %d\n", mi); } }; int main() { Test t(1); Test* pt = new Test(2); delete pt; return 0; }
析构函数的定义准则：当类中自定义了构造函数,并且构造函数中使用了系统资源(如:内存申请、文件打开等),则需要自定义析构函数
10.临时对象
(1)程序意图:在 Test()中以 0 作为参数调用 Test(int i)来将成员变量 mi 初始值设置为 0.
(2)运行结果:成员变量 mi 的值为随机值(没达到目的!)
#include <stdio.h> class Test { private: int mi; public: //带参构造函数 Test(int i) { mi = i; } //不带参构造函数 Test() { Test(0);//程序的意图是把Test当成普通函数来使用以达到对mi赋值的目的但直接调用构造函数，会将产生临时对象。所以Test(0)相当于 //对新的临时对象的mi赋初值为0，而不是对这个对象本身mi赋值 } void print() { printf("mi = %d\n", mi); } }; int main() { Test t; t.print(); //mi并没被赋初始，会输出随机值 return 0; }
10.1.临时对象
(1)构造函数是一个特殊的函数,调用构造函数将产生一个临时对象
(2)临时对象的生命期只有一条语句的时间
(3)临时对象的作用域只在一条语句中
(4)临时对象是 C++中值得警惕的灰色地带
解决方案
#include <stdio.h> class Test { private: int mi; //正确的做法，是提供一个用来初始化的普通函数 void init(int i){ mi = i; } public: //带参构造函数 Test(int i) { init(i); } //不带参构造函数 Test() { init(0);//调用普通的初始化函数，而不是带参的构造函数Test(int i); } void print() { printf("mi = %d\n", mi); } }; int main() { Test t; t.print(); //mi被赋值为0 return 0; }
10.2.临时对象与返回值优化（RVO）
(1)现代 C++编译器在不影响最终执行结果的前提下,会尽力减少临时对象的产生。
神秘的临时对象
#include <stdio.h> class Test { private: int mi; public: //带参构造函数 Test(int i) { mi = i; printf("Test(int i): %d\n", i); } //不带参构造函数 Test() { mi = 0; printf("Test()\n"); } //拷贝构造函数 Test(const Test& t) { mi = t.mi; printf("Test(cosnt Test& t): %d\n", t.mi); } void print() { printf("mi = %d\n", mi); } ~Test(){ printf("~Test()\n"); } }; Test func() { return Test(20); } int main() { Test t = Test(10); //==> Test t = 10，临时对象被编译器给“优化”掉了说明：如果不优化，该行代码的行为：调用Test(10) //将产生一个临时对象，并用这个对象去初始化t对象，会先调用Test(int i)，再调用Test(const Test& t) Test tt = func(); //==> Test tt = Test(20);==>Test tt = 20; //说明：如果不优化，该行代码的行为：在func内部调用Test(20)，将产生一个临时对象,此时(Test(int i)被调用，然后按值返回， //会调用拷贝构造函数Test(const Test&)产生第2个临时对象，最后用第2个临时对象去初始化tt对象，将再次调用Test(const Test& t) t.print(); tt.print(); return 0; } //实际输出（优化后）结果（在g++下，可以关闭RVO优化再测试：g++ -fno-elide-constructors test.cpp） //Test(int i): 10 //Test(int i): 20 //~Test() //~Test()
(2)返回值优化(RVO)
//假设 Test 是一个类,构造函数为 Test(int i); Test func() { return Test(2);//若不优化，将产生临时对象，并返回给调用者 }
①在没有任何“优化”之前,return Test(2)代码的行为这行代码中
先构造了一个 Test 类的临时的无名对象(姑且叫它 t1),接着把 t1 拷贝到另一块临时对象 t2(不在栈上),然后函数保存好 t2 的地址(放在 eax 寄存器中)后返回,Func 的栈区间被“撤消”(这时 t1 也就“没有”了,t1 的生存期在 Func 中,所以被析构了),在Test a = TestFun(); 这一句中,a 利用 t2 的地址,可以找到 t2,接着进行构造。这样 a 的构造过程就完成了。然后再把 t2 也“干掉”。
②经过“优化”的结果
可以看到,在这个过程中,t1 和 t2 这两个临时的对象的存在实在是很浪费的,占用空间不说,关键是他们都只是为 a 的构造而存在,a 构造完了之后生命也就终结了。既然这两个临时的对象对于程序员来说根本就“看不到、摸不着”(匿名对象),于是编译器干脆在里面做点手脚,不生成它们!怎么做呢?很简单,编译器“偷偷地”在我们写的 TestFun 函数中增加一个参数 Test&,然后把 a 的地址传进去(注意,这个时候 a 的内存空间已经存在了,但对象还没有被“构造”,也就是构造函数还没有被调用),然后在函数体内部,直接用 a 来代替原来的“匿名对象”,在函数体内部就完成 a 的构造。这样,就省下了两个临时变量的开销。这就是所谓的“返回值优化”!
③编译器“优化”后的伪代码
//Test a = func(); 这行代码，经过编译优化后的等价伪代码： //从中可以发现，优化后，减少了临时变量的产生 Test a; //a只是一个占位符 func(a); //传入a的引用 void func(Test& t) //优化时，编译器在func函数中增加一个引用的参数 { t.Test(2); //调用构造函数来构造t对象 }
直接调用构造函数将产生一个临时对象，临时对象是性能的瓶颈,也是 bug 的来源之一，现代 C++编译器会尽力避开临时对象，实际工程开发中需要人为的避开临时对象。
