C++学习笔记----6、内存管理（四）---- 通常的内存陷阱（1）

        使用new/delete/new[]/delete[]处理动态内存以及底层内存操作是非常容易出错的。对于引起内存有关的问题还特别难以定位。每一个内存泄露与错误指针都有其细微差别。没有能够解决内存问题的银弹。我们就来谈一谈一些通常问题以及能够检测和解决的一些工具。

1、少分配了数据空间与越界内存访问

        对于C风格的字符串来讲少分配了数据空间是一个常见的问题，当程序员对于结尾的'\0'这个哨兵字符没有多分配一个字节时就会产生。当程序员假定固定大小的字符串时少分配数据空间也会发生。基本的内建C风格字符串函数不会拥有固定大小--他们会很开心地将字符串结尾写到未知内存中。

        下面的代码演示了少分配内存空间。它从网络连接中读取数据并将其旋转到一个C风格的字符串中。通过循环来实现，因为网络连接在一定时间内只能接收一小部分的数据。在每个循环中，getMoreData()被调用，它返回一个指向动态分配的内存指针。当nullptr从getMoreData()中返回时，数据接收完毕。strcat()是一个将C风格字符串进行拼接的函数，它将第二个参数的字符串拼接到第一个参数的字符串的结尾。它期望的是结果缓存足够大。

	char buffer[1024]{ 0 }; // Allocate a whole bunch of memory.
	while (true) {
		char* nextChunk{ getMoreData() };
		if (nextChunk == nullptr) {
			break;
		}
		else {
			strcat(buffer, nextChunk); // BUG! No guarantees against buffer overrun!
			delete[] nextChunk;
		}
	}

        对于这个例子有三种可能的解决方案。按照优劣，叙述如下：

1. 使用C++风格的客，代替自己处理连接有关的内存问题。
2. 不要使用全局变量来分配空间或者是在栈上分配空间，在自由内存空间上进行分配。在剩余空间不足时，分配一个新的足够大到能放下至少当前内容加上新的内容的缓存空间，将原来的缓存拷贝到新的缓存，加上新的内容，删除原有的缓存。
3. 生成一个能够放下最大数量（包括'\0'字符）的getMoreData()的版本，返回值不会大于其空间；跟踪剩余空间，以及在缓存中的当前位置。

        少分配数据空间通常会导致内存越界。例如，如果你用数据填充缓存，当你认为缓存大于实际需要的空间时，就会开始向分配数据空间之外写数据。将重要内存进行覆盖，进而导致程序崩溃只是时间问题。在你的程序中当与对象相关的内存突然被覆盖了，考虑一下会发生什么。这不够漂亮吧！

        当处理C风格的字符串时，不管出于什么原因丢掉了'\0'结束符时也会发生内存越界。例如，在下面的函数中如果不合适的结束符字符串传进来，它就会将带有'm'的字符串填进来，很开心地将'm'字符串后面的内存内容继续进行填充，覆盖掉字符串边界之外的内存。

	void fillWithM(char* text)
	{
		int i{ 0 };
		while (text[i] != '\0') {
			text[i] = 'm';
			++i;
		}
	}

        将数组结尾之外的内存写入导致的问题通常路段缓存溢出错误。这些问题会被一些像病毒与蛀虫这样的高级不良程序所利用。邪恶的骇客会利用这种能力来覆写内存部分将代码注入运行中的程序。

        避免使用旧的C风格的字符串和数组，它们没有保护。要使用像C++ string与vector这样的自己管理内存的安全构造函数。

2、内存渗露

        在现代C++中，已经没有内存渗露。所有的内存管理都被高阶类来处理，比如std::vector，string等等。只有你不走正路，执行手动内存分配与释放都会导致内存渗露。

        发现并修改这样的内存渗露会非常令人脑仁疼。你的程序最终会运行，也会给出正确的结果。然后呢，你开始注意到你的程序会在运行时大量地不断地吃内存。那么来说，你的程序出现了内存渗露。

        内存渗露发生在当你分配了内存但却忽视了对其的释放。一开始，这听起来好像是可以很容易避免的编程粗心的结果。毕竟，如果每一个new有一个对应的delete在每一个你写的类中，那就没有内存渗露了，对吗？实际上，这并不总是正确。例如，在下面的代码中，Simple类正确地将其分配的内存进行了释放。然而，当doSomething()被调用时，OutSimplePtr指针被换成了另一个Simple对象而没有删除旧的，这展示了一个内存渗露。一旦你丢掉了对象的指针，就不可能再去删除它。

import std;
using namespace std;

class Simple
{
public:
	Simple() { m_intPtr = new int{}; }
	~Simple() { delete m_intPtr; }
	void setValue(int value) { *m_intPtr = value; }
private:
	int* m_intPtr;
};

void doSomething(Simple*& outSimplePtr)
{
	outSimplePtr = new Simple();
}

int main()
{
	Simple* simplePtr{ new Simple{} };
	doSomething(simplePtr);
	delete simplePtr;

	return 0;
}

        千万要记住这段代码只是出于演示的目的！在有生产质量的代码中，m_intPtr与simplePtr都不应该是原始指针，都应该是我们以后要讨论的智能指针。

        一旦碰到如示例中的情况，在程序员之间的无效沟通或者是代码的糟糕文档都会导致内存渗露的上升。对于doSomething()的调用者而言，它可能没有意识到用引用调用的变量没道理会导致指针被重定向。如果他们注意到参数是一个非常量引用的指针，他们可能会怀疑有奇奇怪怪的事情发生，但是在doSomething()周围没有对这种行为的解释的注释。