C++对象与内存的探索

一. 内存的存储

C/C++编译的程序占用的内存分为：

1. 栈区（stack）： 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。比如Class a()，这个a就是在栈里的，超出变量的生存周期会自动释放。
2. 堆区（heap）：由程序员new，new出来的内存需要手动或编程delete掉，否则反复new会发生内存泄漏。进程结束后，系统会全部释放。
3. 全局区（static）：全局变量和静态变量的存储是放在一块的。
4. 文字常量区：常量字符串就是放在这里的，程序结束后由系统释放。
5. 程序代码区：存放函数体的二进制代码。

二. 对象的构造和析构

二.1 析构

class MyClass2
{
public:
	int* p;
	int val;
public:
	MyClass2() :val(1),p(new int(1)) {}
};

MyClass2* stack;
int* stackp;
void Func()
{
	auto mc1 = MyClass2();
	stack = &mc1;
	stackp = mc1.p;
}
void Func2() {}

int main()
{
	Func();
	Func2();
	int* p = stack->p;	//stack内的p已经变成野指针，但p曾经指向的空间并没有释放，因为stackp仍然存在
	return 0;
}

这里有坑，默认析构不会释放new出来的空间。
测试代码2

int main()
{
	auto* mc = new MyClass2();
	int* p = mc->p;
	delete(mc);
	Print(*p); 	//	即使mc已被释放，mc内的p变成野指针，但p指向的内存仍然存在
	return 0;
}

所以析构函数内一定要指定释放逻辑。

二.2 构造

C++的类的默认函数有6个

1. 无参构造函数
2. 拷贝构造函数
3. 赋值构造函数
4. 析构函数
5. 取地址运算
6. const取地址运算

移动构造函数 // 需要手动定义
移动赋值构造函数 // 需要手动定义

假设我们写了一个非常简单的类

class MyClass
{
private:
	int val;	// 栈变量
	int* p;		// 堆变量
public:
	MyClass():val(0),p(new int(0)){}
};

这个类实际上应该写成这样

class MyClass
{
private:
	int val;
	int* p;
public:
	MyClass(const int _val) :val(_val), p(new int(_val)) {}	// 自定义有参构造函数
public:
	MyClass() :val(0), p(new int(0)) {}	// 构造函数
	MyClass(const MyClass& mc)// 拷贝构造函数
		:val(mc.val),
		p(new int(*mc.p)) {}	// 深拷贝,p指向新分配的内存，但值两者一样
	MyClass& operator= (const MyClass& mc)	// 赋值构造函数
	{
		this->val = mc.val;
		//this->p = mc.p;	// 这是浅拷贝，两者指向同一个内存，编译器默认生成的是浅拷贝
		delete(this->p); this->p = new int(*mc.p);	// 深拷贝,p指向新分配的内存，但值两者一样
		return *this;
	}
	MyClass* operator&() { return this; }	// 取地址运算符，默认的就好
	const MyClass* operator&() const { return this; }	// const修饰的取地址运算符，第二个const表示函数不可修改类的成员变量
	~MyClass() { delete(p); }	// 析构函数，默认析构是不会释放new出来的空间的，需要手动定义
	MyClass(MyClass&& mc) noexcept :	// 移动构造函数
		val(mc.val), p(mc.p)	// &&表示右值引用，即用来赋值构造的临时变量
	{							// 移动构造函数发生在 左值 = 右值 的时候
		mc.p = nullptr;			// 左值在表达式结束后仍然存在，而右值是表达式结束后就不再存在的临时对象
	}
	MyClass& operator=(MyClass&& mc) noexcept	// 移动赋值构造函数
	{
		this->val = mc.val;
		delete(this->p);
		this->p = mc.p;
		mc.p = nullptr;
		return *this;
	}
};

下面是各个函数的调用时机：

