[C++知识库]类和对象（封装/class/struct）/构造函数/析构函数/深拷贝/浅拷贝

封装/继承/多态

封装

属性和行为作为一个整体，表现生活中的事物；

将属性和行为加以权限控制；

封装

#include <iostream>
using namespace std;
class Circle
{
public:
	int m_r;
	double PI = 3.14;
	double Circlezc()
	{
		return 2 * PI * m_r;
	}
};

int main()
{
	Circle c1;
	c1.m_r = 10;
	cout << "周长 = " << c1.Circlezc() << endl;
	return 0;
}

访问权限

public 公共

protected 保护 类外不可以访问

private 私有 类外不可以访问

class/struct区别默认访问权限不同

class->private

struct->public

构造函数/析构函数

构造函数可以有参数，因此可以发生重载，析构函数不可以有参数因此不会发生重载。

拷贝构造函数的使用

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

值传递方式给函数参数传值

以值的方式返回局部对象

#include <iostream>
using namespace std;
class MyClass
{
public:
	//构造函数
	MyClass();
	//有参构造函数
	MyClass(int a);
	//拷贝构造函数
	MyClass(const MyClass &mc);
	//析构函数
	~MyClass();
	void fun();

private:
	int num;

};

MyClass::MyClass()
{
	cout << "构造函数" << endl;
}
MyClass::MyClass(int a)
{
	num = a;
	cout << "有参构造函数" << endl;
}
MyClass::MyClass(const MyClass& mc)
{
	num = mc.num;
	cout << "拷贝构造函数" << endl;
}
void MyClass::fun()
{
	cout << "num = " << num << endl;
}

MyClass::~MyClass()
{
	cout << "析构函数" << endl;
}

void fun1(MyClass mc) {
	cout << "fun1()" << endl;
}

MyClass func() {
	cout << "func()" << endl;
	MyClass mc1(50);
	return mc1;
}
void test01()
{
	MyClass *mc1 = new MyClass(10);
	mc1->fun();
	MyClass* mc2 = new MyClass(*mc1);
	mc2->fun();
	//匿名对象
	MyClass(10);
	//不要用拷贝构造函数 初始化匿名对象 编译器会认为MyClass(mc1) == MyClass mc1；
	//MyClass(mc1);
	//显示法调用
	MyClass mc3 = MyClass(10);
	//隐式法调用
	MyClass mc4 = 10;
	//括号法
	MyClass mc5(10);
	//值传递方式给函数参数传值
	MyClass mc;
	fun1(mc);
	//以值的方式返回局部对象
	MyClass mc6 = func();
	mc6.fun();
}
int main()
{
	test01();
	return 0;
}

c++中只要创建一个class 就会默认创建 一个构造函数一个析构函数一个拷贝函数。

如果用户定义了有参构造函数，会删除默认无参构造函数，但是会保留默认拷贝函数；

如果用户定义了拷贝函数，其他默认构造函数都会被干掉。

浅拷贝和深拷贝

浅拷贝就是简单的 = 等号赋值操作；

深拷贝是new开配空间赋值的操作；

如果利用编译器提供的拷贝构造函数，会做浅拷贝操作（其实就是原封不动的拷贝 到新的内存空间? 这时候如果拷贝的是 指针类型? 那么 拷贝原和 拷贝先 其实是指向同一块堆中的内存空间 这时候释放 就会重复释放一块空间 即使加了非空判断 因为判断的是栈里的内存存储情况 而不是 堆中的内存存储情况 解决办法就是 自己写一个拷贝构造函数 其内new 一块空间 再赋值 这个过程叫深拷贝）

#include <iostream>
using namespace std;
class person
{
public:
	int m_Age;
	int* m_Height;
	person();
	person(const person &p);
	person(int age, int height);
	~person();

private:

};

person::person()
{
	cout << "构造函数" << endl;
}

person::person(int age,int height)
{
	m_Age = age;
	m_Height = new int(height);
	cout << "有参构造函数" << endl;
}
person::person(const person& p)
{
	m_Age = p.m_Age;
	m_Height = new int(*p.m_Height);
	cout << "拷贝构造函数" << endl;
}

person::~person()
{
	//堆区开辟的空间作释放操作
	if (m_Height != NULL)
	{
		delete m_Height;
		m_Height = NULL;
	}
	cout << "析构函数" << endl;
}
void test01()
{
	person p1(18,180);
	cout << "p1的年龄 = " << p1.m_Age << endl;
	cout << "p1的身高 = " << *p1.m_Height << endl;
	person p2(p1);
	cout << "p2的年龄 = " << p2.m_Age << endl;
	cout << "p2的身高 = " << *p2.m_Height << endl;
}
int main()
{
	test01();
	return 0;
}