2021.8.3~8.4---1/7、2/7---类和对象之封装、对象的初始化和清理

一、封装

1.封装的意义

2.struct和class区别

3.成员属性设置为私有

二、对象的初始化和清理

1.构造函数好析构函数

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

#include<iostream>
using namespace std;

//按参数分类 无参构造（默认构造）和 有参构造
//按类型分类 普通构造 和 拷贝构造
class Person
{
public:
	普通构造函数
	//无参构造函数
	Person()
	{
		cout << "Person的无参构造函数调用" << endl;
	}
	//有参构造函数
	Person(int a)
	{
		age = a;
		cout << "Person的有参构造函数调用" << endl;
	}


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


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


	int age;
};

//调用
void test01()
{
	//以下三选一

	//1.括号法，常用
	Person p1;//无参构造函数调用//注意事项：不要加()
	Person p2(10);//有参构造函数调用
	Person p3(p2);//拷贝构造函数调用

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

	//2.显示法
	/*
	Person p1;
	Person p2 = Person(10);//有参构造
	Person p3 = Person(p2);//拷贝构造

	//注意事项1：
	Person(10);//匿名对象  特点：当前行执行结束后，系统会立即回收掉匿名对象
	cout << "hhhhhhhh" << endl;
	//注意事项2：
	//Person(p3);
	//不要利用拷贝构造函数初始化匿名对象，编译器会认为 Person(p3) === Person p3,对象重名
	*/


	//3.隐式转换法
	/*
	Person p4 = 10;//相当于写了 Person p4 = Person(10);//有参构造
	Person p5 = p4;//拷贝构造
	*/
}

int main()
{
	test01();
	return 0;
}

3.拷贝构造函数调用时机

4.构造函数调用规则

5.深拷贝与浅拷贝

#include<iostream>
using namespace std;

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

	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);

	}

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

	int m_Age;
	int* m_Height;
};

void test01()
{
	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;

}
int main()
{
	test01();
	return 0;
}

6.初始化列表

7.类对象作为类成员

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

//手机类
class Phone
{
public:
	Phone(string pName)
	{
		cout << "Phone的构造函数调用" << endl;
		m_PName = pName;
	}

	~Phone()
	{
		cout << "Phone的析构函数调用" << endl;
	}
	
	//手机品牌名称
	string m_PName;
};

//人类
class Person
{
public:
	Person(string name, string pName) :m_Name(name), m_Phone(pName)
	{
		cout << "Person的构造函数调用" << endl;
	}

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

	//姓名
	string m_Name;
	Phone m_Phone;
};

//当其他类成员作为本类成员，构造时候先构造类对象，再构造自身
//析构的顺序：与构造相反
void test01()
{
	Person p("张三", "华为");

	cout << p.m_Name << "拿着" << p.m_Phone.m_PName << endl;
}

int main()
{
	test01();
	return 0;
}

8.静态成员

静态成员变量

#include<iostream>
using namespace std;

class Person
{
public:
	//1.所有对象都共享同一份数据
	//2.编译阶段就分配内存
	//3.类内声明，类外初始化操作
	static int m_A;
private:
	static int m_B;

};

int Person::m_A = 100;
//int Person::m_B = 200;//类外访问不到私有静态成员变量

void test01()
{
	Person p;
	cout << p.m_A << endl;

	Person p2;
	p2.m_A = 200;
	cout << p2.m_A << endl;
}

void test02()
{
	//静态成员变量 不属于某个对象上，所有对象都共享同一份数据
	//因此静态成员变量有两种访问方式

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

}

int main()
{
	//test01();
	test02();
	return 0;
}

静态成员函数

#include<iostream>
using namespace std;

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

class Person
{
public:
	//静态成员函数
	static void func()
	{
		m_A = 100;//静态成员函数 可以访问 静态成员变量
		//m_B = 100;//静态成员函数 不可以访问 非静态成员变量//因为无法区分到底是哪个对象的m_B属性
		cout << "static void func调用" << endl;
	}

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

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

int Person::m_A = 0;

//有两种访问方式
void test01()
{
	//1.通过对象访问
	Person p;
	p.func();

	//2.通过类名访问
	Person::func();
	//Person::func2();//类外访问不到私有静态成员函数
}


int main()
{
	test01();
	return 0;
}