【学习篇】【C++】【类和对象】【对象初始化和清理】

一、构造函数和析构函数

构造函数：主要作用在于创建对象时为对象的成员属性赋值，由编译器自动调用，无需手动
析构函数：主要作用于对象销毁前系统自动调用，执行一些清理工作。

---

构造函数的语法：函数名（即是类名）() {}
1. 没有返回值也不写void
2. 函数名称与类名相同
3. 构造函数可以有参数，因此可以发生重载
4. 程序在调用对象时候会自动调用构造，无需手动调用，而且只会调用一次

析构函数的语法：~函数名（即是类名）() {}
1. 没有返回值也不写void
2. 函数名称与类名相同，在名称前加~
3. 析构函数不可以有参数，因此不能发生重载
4. 程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次

---

e.g.

class Person
{
public:
	//构造函数
	Person()
	{
		cout << "Person的构造函数调用" << endl;
	}

	//析构函数
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}
};

int main()
{
	Person p;
	return 0;
}

1.构造函数的分类及调用

---

两种分类方式：

1. 参数：无参构造（默认构造）、有参构造

Person()
{
	cout << "Person的无参构造函数调用" << endl;
}
	
Person(int a)
{
	age = a;
	cout << "Person的有参构造函数调用" << endl;
}

2. 类型：普通构造、拷贝构造

除了拷贝构造，其余都是普通构造。

//拷贝构造函数
Person(const Person& p)
{
	//将传入的人身上的所有属性都拷贝到我身上
	age = p.age;
	cout << "Person的拷贝构造函数调用" << endl;
}

---

三种调用方式：

1. 括号法

Person p1; //默认构造函数调用
Person p2(10); //调用有参构造函数
Person p3(p2); //调用拷贝函数

注意事项：
调用默认构造函数的时候，不要加()。否则编译器会认为Person p1();是一个函数声明，而不是创建对象

2. 显示法

Person p1; //默认构造函数调用
Person p2 = Person(10); //调用有参构造函数
Person p3 = Person(p2); //调用拷贝函数

Person(10); //匿名对象
	
Person(p3); //错误的写法，原因见下

匿名对象的特点：当前行执行结束后，系统会立即回收掉匿名对象

注意事项：
不要利用拷贝构造函数来初始化匿名对象。编译器会认为Person(p3);等同于对象声明Person p3;

3. 隐式转换法

Person p4 = 10; //相当于写了Person p4 = Person(10);有参构造
Person p5 = p4; //拷贝构造

---

2.拷贝构造函数的调用时机

三种情况：

1. 使用一个已经创建完毕的对象来初始化一个新对象
2. 值传递的方式给函数参数传值
3. 以值方式返回局部对象

情况1：使用一个已经创建完毕的对象来初始化一个新对象

//*******************************************
//使用一个已经创建完毕的对象来初始化一个新对象
void test_001()
{
	Person p1(20);
	Person p2(p1);

	cout << "p2的年龄为： " << p2.m_age << endl;
}

情况2： 值传递的方式给函数参数传值

//*******************************************
//值传递的方式给函数参数传值
void dowork(Person ppap)
{

}
void test_002()
{
	Person p;
	dowork(p);//这里值传递相当于Person ppap = p（隐式写法）
}

情况3：以值方式返回局部对象

//*******************************************
//以值方式返回局部对象
Person dowork2()
{
	Person p1;
	cout << (int*)&p1 << endl;
	return p1;
}
void test_003()
{
	Person p = dowork2();
	cout << (int*)&p << endl;

}

---

最后结合编译结果来讲解。

//*******************************************
int main()
{
	test_001();
	cout << "**************test已结束****************" << endl;
	test_002();
	cout << "**************test已结束****************" << endl;
	test_003();
	cout << "**************test已结束****************" << endl;
	return 0;
}

