C进阶动态内存管理-2

First Post:

Last Update:

经典笔试题

题目2：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
char *GetMemory(void)
{
	char p[] = "hello world";
	return p;
}

void Test(void)
{
	char *str = NULL;
	str = GetMemory();
	printf(str);
}

int main()
{
	Test();
	return 0;
}
//打印随机值

返回栈空间地址问题，非法访问内存野指针

题目3：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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;
}

改正:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//忘记释放动态开辟的内存，导致内存泄漏

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;
}
题目4：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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;
}

改正:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void Test(void)
{
	char *str = (char *)malloc(100);
	strcpy(str, "hello");
	free(str);//free释放str指向的空间后，并不会把str置为NULL
	str = NULL;

	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

int main()
{
	Test();
	return 0;
}

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

动态内存管理动态内存管理

💠数据段也称静态区

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

根据上图，理解static关键字修饰局部变量：

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

柔性数组（flexible array）

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

举🌰:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//常规写法
//struct S
//{
//	int n;
//	int arr[10];
//};

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

struct S
{
	int n;
	int arr[0];//未知大小的-柔性数组成员-数组的大小是可以调整的
};

柔性数组的特点

  • 结构中的柔性数组成员前面必须至少一个其他成员。
  • sizeof 返回的这种结构大小不包括柔性数组的内存。
  • 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
1
2
3
4
5
6
7
8
9
10
11
12
13
struct S
{
	int n;
	int arr[0];//未知大小的-柔性数组成员-数组的大小是可以调整的
};

int main()
{
	struct S s;
  //在包含柔性数组的结构体大小中,不计算柔性数组
	printf("%d\n",sizeof(s));//4
	return 0;
}

柔性数组的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
struct S
{
	int n;
	int arr[0];//未知大小的-柔性数组成员-数组的大小是可以调整的
};

int main()
{
	//struct S s;
	//printf("%d\n", sizeof(s));//
	struct S* ps = (struct S*)malloc(sizeof(struct S)+5*sizeof(int));
	ps->n = 100;

	int i = 0;
	for (i = 0; i < 5; i++)
	{
		ps->arr[i] = i;//0 1 2 3 4
	}
	struct S* ptr = realloc(ps, 44);
	if (ptr != NULL)
	{
		ps = ptr;
	}
	for (i = 5; i < 10; i++)
	{
		ps->arr[i] = i;
	}

	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}

	//释放
	free(ps);
	ps = NULL;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
//代码1
int main(){
	int i = 0;
	type_a *p = (type_a*)malloc(sizeof(type_a)+100 * sizeof(int));
	//业务处理
	p->i = 100;
	for (i = 0; i<100; i++)
	{
		p->a[i] = i;
	}
	free(p);
}

这样柔性数组成员a，相当于获得了100个整型元素的连续空间。

柔性数组的优势

上述的type_a 结构也可以设计为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
int main(){
	//代码2
	typedef struct st_type
	{
		int i;
		int *p_a;
	}type_a;
  
	type_a *p = malloc(sizeof(type_a));
	p->i = 100;
	p->p_a = (int *)malloc(p->i*sizeof(int));
  
	//业务处理
	for (i = 0; i < 100; i++)
	{
		p->p_a[i] = i;
	}
  
	//释放空间
	free(p->p_a);
	p->p_a = NULL;
	free(p);
	p = NULL;
}

上述 代码1 和 代码2 可以完成同样的功能，但是 方法1 的实现有两个好处。

第一个好处是：方便内存释放

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

第二个好处是：这样有利于访问速度

连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）

📖扩展阅读：

C语言结构体里的数组和指针

实战通讯录

源码地址: