c++类和对象---对象的初始化和清理

1、构造函数和析构函数

对象的初始化和清理是非常重要的安全问题

c++利用了构造函数和析构函数解决上述问题，这个函数编译器自动调用。如果程序员没有提供构造和析构函数，编译器会提供默认的构造和析构函数，都是空实现。

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

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

1. 构造函数，没有返回值也不写void
2. 函数名称和类名相同
3. 构造函数可以有参数，因此可以发送重载
4. 程序在调用对象时会自动调用构造函数，无需手动调用，且只调用一次

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

1. 析构函数，没有返回值也不写void
2. 函数名称和类名相同，并在前面加~
3. 不可以有参数，不能发生重载
4. 程序在对象销毁前自动调用析构函数，无需手动调用，且只调用一次

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

void test01()
{
	Person p;
}
int main()
{
	
	test01();
	Person p1;

	system("pause");
	return 0;
}

构造函数的调用
析构函数的调用
构造函数的调用
请按任意键继续. . .

前两条是调用test01时会自动调用构造函数和析构函数

第三条是main函数中运行时先调用构造函数，之后按任意键，结束main函数，此时自动调用析构函数，如下所示：

构造函数的调用
析构函数的调用
构造函数的调用
请按任意键继续. . .
析构函数的调用

2、构造函数的分类及调用

两种分类方式：

按参数分为：有参构造函数和无参构造函数

按类型分为：普通构造和拷贝构造

三种调用方式

括号法

显示法

隐式转换法

//构造函数的分类及调用
class Person
{
public:
	//构造函数
	//按参数分为：有参构造函数和无参构造函数
	Person()
	{
		cout << "无参构造函数的调用" << endl;
	}
	Person(int a)
	{
		age = a;
		cout << "有参构造函数的调用" << endl;
	}
	//按类型分为：普通构造和拷贝构造
	Person(const Person &p)
	{
		age = p.age;//将传入的人身上的属性拷贝过来
		cout << "拷贝构造函数的调用" << endl;
	}
	int age;

	//析构函数
	~Person() 
	{
		cout << "析构函数的调用" << endl;
	}
};
//构造函数的调用
void test01()
{
	//括号法
	Person p1;//默认构造函数的调用  注意调用默认构造函数不要加括号
	Person p2(10);//有参构造函数的调用
	Person p3(p2);//拷贝构造函数调用

	cout << "p2的年龄" << p2.age << endl;
	cout << "p3的年龄" << p3.age << endl;

	//显示法
	Person p4;
	Person p5 = Person(20);//有参构造调用
	Person p6 = Person(p5);//拷贝构造调用 
	cout << "p5的年龄" << p5.age << endl;
	cout << "p6的年龄" << p6.age << endl;

	Person(30);//匿名对象，特点：当前执行结束后，系统立马回收掉匿名对象
	//不要利用拷贝构造函数初始化匿名对象

	//隐式构造法
	Person p7 = 40;//有参构造调用
	Person p8 = p7;//拷贝构造调用
}
int main()
{
	
	test01();
	

	system("pause");
	return 0;
}

无参构造函数的调用
有参构造函数的调用
拷贝构造函数的调用
p2的年龄10
p3的年龄10
无参构造函数的调用
有参构造函数的调用
拷贝构造函数的调用
p5的年龄20
p6的年龄20
有参构造函数的调用
析构函数的调用
有参构造函数的调用
拷贝构造函数的调用
p7的年龄40
p8的年龄40
析构函数的调用
析构函数的调用
析构函数的调用
析构函数的调用
析构函数的调用
析构函数的调用
析构函数的调用
析构函数的调用
请按任意键继续. . .

3、拷贝构造函数的调用时机

c++中拷贝构造函数调用时间通常有三种情况

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

//拷贝构造函数的调用时机

class person
{
public:
	int m_age;
	person()
	{
		cout << "默认构造函数调用" << endl;
	}
	person(int age)
	{
		m_age = age;
		cout << "有参构造函数调用" << endl;
	}
	person(const person &p)
	{
		m_age = p.m_age;
		cout << "拷贝构造函数调用" << endl;
	}
};
//使用一个已经创建的完毕的对象来初始化一个新对象
void test01()
{
	person p1(20);
	person p2(p1);
}
//值传递的方式给函数参数传值
void doWork(person p)
{
	cout << "值传递" << endl;
}
void test02()
{
	person p;
	doWork(p);
}
//以值方式返回局部对象
person doWork1()
{
	person p3;
	return p3;

}
void test03()
{
	person p4 = doWork1();
}
int main()
{
	
	test01();
	

	system("pause");
	return 0;
}

4、构造函数的调用规则

默认情况下，c++编译器至少给一个类添加3个函数

1、默认构造函数（无参，函数体为空）

2、默认析构函数（无参，函数体为空）

3、默认拷贝构造函数，对属性值进行拷贝

构造函数调用规则如下：

• 如果用户定义有参构造函数，c++不在提供默认无参构造函数，但会提供默认拷贝构造函数
• 如果用户定义拷贝构造函数，c++不在提供其他构造函数

5、深拷贝和浅拷贝

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

！！！如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

using namespace std;

class person
{
public:
	int m_age;
	int *m_hight;
	person()
	{
		cout << "默认构造函数调用" << endl;
	}
	person(int age,int hight)
	{
		m_age = age;
		m_hight = new int(hight);
		cout << "有参构造函数调用" << endl;
	}
	person(const person &p)
	{
		m_age = p.m_age;
		m_hight = new int(*p.m_hight);
		cout << "拷贝构造函数调用" << endl;
	}
	
	~person()//将堆区的开辟的数据做释放操作
	{
		if (m_hight != NULL)
		{
			delete m_hight;
			m_hight = NULL;
		}
		cout << "析构构造函数调用" << endl;
	}
};

void test01()
{
	person p(18, 180);
	person p1(p);
	cout << "p1的年龄" << p1.m_age << endl;
	cout << "p1的身高" << *p1.m_hight << endl;
}

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

6、初始化列表

作用：c++提供了初始化列表语法，用来初始化属性

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

class person
{
public:
	int m_age;
	int m_hight;
	//传统初始化
	/*person(int age,int hight)
	{
		m_age = age;
		m_hight = hight;
		cout << "有参构造函数调用" << endl;
	}*/
	//初始化列表
	person(int age, int hight) :m_age(age), m_hight(hight)
	{

	}
	
	~person()//将堆区的开辟的数据做释放操作
	{
		
		cout << "析构构造函数调用" << endl;
	}
};

void test01()
{
	person p(18, 200);
	cout << "p的年龄" << p.m_age << endl;
	cout << "p的身高" << p.m_hight << endl;
	person p1(p);
	cout << "p1的年龄" << p1.m_age << endl;
	cout << "p1的身高" << p1.m_hight << endl;
}

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

7、类对象作为类成员

c++类中的成员可以是另一个类的对象，我们称该成员为对象成员

class phone
{
public:
	
	phone(string pname)
	{
		m_pname = pname;
	}
	string m_pname;
	~phone()
	{

	}
};

class person
{
public:
	string m_name;
	phone m_phone;
	

	person(string name, string pname): m_name(name), m_phone(pname)
	{
		cout << m_name << endl;
		cout << m_phone.m_pname << endl;
	
	}

	~person()
	{

		cout << "析构构造函数调用" << endl;
	}
	void playgame()
	{
		cout << m_name << "岁" << m_phone.m_pname << "手机" << endl;
	}
};

void test01()
{
	person p("liuHI","phone");
	p.playgame();

}

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

8、静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员

静态成员分为

• 静态成员变量

1. 所有对象共享同一份数据
2. 在编译阶段分配内存
3. 类内声明，类外初始化

class Person
{
	
public:

	static int m_A; //静态成员变量

	//静态成员变量特点：
	//1 在编译阶段分配内存
	//2 类内声明，类外初始化
	//3 所有对象共享同一份数据

private:
	static int m_B; //静态成员变量也是有访问权限的
};
int Person::m_A = 10;
int Person::m_B = 10;

void test01()
{
	//静态成员变量两种访问方式

	//1、通过对象
	Person p1;
	p1.m_A = 100;
	cout << "p1.m_A = " << p1.m_A << endl;

	Person p2;
	p2.m_A = 200;
	cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据
	cout << "p2.m_A = " << p2.m_A << endl;

	//2、通过类名
	cout << "m_A = " << Person::m_A << endl;


	//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}

int main() {

	test01();

	system("pause");

	return 0;
}

• 静态成员函数

1. 所有对象共用同一个函数
2. 静态成员函数只能访问静态成员变量

class person
{
public:
	string m_name;
	static void func()
	{
		m_A = 100;//可以访问类内静态成员变量
		//m_B = 200;//报错，不可以访问其他变量
		cout << "静态成员函数调用" << endl;
	}
	static int m_A;	//类内声明，类外初始化
	int m_B;
private:
	static void func2()
	{
		cout << "static void func2()调用" << endl;
	}
};

int person::m_A = 0;

void test01()
{
	//通过对象调用
	person p;
	p.func();
	//通过类名访问
	person::func();
	//person::func2();//类外不能访问私有静态成员函数
}

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

静态成员函数调用
静态成员函数调用
请按任意键继续. . .