class Solution
{
public:
	std::vector<MyClass> pool;
public:
	Solution() :pool() {}
	void Func1()
	{
		auto c1 = MyClass();	// 构造函数 编译器会将其优化为 MyClass c1; 否则就是构造函数 + 赋值构造函数
		MyClass(c1);	// 拷贝构造函数，生成了一个匿名临时对象
		auto c2 = c1;	// c2拷贝构造函数
		auto c3 = MyClass();	// c3构造函数
		c3 = c1;	// c3赋值构造函数
		auto* c4 = new MyClass();	// 分配在堆上的，构造函数
		pool.emplace_back(MyClass());	// 构造函数 + 移动构造函数 + 匿名临时变量的析构
		// c1,c2,c3析构，c4内存泄漏
	}
private:
	void Func2(MyClass mc)
	{
		
	}
};

int main()
{
	Solution s;
	s.Func1();
	return 0;
}

如何区别构造函数的类型？

一句话记住三者：对象不存在，且没用别的对象来初始化，就是调用了构造函数；
对象不存在，且用别的对象来初始化，就是拷贝构造函数
对象存在，用别的对象来给它赋值，就是赋值函数。
https://blog.csdn.net/zcyzsy/article/details/52132936

移动构造函数放到后面讲
以上代码运行在vs2019，其编译器对代码有自己的优化，但是如果是运行在没有优化的编译器上，问题就很大了，比如

demo get_demo()
{
    return demo();
}
int main(){
    demo a = get_demo();
    return 0;
}

引用http://c.biancheng.net/view/7847.html

可以看到，程序中定义了一个可返回 demo 对象的 get_demo() 函数，用于在 main() 主函数中初始化 a 对象，其整个初始化的流程包含以下几个阶段：
执行 get_demo() 函数内部的 demo() 语句，即调用 demo 类的默认构造函数生成一个匿名对象；
执行 return demo() 语句，会调用拷贝构造函数复制一份之前生成的匿名对象，并将其作为 get_demo() 函数的返回值（函数体执行完毕之前，匿名对象会被析构销毁）；
执行 a = get_demo() 语句，再调用一次拷贝构造函数，将之前拷贝得到的临时对象复制给 a（此行代码执行完毕，get_demo() 函数返回的对象会被析构）；
程序执行结束前，会自行调用 demo 类的析构函数销毁 a。

注意，目前多数编译器都会对程序中发生的拷贝操作进行优化，因此如果我们使用 VS 2017、codeblocks 等这些编译器运行此程序时，看到的往往是优化后的输出结果：
construct!
class destruct!
而同样的程序，如果在 Linux 上使用g++ demo.cpp -fno-elide-constructors命令运行（其中 demo.cpp 是程序文件的名称），就可以看到完整的输出结果：
construct! <-- 执行 demo()
copy construct! <-- 执行 return demo()
class destruct! <-- 销毁 demo() 产生的匿名对象
copy construct! <-- 执行 a = get_demo()
class destruct! <-- 销毁 get_demo() 返回的临时对象
class destruct! <-- 销毁 a

如上所示，利用拷贝构造函数实现对 a 对象的初始化，底层实际上进行了 2 次拷贝（而且是深拷贝）操作。当然，对于仅申请少量堆空间的临时对象来说，深拷贝的执行效率依旧可以接受，但如果临时对象中的指针成员申请了大量的堆空间，那么 2 次深拷贝操作势必会影响 a 对象初始化的执行效率。
事实上，此问题一直存留在以 C++ 98/03 标准编写的 C++ 程序中。由于临时变量的产生、销毁以及发生的拷贝操作本身就是很隐晦的（编译器对这些过程做了专门的优化），且并不会影响程序的正确性，因此很少进入程序员的视野。

那么当类中包含指针类型的成员变量，使用其它对象来初始化同类对象时，怎样才能避免深拷贝导致的效率问题呢？C++11 标准引入了解决方案，该标准中引入了右值引用的语法，借助它可以实现移动语义。

有的朋友可能就要问了，说🐴老师你这就不讲武德，这么复杂万一我不小心就多构造了一遍呢，难道每个类的构造函数都要这么手写吗？
C++提供了两个修饰符来方便程序员的编程。

三. default和delete修饰符

三.1 default

这些函数如果不手动定义的话，在需要调用的时候编译器都会自动生成一个默认函数，但也会面临如下的情况。

class Test
{
public:
	int val;
public:
	Test(const int _val) :val(_val) {}
};

