动态内存分配（二）

常见的动态内存错误

对NULL指针的解引用操作

eg:

#include<stdio.h>
int main()
{
	int* p = (int*)malloc(10000000000);
	int i = 0;
	for (i = 0;i < 10;i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

1.如果p的值是NULL，就会有问题
2.对malloc进行判空处理

对动态开辟空间的越界访问

eg:

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(10*sizeof(int));
	if (p == NULL)
	{
		perror("main");
		return 1;
	}
	int i = 0;

	for (i = 0;i < 40;i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

当i是10的时候越界访问

对非动态开辟内存使用free释放

eg:

int main()
{
	int arr[10] = { 0 };
	int* p = arr;
	free(p);
	p = NULL;
	return 0;
}

使用free对p进行非动态内存的释放
p是局部变量，是在栈上开辟的

使用free释放一块动态开辟内存的一部分

eg：

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("main");
		return 1;
	}
	int i = 0;
	for (i = 0;i < 5;i++)
	{
		*p++ = i;
	}
	free(p);
	p = NULL;
	return 0;
}

p不再指向动态内存的起始位置，而是从p+4的位置开始释放内存空间
而起始位置到p+4是没有被释放的，这样会产生内存泄漏的问题

对同一块动态内存多次释放

eg：

int main()
{
	int* p = (int*)malloc(sizeof(100));
	free(p);
	free(p);
	return 0;
}

避免对同一块动态内存多次释放可以用以下方法
将p进行释放后，手动将p置成空指针

int main()
{
	int* p = (int*)malloc(sizeof(100));
	free(p);
	p = NULL;
	free(p);
	return 0;
}

动态开辟内存忘记释放（内存泄漏）

eg：

void test()
{
	int* p = (int*)malloc(sizeof(100));
	if (p == NULL)
	{
		return;
	}
}
int main()
{
	test();
	return 0;
}

动态开辟的空间两种回收的方式：
1.主动用free释放并将该指针手动置为空
2.程序结束

经典的笔试题

eg1：该段代码出现的问题

void GetMemory(char *p) 
{
	p = (char *)malloc(100);
}
void Test(void) 
{
	char *str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

解析：
str传给GetMemory函数的时候是值传递，所以GetMemory函数的形参p是str的一份临时拷贝。
在GetMemory函数内部动态申请空间的地址，存放在p中，不会影响外边str，所以当GetMemory函数结束之后，str依然是NULL。所以strcpy会失败.
当GetMemory函数返回之后，形参p销毁，使得动态开辟的100个字节存在内存泄漏。无法释放。

修改一：

char* GetMemory(char* p)
{
	p = (char*)malloc(100);
	return p;
}
void Test(void)
{
	char* str = NULL;
	str=GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

修改二：

char* GetMemory(char** p)
{
	*p = (char*)malloc(100);
	return *p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory(&str);
	strcpy(str, "hello world");
	printf(str);
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

eg 2

char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main()
{
	Test();
	return 0;
}

解释：
GetMemory 函数内部创建的数组是在栈区上创建的出了函数，p数组的空间就还给了操作系统返回的地址是没有实际的意义，如果通过返回的地址，去访问内存就是非法访问内存的。
解决方法：
在堆上创建一块空间并赋给p，这样GetMemory 函数的返回地址赋给str，这样访问的内存是有效的。

eg3:说明以下代码出现的问题

例一：

int* f1(void)
{
	int x = 10;
	return &x;
}

解释：
fi函数内部创建的整形是在栈区上创建的出了函数，整形x的空间就还给了操作系统返回的地址是没有实际的意义，如果通过返回的地址，去访问内存就是非法访问内存的。

例二：

int* f2(void)
{
	int* ptr;
	*ptr = 10;
	return ptr;
}

解释：
f2函数内部创建的ptr指针未定义（初始化），造成野指针问题，接下来*ptr = 10;这步系统就会报错。
解决方法：
将ptr初始化或将ptr置成空指针

eg 4

void GetMemory(char** p, int num) 
{
	*p = (char*)malloc(num);
}
void Test(void) 
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

解释：
没有将释放str
解决方法：
释放str，将str置成空指针

修改：

void GetMemory(char** p, int num) 
{
	*p = (char*)malloc(num);
}
void Test(void) 
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

eg 5

void Test(void) 
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}
int main()
{
	Test();
	return 0;
}

解释：
在Test函数将str释放完之后，如果接下来没有将释放的指针置为空指针，那么将造成越界访问
解决方法：
将释放的指针立刻置为空指针

修改：

void Test(void) 
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	str = NULL;
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}
int main()
{
	Test();
	return 0;
}

C/C++程序的内存开辟

有了这幅图，我们可以更好的理解static关键字修饰局部变量了。
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁所以生命周期变长。

C / C++程序内存分配的几个区域：

1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈
   上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

柔性数组

定义

C99 中说到，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』。

例子：

struct S
{
	int n;
	int arr[];//大小未知
};

或

struct S
{
	int n;
	int arr[0];
};

注：
但在各种编译器中以上两种也许会支持其中一种另一种会报错。

柔性数组的特点：

结构中的柔性数组成员前面必须至少一个其他成员。
sizeof 返回的这种结构大小不包括柔性数组的内存。
包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

柔性数组的优势

例一：

struct S
{
	int n;
	int arr[0];
};
int main()
{
	struct S* ps =(struct S *)malloc(sizeof(struct S) + 10 * sizeof(int));
	ps->n = 10;
	int i = 0;
	for (i = 0;i < 10;i++)
	{
		ps->arr[i] = i;
	}
	struct S* ptr=(struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
	if (ptr != NULL)
	{
		ps = ptr;
	}
	free(ps);
	ps = NULL;
	return 0;
}

例二：

struct S
{
	int n;
	int *arr;
};
int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		return 1;
	}
	ps->n = 10;
	ps->arr = (int*)malloc(10 * sizeof(struct S));
	if (ps->arr == NULL)
	{
		return 1;
	}
	int i = 0;
	for (i = 0;i < 10;i++)
	{
		ps->arr[i] = i;
	}
	int* ptr = (int*)realloc(ps->arr, 20 * sizeof(int));
	if (ptr != NULL)
	{
		ps->arr = ptr;
	}
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;
	return 0;
}

上述 例一 和 例二 可以完成同样的功能，但是 例一 的实现有两个好处：
第一个好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速度.
连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）