本文详细介绍了C++中的构造函数和析构函数，包括它们的基本概念、调用规则以及在对象初始化、深拷贝和动态内存管理中的应用。特别讨论了拷贝构造函数的重要性，以及何时需要实现深拷贝以避免数据丢失。此外，还提到了对象初始化列表的作用和使用场景。
C++（五） 构造函数和析构函数
1. 基本概念
构造函数用于解决对象的初始化。构造函数是一种特殊的成员函数，与其他的函数不同，不需要用户调用，而是在建立对象是自动执行。
1.1 构造函数
C++中类可以定义和类名相同的特殊的成员函数，这种成员函数即构造函数。
注意：构造函数在定义时可以有参数；没有任何返回类型的声明；构造函数可以自动调用（一般情况下C++编译器会自动调用构造函数）或者手动调用（特殊情况）。
1.2 析构函数
理解为构造函数的逆操作。语法为~ClassName()
注意：析构函数没有参数，也没有返回值；析构函数在对象销毁时自动被C++编译器调用。
2. 具体细节
2.1 构造函数的分类以及调用规则
C++编译器提供了三种对象初始化的方案
#include <iostream>
using namespace std;
class Test
{
public:
Test();
Test(int x);
Test(int x, int y);
~Test();
private:
int x;
int y;
};
// 无参造函数
Test::Test()
{
this->x = 0;
this->y = 0;
}
Test::Test(int x)
{
this->x = x;
}
// 有参造函数
Test::Test(int x1,int y1)
{
this->x = x1;
this->y = y1;
}
// 析构函数
Test::~Test()
{
}
int main()
{
// 1 在初始化直接调用，括号法
Test t1(1, 2);
// 2 C++编译器对于=操作符进行了加强，可以使用=来进行操作
Test t2 = 3;
Test t3 = (4, 5);
// 3 直接显式的调用构造函数
Test t4 = Test(1);
return 0;
}
注意：当类中未对构造函数进行定义时，编译器会默认一个无参的构造函数，默认的构造函数函数体为空。
2.2 拷贝构造函数
例1
#include "iostream"
using namespace std;
class Test
{
public:
Test() //无参构造函数 默认构造函数
{
cout << "我是无参构造函数" << endl;
value = 0;
}
Test(int test_val) //无参构造函数 默认构造函数
{
cout << "我是有参构造函数" << endl;
value = test_val;
}
Test(const Test& obj)
{
cout << "我也是构造函数，我是通过另外一个对象obj2，来初始化我自己" << endl;
value = obj.value + 10;
}
~Test()
{
cout << "我是析构函数，自动被调用了" << endl;
}
void getTestValue()
{
cout << "value的值" << value << endl;
}
protected:
private:
int value;
};
//单独搭建一个舞台来进行测试
void ObjShow01()
{
/* 定义一个变量 */
Test t0(5);
Test t1(20);
/* 使用赋值法来对t2进行初始化*/
Test t2 = t0;
t2.getTestValue();
t1 = t0;
t1.getTestValue();
}
int main()
{
ObjShow01();
return 0;
}
结果
对比t2和t1的初始化过程，对t2进行初始化时C++编译器会自动调用类中的拷贝构造函数，从而实现深拷贝；而对t1进行初始化时只是通过=进行简单的赋值，是浅拷贝。
例2
#include "iostream"
using namespace std;
class Test
{
public:
Test() //无参构造函数 默认构造函数
{
cout << "我是无参构造函数" << endl;
value = 0;
}
Test(int test_val) //无参构造函数 默认构造函数
{
cout << "我是有参构造函数" << endl;
value = test_val;
}
Test(const Test& obj)
{
cout << "我也是构造函数，我是通过另外一个对象obj2，来初始化我自己" << endl;
value = obj.value + 10;
}
~Test()
{
cout << "我是析构函数，自动被调用了" << endl;
}
void getTestValue()
{
cout << "value的值" << value << endl;
}
protected:
private:
int value;
};
void testFunction(Test obj)
{
cout<<"test_function"<< endl;
obj.getTestValue();
}
//单独搭建一个舞台来进行测试
void ObjShow03()
{
/* 定义一个变量 */
Test t1(10);
testFunction(t1);
}
int main()
{
ObjShow03();
return 0;
}
结果
分析：在ObjShow03()中先定义了Test t1(10)，这一过程C++编译器会自动调用构造函数进行初始化。然后调用testFunction(t1)，这一过程中，先使用Test中的构造函数来构造函数testFunction(obj)的参数obj，然后当testFunction函数运行结束后执行obj对象的析构函数。最后在退出ObjShow03()函数后，调用t1的析构函数。
例3
#include <iostream>
using namespace std;
class Teacher
{
string name;
string course;
public:
Teacher(const char *n,const char *c):name(n),course(c)
{
cout << "创建" << course << "老师" << name <<endl;
}
Teacher(const Teacher& t)
{
name = t.name;
course = t.course;
cout << "复制" << course << "老师" << name << endl;
}
~Teacher()
{
cout << "辞退" << course << "老师" << name <<endl;
}
};
int main()
{
Teacher t1("陈宗权","C++");//构造函数
Teacher t2 = t1;//拷贝构造函数
//用匿名对象（临时对象）来初始化一个新对象
//编译器一般会优化成直接用创建匿名对象的参数来创建新对象
Teacher t3 = Teacher("杨强","UC");
t2 = t3; //赋值函数
cout << "=======" <<endl;
t2 = Teacher("徐薇薇","咨询"); // 没有优化创建匿名对象，调用赋值函数，且匿名对象被析构
cout << "=======" <<endl;
}
/*
创建C++老师陈宗权
复制C++老师陈宗权
创建UC老师杨强
=======
创建咨询老师徐薇薇
辞退咨询老师徐薇薇
=======
辞退UC老师杨强
辞退咨询老师徐薇薇
辞退C++老师陈宗权
*/
分析：Teacher t3 = Teacher(“杨强”,“UC”)中，首先通过构造函数生成了一个匿名对象，由于该匿名对象用于对t3的初始化（通过拷贝构造函数），因此未析构。
t2 = Teacher(“徐薇薇”,“咨询”)中，同样首相通过构造函数生成了一个匿名对象，由于该匿名对象不是用于初始化而是用于赋值（通过操作符重载），因此析构了。
匿名对象（临时对象）：
通常以下三种情况会产生临时对象：以值的方式给函数传参；类型转换；函数需要返回一个对象时。
注意：当类中未对拷贝构造函数进行定义时，编译器会提供一个默认的拷贝构造函数，默认的拷贝构造函数只是简单地进行成员变量的复制（值的复制，即浅拷贝）。
2.3 构造函数的调用规则
1.当类中定义了构造函数，C++编译器不会再提供无参的构造函数；
2.当类中有成员变量是其它类的对象时，首先调用成员变量的构造函数，调用顺序与声明顺序相同；之后调用自身类的构造函数；
3.析构函数的调用顺序与对应的构造函数调用顺序相反。
3. 深拷贝和浅拷贝
3.1 基本概念
3.1.2 浅拷贝
对基本类型的数据以及简单的对象，拷贝就是按位复制内存，如：
class Base{
public:
Base(): m_a(0), m_b(0){ }
Base(int a, int b): m_a(a), m_b(b){ }
private:
int m_a;
int m_b;
};
int main(){
int a = 10;
int b = a; //拷贝
Base obj1(10, 20);
Base obj2 = obj1; //拷贝
return 0;
}
分析：b和obj2都是通过拷贝进行初始化，即将a和obj1所在内存中的数据按照二进制位复制到b和obj2的内存中，这种默认的拷贝方式即为浅拷贝。
对于简单的类，默认的拷贝构造函数（浅拷贝）足矣，但是当类拥有动态分配的内存、指向其他数据的指针时，单纯地进行浅拷贝会导致信息的丢失。因此需要显式地定义拷贝构造函数，以完整地拷贝对象的所有数据。
3.1.2 深拷贝
如通过深拷贝实现变长数组
#include <iostream>
#include <cstdlib>
using namespace std;
//变长数组类
class Array{
public:
Array(int len);
Array(const Array &arr); //拷贝构造函数
~Array();
public:
int operator[](int i) const { return m_p[i]; } //获取元素（读取）
int &operator[](int i){ return m_p[i]; } //获取元素（写入）
int length() const { return m_len; }
private:
int m_len;
int *m_p;
};
Array::Array(int len): m_len(len){
m_p = (int*)calloc( len, sizeof(int) );
}
Array::Array(const Array &arr){ //拷贝构造函数
this->m_len = arr.m_len;
this->m_p = (int*)calloc( this->m_len, sizeof(int) );
memcpy( this->m_p, arr.m_p, m_len * sizeof(int) );
}
Array::~Array(){ free(m_p); }
//打印数组元素
void printArray(const Array &arr){
int len = arr.length();
for(int i=0; i<len; i++){
if(i == len-1){
cout<<arr[i]<<endl;
}else{
cout<<arr[i]<<", ";
}
}
}
int main(){
Array arr1(10);
for(int i=0; i<10; i++){
arr1[i] = i;
}
Array arr2 = arr1;
arr2[5] = 100;
arr2[3] = 29;
printArray(arr1);
printArray(arr2);
return 0;
}
结果：
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
0, 1, 2, 29, 4, 100, 6, 7, 8, 9
分析：
这一例子中显式地定义了拷贝构造函数，在调用这一函数时，除了会将原有对象的所有变量拷贝给新对象，还会为新对象再分配一块内存，并将原有对象所持有的内存也拷贝过来。这样使得原有对象和新对象的内存是相互独立的，更改一个对象的值不会影响另一个对象的值。
这种将对象及其所持有资源一并拷贝的行为叫做深拷贝。必须显式地定义拷贝构造函数才能够实现深拷贝。
3.2 适用情况
如果一个类拥有指针类型的成员变量，那么绝大部分情况下需要进行深拷贝，因为只有这样，才能将指针所指向的内容再复制一份，而不是两个指针实际上指向的是同一个内容。如果类的成员变量中没有指针，一般浅拷贝即可。
另外一种需要深拷贝的情况就是在创建对象时进行一些预处理工作，比如记录对象创建的时间，统计创建过的对象的数目等，如下列所示：
#include <iostream>
#include <ctime>
#include <windows.h> //在Linux和Mac下要换成 unistd.h 头文件
using namespace std;
class Base{
public:
Base(int a = 0, int b = 0);
Base(const Base &obj); //拷贝构造函数
public:
int getCount() const { return m_count; }
time_t getTime() const { return m_time; }
private:
int m_a;
int m_b;
time_t m_time; //对象创建时间
static int m_count; //创建过的对象的数目
};
int Base::m_count = 0;
Base::Base(int a, int b): m_a(a), m_b(b){
m_count++;
m_time = time((time_t*)NULL);
}
Base::Base(const Base &obj){ //拷贝构造函数
this->m_a = obj.m_a;
this->m_b = obj.m_b;
this->m_count++;
this->m_time = time((time_t*)NULL);
}
int main(){
Base obj1(10, 20);
cout<<"obj1: count = "<<obj1.getCount()<<", time = "<<obj1.getTime()<<endl;
Sleep(3000); //在Linux和Mac下要写作 sleep(3);
Base obj2 = obj1;
cout<<"obj2: count = "<<obj2.getCount()<<", time = "<<obj2.getTime()<<endl;
return 0;
}
结果：
obj1: count = 1, time = 1488344372
obj2: count = 2, time = 1488344375
分析：Base 类中的 m_time 和 m_count 分别记录了对象的创建时间和创建数目，它们在不同的对象中有不同的值，所以需要在初始化对象的时候提前处理一下，需要使用深拷贝而不是浅拷贝。
4. 对象初始化列表
4.1 基本概念
C++中提供对象初始化列表对成员变量进行初始化
class foo
{
public:
foo(string s, int i):name(s), id(i){} ; // 初始化列表
private:
string name ;int id ;
};
foo(string s, int i):name(s), id(i){}即为初始化列表。
——成员变量的初始化顺序由声明的顺序决定，与在初始化列表中的顺序无关；
——初始化列表先于构造函数的函数体执行。
4.2 使用初始化列表的原因
1.出于性能考虑。对于内置类型，如int，float等，使用初始化列表和构造函数效率差别不大；但是对于类，使用初始化列表无需调用构造函数，效率高；
2.必须使用初始化列表的情况：
常量成员：因为常量只能初始化不能赋值，因此必须使用初始化列表；
引用类型：引用必须在定义的时候初始化，并且不能重新赋值；
没有默认构造函数的类：因为使用初始化列表可以不必通过默认构造函数进行初始化，而是直接通过拷贝构造函数。（主要针对这一问题：在定义一个成员有类的类对象时，如果该类成员没有默认构造函数，则会报错）。
5. 类对象的动态建立和释放
通过new和delete
通过new如果成功，返回内存首地址（赋值给指针），如果失败，返回NULL。
扫一扫
1433
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