int main()
{
	auto v = std::vector<Test>(1);
	// 错误，因为没有显式定义无参构造函数，调用不到
}

修改为如下即可编译通过

class Test
{
public:
	int val;
public:
	Test() = default;	// 显式声明默认无参构造函数，且默认无参构造比显式定义的无参构造效率更高
	Test(const int _val) :val(_val) {}
};

三.2 delete

有一些变量只需要存在一个，但在实际代码中一不小心可能就会多构造一遍，造成资源浪费，始终小心翼翼的会让自己很累，不如直接干脆禁用某些构造函数！
比如

class Camera
{
public:
	Camera() = default;
	Camera(const Camera& c) = delete;
	Camera& operator= (const Camera& c) = delete;
};

void Func1(Camera& c) {}
void Func2(Camera c) {}

int main()
{
	auto v = std::vector<Camera>(1);
	Func1(v[0]);
	Func2(v[0]);	// erro E1776 无法引用 函数 "Camera::Camera(const Camera &c)" (已声明 所在行数:9) -- 它是已删除的函数	
}

四. 移动语义和完美转发

四.1 右值和移动语义

可以做个小测试

	MyClass&& rvref = MyClass();  // 表示右值的引用，会延长右值的声明周期，将其变成左值
	MyClass* rv = &MyClass();	// 表示定义一个指针指向一个右值，这个右值会在定义执行后立即析构。

再看这段代码

	MyClass mc1(MyClass(1));	// 编译器会把这句优化成 MyClass mc1(1); 否则的话就是 有参构造函数 + 拷贝构造函数
	MyClass mc2(std::move(MyClass(2)));	// 调用有参构造函数 + 移动构造函数
	mc2 = mc1;	// 调用赋值构造函数

第一行被编译器自动优化过了，这是重点，否则很多像我一样的程序员就要踩屎。
这里的mc1，mc2都是左值，而MyClass(2)声明了一个匿名临时变量，代码执行完即析构，这是个右值。
我自己认为的左值和右值的定义就是，左值是持久的，定义出来可以在一定的生命周期内调用，而右值是即将衰亡的匿名变量。

左值 mc2 = MyClass(2); 右值

注意，初始化过的右值引用将会使该右值变成左值。

