3，this指针、深拷贝浅拷贝、namespace的使用

3.1this指针

定义：当前类指向自己地址的常量指针
指针被const修饰，指针指向的内容不能修改

this指针-》类 对象 占不占用大小？

this指针不占用类的大小，因为是编译器去传递的

this指针-》地址 地址里面放的是什么？

存放的是对象的首地址

静态的 非静态的 静态的成员函数没办法操作this？为什么？

静态函数没办法操作this指针，因为静态成员函数是先于对象存在的，是所有对象共有的，没有this指针

为什么要设计this的存在？

看书c++对象模型 （会了解类的大小类的设计）

#include<iostream>
using namespace std;
class Student
{
public:
	int getAge()
	{
		return age;
	}
	Student setAge(int age)
	{
		this->age = age;
		cout << "age:" << age << endl;
		return *this;
	}
	void test()//this指针地址里面存放的是什么？
	{
		cout << "this指针里面存放的地址是什么：" << this << endl;
		cout << "实例对象的地址为：" << &age << endl;
	}
	static void lazy()
	{
		cout << "i want to sleep" << endl;
		//cout << this->age << endl;//会报错
	}
private:
	int age;
};

int main()
{
	Student s;
	s = s.setAge(18);
	cout << s.getAge() << endl;
	//this指针占不占用类的大小
	cout << sizeof(Student) << endl;
	//输出结果：4
	//this指针不占用类的大小

	//this指针地址里面存放的是什么？
	s.test();
	//输出结果：
	//this指针里面存放的地址是什么：004FF95C
    //实例对象的地址为：004FF95C
	//存放的是对象的首地址

	//此时没有对象 this-》实例化对象首地址
	Student::lazy();
	//静态成员函数是先于对象存在的
	s.lazy();

	system("pause");
	return 0;
}

3.2深拷贝和浅拷贝

浅拷贝：
简单的赋值拷贝操作（编译器提供的拷贝构造函数都是浅拷贝）
浅拷贝指的是仅复制对象的指针或引用，而不复制实际数据。换句话说，两个对象共享同一块内存。当其中一个对象修改了共享数据时，另一个对象也会受到影响。在进行浅拷贝时，只是简单地进行地址的复制，而没有创建新的对象。

深拷贝：
在堆区重新申请空间，进行拷贝操作
深拷贝指的是创建一个新的对象，并复制原始对象的所有数据，包括数据本身和指向的数据。也就是说，两个对象拥有各自独立的内存空间，互不影响。在进行深拷贝时，会递归地复制对象的成员变量，确保每个对象都有自己的拷贝。

#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)//Person p1(18,160);和Person p2(p1);释放实在析构前释放，所以写在析构内
		{
			delete m_Height;
			m_Height = NULL;//防止野指针出现，置空操作
		}
		cout << "Person析构函数调用" << endl;
	}
	int m_Age;
	int* m_Height;//指针指向身高（为了开辟到堆区所以用指针）
};
void test01()
{
	Person p1(18,160);
	cout << "p1的年龄为：" << p1.m_Age << "身高为：" << *p1.m_Height << endl;
	Person p2(p1);
	cout << "p2的年龄为：" << p2.m_Age << "身高为：" << *p2.m_Height << endl;
	//利用编译器提供的拷贝函数，会做浅拷贝
	// p1储存的身高int*m_Height为地址，数值160在堆区中，传递给p2的也是地址
	//浅拷贝中，释放顺序是先进后出，p2先被释放，之后是p1，但是p2已经释放过堆区了，所以堆区被重复释放
	//所以浅拷贝带来的问题就是堆区的内存重复释放（非法操作）
	//解决的办法：浅拷贝的问题要利用深拷贝解决
	// 自己实现拷贝构造函数，解决浅拷贝带来的问题
	//重新在堆区申请一块内存，让p2的int*m_Height指向新在堆区申请的内存（地址不同了）
}
int main()
{
	test01();
	system("pause");
	return 0;
}

3.3namespace的使用

通过namespace命名空间区别要省的代码、函数、类
namespace 是一种用来管理命名空间的关键字。命名空间提供了一种将全局作用域划分为不同的命名区域的机制，用于避免命名冲突和提供更好的代码组织。
使用被namespace管理类、函数等时需要在前加上命名空间关键字，如下图代码中的AsetHello::

#include<iostream>
using namespace std;
namespace AsetHello//可以在命名空间内写函数、定义类、枚举
{
	enum EHello
	{
		Hello_A,
		Hello_B,
	};
	struct FAsetHello
	{
		void Init() {}
		void Hello() {}
	};
	class IInterface
	{

	};
	class FHello:public IInterface
	{

	};
	FHello* GetHello();
}

void HelloTest() {}

namespace AsetHello
{
	FHello* GetHello()
	{
		return NULL;
	}
}

namespace AsetHello
{
	class IInterface2
	{

	};
}

namespace AsetHello//写几个namespace都行
{
	class IInterface3
	{

	};
}
int main()
{
	//namespace的调用、调用枚举
	AsetHello::EHello o = AsetHello::EHello::Hello_A;//想要省去AsetHello需要在全局函数写using namepace AsetHello;
	AsetHello::EHello o1 = AsetHello::Hello_A;//和上面写法不同，表达的意思相同
	//调用指针
	AsetHello::FHello* p = new AsetHello::FHello();
	//调用函数
	AsetHello::GetHello();

	::HelloTest;
	system("pause");
	return 0;
}