14.C++之对象的初始化和清理

学习目标：

---

学习内容：

1.对象的初始化和清理

在C++中，每个对象也都会有初始设置以及 对象销毁前的清理数据的设置，今天介绍两种函数———构造函数和析构函数，来完成对象的初始化和清理。
构造函数:主要用于为对象的成员属性赋值，又编译器自动完成，无须手动调用。
析构函数：主要用于对象销毁前系统自动调用，并执行一些清理工作。

构造函数的语法： 类名（） {}

• 构造函数没有返回值（return），也不写void、int等数据类型；
• 函数名称和类名一致；
• 构造函数可以有参数，因此可重载；
• 程序在调用对象时会自动调用构造函数，无须手动调用，并且只会调用一次。

析构函数的语法： ~类名（） {}

• 析构函数没有返回值（return），也不写void、int等数据类型；
• 函数名称和类名一致，在类名前加上~；
• 构造函数不可以有参数，因此不能重载；
• 程序在对象销毁前会自动调用，无须手动调用，并且只会调用一次。

示例说明

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
	Person()
	{
		cout << "Person构造函数的调用" << endl;
	}
	~Person()
	{
		cout << "Person析构函数的调用" << endl;
	}
};
void test()
{
	Person p;//实例化调用构造函数
	//system("pause");
}
int main()
{
	test();
	system("pause");
	return 0;
}

当实例化之后还有其它的执行函数，则只会打印该实例化的构造函数

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
	Person()
	{
		cout << "Person构造函数的调用" << endl;
	}
	~Person()
	{
		cout << "Person析构函数的调用" << endl;
	}
};
int main()
{

	Person p;
	cout << "hello" << endl;
	system("pause");
	return 0;
}

2.构造函数的分类

分类方式：

• 按参数可分：有参构造和无参构造
• 按类型可分：普通构造和拷贝构造

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
	Person()
	{
		cout << "Person无参构造函数的调用" << endl;
	}

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

	Person(const Person& p)
	{
		cout << "Person 的拷贝构造函数调用" << endl;
	}
	~Person()
	{
		cout << "Person析构函数的调用" << endl;
	}
};
void test()
{
	Person p1;
	Person p(10);
	Person p2(p1);
}
int main()
{

	test();
	cout << "hello" << endl;
	system("pause");
	return 0;
}

有三个实例化，就会三个析构函数的调用

3.构造函数的调用规则

一般情况下，C++编辑器至少为一个类添加了3个函数“

• 默认的构造函数
• 默认的析构函数
• 默认的拷贝函数，对属性的值进行拷贝