void Func(MyClass& _mc)  {}  // 函数1 左值重载
void Func(MyClass&& _mc) {}  // 函数2 右值重载
void Main()
{
	MyClass&& mcr = MyClass();	// mcr是初始化过的右值，因此mcr是个左值
	Func(mcr);`	// 调用函数1
	Func(std::move(mcr));	//调用函数2
}

配合std::move()移动语义可以将左值转成右值，返回一个匿名对象，他仅具有类型转换的功能，没有真正移动的功能。如果你用std::move()的返回值来初始化一个右值，那这个右值立刻会变成左值。
那么右值有什么用呢？
痛点就是，假如我需要把一个对象a的值转移到另一个对象b（假设b中指针都为空）中，有以下几种做法：

1. 将a中的值深拷贝到b中（拷贝构造函数），然后释放掉a ，但是这样a中原有的内存就显得多余了
2. 将a中的值浅拷贝到b中（拷贝构造函数），但是这样释放a也会释放b中的指针。
3. 将a中的值浅拷贝到b中（移动构造函数），再将a中的指针置为空指针，然后再释放a。
   这样避免了多余的内存申请

C++标准库中许多容器及时确实移动比复制高效，但是为了强异常安全保证，底层的复制操作只有在已知移动操作不会抛出异常的前提下才会使用移动操作将其替换。这会导致，只要对应的操作没有加上noexcept声明，编译器便不会调用移动操作，仍然是复制。
https://zhuanlan.zhihu.com/p/188722744

四.2 完美转发

写一段模版，表示将一个参数传入模版函数中，并将该参数作为模版韩式内对象实例化用的构造参数，并将实例化的对象返回。

class Solution
{
private:
	template<typename T>
	void Log(T&& t)
	{
		Print("这是右值类型");
	}
	template<typename T>
	void Log(T& t)
	{
		Print("这是引用类型");
	}
public:
	template <typename T, typename Arg>
	T* GetInstance(Arg&& arg)
	{
		Print("完美转发:"); Log(std::forward<Args>(arg));
		Print("非完美转发:"); Log(arg);
		Enter();
		T* t = new T(std::forward<Arg>(arg));
		return t;
	}
};

void main()
{
	Solution s = Solution();
	MyClass mc1 = MyClass(1);
	MyClass* mc2 = s.GetInstance<MyClass>(mc1);
	MyClass* mc3 = s.GetInstance<MyClass>(MyClass());
}

最后的输出是

看出区别了没：

1. 对于非完美转发来说，传入模版的参数MyClass()在main函数内为右值，而在模版函数内因为不再匿名而变成了左值，因此在Log函数处理时按左值的引用处理。
2. 对于完美转发，mc1为左值，那么在模版内仍为左值。
   MyClass()在main函数内为右值，在模版内使用std::forward<>()将其恢复成main函数内的右值身份，按右值处理。

//	这就相当于，当模版参数为右值MyClass()时，即代码MyClass* mc3 = s.GetInstance<MyClass>(MyClass());我调用
	MyClass temp;
	MyClass* mc3 = new MyClass(std::move(temp));
	delete(temp);
//	而不是
	MyClass temp;
	MyClass* mc3 = new MyClass(temp);

std::forward函数不会转发任何数据，他只是将对象转换成本来的样子。
至于为什么要转成右值，右值的好处在前面已经写过了。

五. 智能指针

大体有三个std::unique_ptr，std::shared_ptr和std::weak_ptr，这三个都是类，不是真正的指针！

名称	描述
std::unique_ptr	独一无二，不可拷贝分享，只能用移动语义，且只在智能指针对象的作用域内存活，超出时会自动释放。
std::shared_ptr	内部有一个引用计数器，保存指向该原始内存的指针对象数量。每析构一次，引用-1，变成0时释放内存
std::weak_ptr	无法像指针那样去调用，可以从shared_ptr和weak_ptr那里构造，内部包含一个引用计数，可以观测其他指针的引用情况

智能指针是个类的对象，不是指针，而且既然用了智能指针，就不要用智能指针的指针了，智能指针对象本身不需要new，画蛇添足还会破坏智能指针的管理逻辑，将智能指针的析构交给编译器就好。
测试代码

class MyClass2
{
public:
	int* p;
	int val;
public:
	MyClass2() :val(1),p(new int(1)) {}
};

MyClass2* stack;
MyClass2* New;
MyClass2* unique;
MyClass2* shared;
std::shared_ptr<MyClass2> sharedsp;
void Func()
{
	auto mc1 = MyClass2();	// 栈对象
	auto* mc2 = new MyClass2();	// new出来的对象
	auto mc3 = std::make_unique<MyClass2>();	// unique智能指针
	auto mc4 = std::make_shared<MyClass2>();	// shared智能指针

	// 以下分别是对应四个对象内存的四个全局指针和一个全局智能指针
	stack = &mc1;
	New = mc2;
	unique = mc3.get();
	shared = mc4.get();
	sharedsp = mc4;
}

int main()
{
	Func();
	Enter();  //此时，四个全局指针仅剩下New和shared还在，
	auto sharedsp2 = sharedsp;	// sharedsp的索引变成2
	sharedsp.reset();
	sharedsp2.reset();	// sharedsp的索引变成0
	// shared被释放
	return 0;
}

https://www.cnblogs.com/wxquare/p/4759020.html

六.转型

转型分为向上转型和向下转型。
父类指针指向子类为向上转型，子类指针指向父类为向下转型。
举例

class Human{};
class Father :public Human{}
class Son :public Father{};
class Daughter :public Father{};
int main()
{
	auto home = std::vector<std::shared_ptr<Human>>();
	home.emplace_back(std::make_shared<Son>());
	home.emplace_back(std::make_shared<Daughter>());
	return 0;
}

这都是支持的，后面从v中调取对象执行相应的虚函数时，调用的都是子类的方法，但是我们是用父类指针指向子类调用，这就是向上转型，这也是OOP思想的基础之一，这是自然的，无需显式说明的。
而向下转型是不自然的，需要强制类型转换。

为什么要向下转型？我不知道。可能如果有一个函数的形参是父类，而我知道这个形参是某个子类向上转型的结果，可能需要我手动向下转型一下，才能调用子类独有的某个方法，万一转错了。。。额我不知道。
https://www.cnblogs.com/s3320/p/11817110.html

测试代码

class Father {};
class Son :public Father
{
public:
	int* i;
	void Func() {}
	Son() :i(new int(1)) {}
};
class Daughter : public Father
{
public:
	float* f;
public:
	Daughter() :f(new float(2.0f)) {}
};
void Func(std::shared_ptr<Father> f)
{
	auto s = std::static_pointer_cast<Son>(f);
	s->Func();
	Print(*s->i);
}
int main()
{
	auto father = std::make_shared<Father>();
	auto son = std::make_shared<Son>();
	auto daughter = std::make_shared<Daughter>();
	Func(father);
	Func(son);
	Func(daughter);	//1073741824
	return 0;
}

这里声明了两个Father的子类对象son和daughter，其中儿子内的数据为int型(1)而女儿的数据为float(2.0)。

1. 第一次调用Func，直接传入形参，将father转为son，输出时报错，因为i是野指针，毕竟Father里根被没有int i，如果把i改为值类型则输出未初始化的整型值。
2. 在第二次调用Func中，先隐式调用向上转型，将son转为父类对象，作为形参传入，在Func中，将父类对象显式的向下转型为Son，输出int为1，这是正确的，转上去再转下来而已。
3. 在第三次调用Func中，先隐式的调用向上转型，将daughter转为Father，作为形参传入，在Func中，将父类对象显式的向下转型为Son，输出int i为1073741824，这是怎么回事呢？

打开内存查看器，son的int i在内存中的表示为00000001（16进制表示），daughter的float f在内存中表示为40000000（16进制表示），而int和float都占4个字节，因此在内存中，Son和Daughter的排布是一样的，而将Daughter转为Son的过程中，编译器会认为daughter内的40000000是个整型而不是浮点型，其值就是1073741824。
说白了转型就是拿个模子去内存里面套，顺着地址走，假装套进去的东西是某个类，然后把相应的值翻译过去。

七. 内存对齐

在DirectX中，传入着色器的常量缓冲区的数据是按字节流读的，用程序告诉显卡我的数据排布是int,float,float,float，再定义相应的数据传入显卡，那么数据传进去后显卡就会按照这个数据对字节进行翻译，然后填充到shader里定义的结构体数据中。

引用https://www.cnblogs.com/X-Jun/p/9376474.html#_lab2_0_0
若C++结构体和HLSL常量缓冲区如下：

// cpp
struct S1
{
    XMFLOAT3 p1;
    XMFLOAT3 p2;
};

// HLSL
cbuffer C1
{
    float4 v1;
    float4 v2;
}

则最终C1两个向量接收到的数据如下：
(p1.x, p1.y, p1.z, p2.x)
(p2.y, p2.z, empty, empty)

这就很麻烦，要小心两边定义是否有误差，还要尽量在声明数据格式的时候就让数据能做到16位对齐，所以可以这么写。

struct PointLightCBuf
	{
		alignas(16) DirectX::XMFLOAT3 pos;	// 表明这是 float float float 空float，把16位填起来
		alignas(16) DirectX::XMFLOAT3 ambient;
		alignas(16) DirectX::XMFLOAT3 diffuseColor;
		float diffuseIntensity;
		float attConst;
		float attLin;
		float attQuad;
	};

八. 有待补充

九. 其他参考

https://blog.csdn.net/zhc_futrue/article/details/79057592
https://zhuanlan.zhihu.com/p/54050093
https://www.ibm.com/developerworks/cn/aix/library/1307_lisl_c11/
https://en.cppreference.com/w/cpp/utility/move
https://zhuanlan.zhihu.com/p/188722744
https://www.cnblogs.com/wxquare/p/4759020.html
https://www.cnblogs.com/s3320/p/11817110.html