1. 函数test_001()调用，首先Person p1(20)先调用了有参构造函数
2. 然后Person p2(p1)调用了拷贝构造函数
3. 输出p2的年龄为：20
4. 到此test_001()函数运行结束，调用析构函数释放p1和p2
**************test已结束****************
5. 函数test_002()调用，首先Person p先调用了无参构造函数
6. 然后dowork(p)调用了拷贝构造函数。这里值传递相当于隐式写法Person ppap = p
7. 然后dowork(p)函数运行结束，调用析构函数释放ppap
8. 最后test_002()函数运行结束，调用析构函数释放p
**************test已结束****************
9. 函数test_003()调用，首先是dowork2()中的Person p1先调用了无参构造函数
10. 然后输出了p1的地址
11. 然后Person p = dowork2()调用了拷贝构造函数，此处等价于Person p = p1
12. 结束后，调用析构函数释放了dowork2()中的p1
13. 然后输出了p的地址
14. 到此test_003()函数运行结束，调用析构函数释放p
**************test已结束****************

3.构造函数的调用规则

默认情况下，c++编译器至少给一个类添加三个函数，默认的构造、析构、拷贝构造。

【规则如下】
用户定义了有参构造，不再提供默认无参构造，但是提供默认的拷贝构造
用户定义了拷贝构造，c++不再提供其他构造函数

无参构造	有参构造	拷贝构造
X(不提供默认的)	√	√(提供默认的)
X(不提供默认的)	X(不提供默认的)	√

二、深拷贝和浅拷贝

浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作

---

举例：

1. 先定义一个Person类class Person{ };

class Person
{
public:
	int m_age; //年龄
	int* m_height; //身高，用指针是为了开辟到堆区

2. 定义有参构造函数、拷贝构造函数和析构函数

Person(int age, int height)
{
	m_age = age;
	m_height = new int(height); //将身高数据的内存开辟到堆区
	cout << "Person的有参构造函数调用" << endl;
}

	//拷贝构造函数
Person(const Person& p)
{
	//将传入的人身上的所有属性都拷贝到我身上
	cout << "Person的拷贝构造函数调用" << endl;
	m_age = p.m_age;
	//m_height = p.m_height;编辑器默认实现的代码

	//深拷贝操作
	m_height = new int(*p.m_height);
}

3. 定义析构函数

//析构函数
~Person()
{
	//析构代码，将堆区开辟数据做释放操作
	if (m_height != NULL)
	{
		delete m_height;
		m_height = NULL;
	}
	cout << "Person的析构函数调用" << endl;
}

4. 定义测试函数test_001()

void test_001()
{
	Person p1(18, 180);
	cout << "p1的年龄为： " << p1.m_age 
		<< " 身高为： " << *p1.m_height << endl;
	Person p2(p1);
	cout << "p2的年龄为： " << p2.m_age 
	<< " 身高为： " << *p2.m_height << endl;
}

由于身高的数据保存在堆区，由上面测试函数可以看出我们需要用指针去访问身高数据。

---

【分析】

如果用户没有定义拷贝构造函数，则Person p2(p1);编辑器默认实现的代码是：

//浅拷贝操作
m_age = p.m_age;
height = p.m_height;

此时当函数运行结束，准备运行析构函数时，由于p2和p1都保存在栈区，根据栈区先进后出的原则，首先运行的是p2的析构函数，此时*p2.m_height的内存会被释放。（这里的*p2.m_height其实就是*p1.m_height，因为是原封不动赋值拷贝过来的，即将p1的身高数据p1.m_height的地址原封不动的拷贝。）

if (m_height != NULL)
	{
		delete m_height;
		m_height = NULL;
	}

所以当后面再运行p1的析构函数时，会对*p1.m_height的内存再一次释放，而前面已经释放过一次了，因此本次释放属于违法操作会报错。

---

所以当我们采用深拷贝来避免浅拷贝所带来的堆区的内存重复释放的问题时，会在堆区新建一个内存空间

//深拷贝操作
m_height = new int(*p.m_height);

此时*p2.m_height和*p1.m_height不同，即是两个不同地址的堆区内存，仅仅是所保存的身高数值相同。故后面运行析构函数的时候不会出现释放两次相同的堆区内存的问题。

---

三、初始化列表

首先我们看一下传统初始化操作

class Person
{
public:
	int m_a;
	int m_b;
	int m_c;
	
public:
	//构造函数
	//传统初始化操作
	Person(int a, int b, int c)
	{
		m_a = a;
		m_b = b;
		m_c = c;
	}
};

再利用初始化列表初始化属性，特别注意冒号的位置，在形参列表的后面。
Person(int a, int b, int c) : m_a(a), m_b(b), m_c(c)

//利用初始化列表初始化属性
Person(int a, int b, int c) : m_a(a), m_b(b), m_c(c)
{}


};