构造函数的调用规则如下：
（1）若定义了有参构造，C++就不会提供无参构造函数，但是会提供默认的拷贝构造函数；
（2）若定义了拷贝构造，C++就不会提供其它的构造函数。

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
	Person()
	{
		cout << "Person无参构造函数的调用" << endl;
	}

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

	~Person()
	{
		cout << "Person析构函数的调用" << endl;
	}
	int m_Age;
};
void test01()
{
	Person p1(10);
	cout << "P1的年龄为：" << p1.m_Age << endl;
	Person p2(p1); //程序中自己有一个浅拷贝操作； 
	cout << "P2的年龄为：" << p2.m_Age << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

4.深拷贝和浅拷贝

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

//深拷贝
#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
	Person()
	{
		cout << "Person无参构造函数的调用" << endl;
	}

	Person(int age, int height)
	{
		cout << "Person有参构造函数的调用" << endl;
		m_Age = age;
		m_Height = new int(height);
	}

	~Person()
	{
		if (m_Height != NULL)
		{
			delete m_Height;
			m_Height = NULL;
		 }
		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);
	}
	int m_Age;
	int* m_Height;
};
void test01()
{
	Person p1(18,169);
	cout << "P1的年龄为：" << p1.m_Age << "身高为："<<*p1.m_Height<<endl;
	Person p2(p1); //程序中自己有一个浅拷贝操作； 
	cout << "P2的年龄为：" << p2.m_Age << "身高为：" << *p2.m_Height << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

使用new在堆区开辟新内存时，需要使用delete来释放空间，此时使用析构函数来释放。

进行判断之后，为了避免程序因为浅拷贝带来堆区内存重复释放而报错，需要自己实现拷贝构造函数。

5.初始化列表--用来初始化属性

5.1 传统的方法初始化属性

#include<iostream>
using namespace std;
class Person
{
public:
	Person(int a, int b, int c)
	{
		m_A = a;
		m_B = b;
		m_C = c;
	}

	int m_A;
	int m_B;
	int m_C;

};
void test()
{
	Person p(10, 20, 30);
	cout << p.m_A << endl;
	cout << p.m_B << endl;
	cout << p.m_C << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

5.2 初始化列表

语法：构造函数（）：属性1（值1），属性2（值2），……{}

#include<iostream>
using namespace std;
class Person
{
public:
	Person() :m_A(10), m_B(20), m_C(30)
	{         };
	int m_A;
	int m_B;
	int m_C;
};
void test()
{
	Person p;
	cout << p.m_A << endl;
	cout << p.m_B << endl;
	cout << p.m_C << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

使用更加灵活的方式

#include<iostream>
using namespace std;
class Person
{
public:
	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c)
	{};

	int m_A;
	int m_B;
	int m_C;

};
void test()
{
	Person p(10,20,30);
	cout << p.m_A << endl;
	cout << p.m_B << endl;
	cout << p.m_C << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

6.类对象作为类成员

C++中一个类的成员是另一个类的对象，我们称这个成员是对象成员，比如：

class A
{
};
class B
{
	A  a;
};

#include<iostream>
#include<string>
using namespace std;

class Phone
{
public:
	Phone(string PName) 
	{
		m_PName = PName;
		cout << "phone构造函数的调用！！" << endl;

	};
	string m_PName;
};
class Person
{
public:
	Person(string name, string phone) :m_Name(name),m_Phone(phone)
	{

	}
	string	m_Name;
	Phone m_Phone;

};
void test()
{
	Person p("张三", "Phone 8");
	cout << p.m_Name << "的手机为：" << p.m_Phone.m_PName << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

7.静态成员

静态成员是指在成员变量和成员函数前加上关键字static。

7.1 静态成员变量

静态成员变量的特点：

• 所有对象共享同一份数据；
• 在编译阶段就分配了内存；
• 在类内进行声明，在类外进行初始化；

#include<iostream>
using namespace std;
class Person
{
public:
	static int m_A;//类内声明
};

int Person::m_A = 100;//类外初始化
void test()
{
	Person p;
	cout << "初始化之后："<<p.m_A << endl;

	Person p2;
	p2.m_A = 200;
	cout <<"数值修改之后为：" << p.m_A << endl; //  当数值变化时，所有对象共享一份数据
}
int main()
{
	test();
	system("pause");
	return 0;
}

7.2 静态成员变量的调用

一般有两种调用方式：

• 通过对象调用；
• 通过类名来调用；

//静态成员变量有两种访问方式
#include<iostream>
using namespace std;
class Person
{
public:
	static int m_A;//类内声明
};

int Person::m_A = 100;//类外初始化
void test()
{
	//1.通过对象进行访问
	//Person p;
	//cout << p.m_A << endl;


	//2.通过类名进行访问
	cout << Person::m_A << endl;

}
int main()
{
	test();
	system("pause");
	return 0;
}

7.3 静态成员函数及调用

静态成员函数的特点：

• 所有对象都共享同一个函数；
• 静态成员函数只能访问静态成员变量；

//静态成员函数
#include<iostream>
using namespace std;
//所有对象共享同一个函数
//静态成员函数只能访问静态成员变量
class Person
{
public:
	static void func()
	{
		m_A = 100;//静态成员函数可以访问静态成员变量
		//m_B = 5;//直接报错，因为静态成员函数不可以访问非静态成员变量
		cout << "static void func的调用" << endl;
	}
	static int m_A;//静态变量
	int m_B;
};
int Person::m_A = 0;
void test()
{
	//1.通过对象来访问
	//Person p;
	//p.func();


	//2.通过类名来访问
	Person::func();

}
int main()
{
	test();
	system("pause");
	return 0;
}

---