---

四、类对象作为类成员

当其他类对象作为本类成员，构造本类对象的时候，先构造其他类对象，再构造自身类剩余成员。同理，析构对象时，先析构自身，再析构其他类对象。

举例：

1. 人类：姓名、手机

class Person
{
public://姓名、手机
	string m_name;
	Phone m_phone;
public:
	Person(string name, string pname) : m_name(name), m_phone(pname)
	{
		cout << "Person的构造函数调用" << endl;
	}
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}
};

2. 手机类：手机型号

class Phone 
{
public:
	string m_phone_name; //手机品牌名称
public:
	Phone(string pname)
	{
		cout << "Phone的构造函数调用" << endl;

		m_phone_name = pname;
	}
	~Phone()
	{
		cout << "Phone的析构函数调用" << endl;
	}

};

观察输出结果分析，在创造Person类的对象p1的之前，先创建了Phone类的对象p1.m_phone，再创建Person类的p1.m_name。同理在创造Person类的对象p2也是如此。
在函数test_001()运行结束后，先释放Person类的对象p2，再释放Phone类的对象p2.m_phone。同理，先释放Person类的对象p1，再释放Phone类的对象p1.m_phone。

void test_001()
{
	Person p1("张三", "苹果");
	cout << "姓名： " << p1.m_name << endl;
	cout << "手机型号： " << p1.m_phone.m_phone_name << endl;

	Person p2("李四", "华为");
	cout << "姓名： " << p2.m_name << endl;
	cout << "手机型号： " << p2.m_phone.m_phone_name << endl;
}

---

五、静态成员

在成员变量和成员函数前加上关键字static

1. 静态成员变量
   • 所有对象共享同一份数据
   • 在编译阶段分配内存
   • 类内声明，类外初始化（必须初始化）
2. 静态成员函数
   • 所有对象共享同一个函数
   • 静态成员函数只能访问静态成员变量

---

1.静态成员变量

静态成员变量：类内声明，类外初始化。不属于任何对象

class Person
{
public:
	static int m_a; // 静态成员变量：类内声明，类外初始化。不属于任何对象
	int m_b;
};
int Person::m_a = 0;

---

2.静态成员函数

如下面的代码块显示，当我们再创建一个非静态成员变量m_b，会报错，因为静态成员函数不能访问非静态成员变量，非静态成员变量的引用必须与特定对象相对。

class Person
{
public:
	//静态成员函数
	static void func() 
	{
		m_a = 100; //静态成员函数 可以访问 静态成员变量
		
		m_b = 200;报错 
		//静态成员函数 不能访问 非静态成员变量
		//非静态成员变量的引用必须与 特定对象 相对
	}
};

静态成员函数也是有访问权限的，类外访问不到私有权限的静态成员函数

class Person
{
private:
	static void func2() //静态成员函数也是有访问权限的
	{
		cout << "static void func2调用" << endl;
	}
};

下面的代码会报错，因为类外访问不到私有权限的静态成员函数

void test01()
{
	Person::func2(); //类外访问不到私有权限的静态成员函数
}

---

3.静态成员变量（函数）两种访问方式

1. 通过对象

Person p1;
p1.m_a;
p1.func();

2. 通过类名

Person::m_a;
Person::func();

正是因为m_a和func()不属于某一个特定的对象，是共享的，因此不需要创建对象也可以访问。