【动态内存管理】malloc&calloc和realloc和笔试题和柔性数组

目录

0 为什么存在动态内存管理？

1 malloc函数

2  calloc函数

 3 realloc函数

5 2道经典的笔试题：

---

0 为什么存在动态内存管理？

char str[20]={0];
int arr[20]={0};

上述的空间开辟的方式有两个特点：

1. 空间开辟空间的大小是固定的
2. 数组在申明的时候必须指定数组空间的大小，它在编译时分配所需要的内存

但是如果我们所需要的空间大小在程序编译时并不确定，而是到程序运行起来的时候才能知道，那上述的空间开辟的方式就不适合了，动态内存管理就应运而生。

定义局部变量开辟的内存和动态内存开辟的内存的区别：

• 开辟空间的位置:
• 定义局部变量开辟的空间:栈上随机位置
• 动态申请的空间: 堆上连续位置
• 释放：
• 定义局部变量开辟的空间：出代码块自动销毁
• 动态申请的空间：最好是程序员手动释放

1 malloc函数

函数原型:void* malloc(size_t size)

参数说明:size为要分配内存空间的大小，单位是字节

#include<stdio.h>
#include<stdlib.h>
#include<limits.h>
int main()
{
    //函数原型:void* malloc(size_t size)
	//向内存申请了40个字节的空间：
	//如果申请成功返回这块空间的首地址
	//如果申请失败返回空指针NULL
	int* p1 = (int*)malloc(40);//这个开辟成功
	int* p2 = (int*)malloc(INT_MAX+1);//这个开辟失败
	//后面使用这块空间时会改变p的指向，所以用ptr保留这块空间的起始地址
	int* ptr = p1;
	//检验指针p的有效性：检测内存申请结果的返回值是否为NULL
	if (p· == NULL)
	{
		perror("malloc");//malloc: Not enough space
		exit(-1);
	}
	//开辟了40个字节，也就是10个int类型变量的大小
	for (int i = 0; i < 10; i++)
	{
		*(p·++) = 0;
	}
	//释放ptr指针所指向的那块空间，但是ptr仍然保留着动态申请的那块空间的起始地址
	free(ptr);
	//让ptr指向空，使他失去对动态申请的那块空间的起始地址的记忆
	ptr = NULL;

    p=NULL;
	return 0；
}

当我们不手动释放动态内存开辟的空间：

• 如果程序结束，动态申请的内存由OS自动回收
• 但是如果程序始终不结束，动态内存申请的那块空间不会自动释放，就会造成内存泄漏问题。 (程序结束肯定会自动释放动态申请的内存，不然内存肯定会越写越少，谁还敢写代码；但是当这块空间占用的时间太长，而且这块空间开辟的比较大，就会比较吃内存）

2  calloc函数

函数原型:void* calloc(size_t num,size_t  size)

参数说明：num是要分配size字节大小的空间的元素个数

 malloc 和  calloc 的区别： calloc在申请内存空间的同时将这块空间初始化为0了

int main()
{
	//函数原型: void* calloc(size_t num,size_t size)
    //元素个数:10
    //每个元素所占的字节数:sizeof(int)
	int* p = (int*)calloc(10, sizeof(int));
	int* ptr = p;
	if (p == NULL)
	{
		perror("calloc");
		exit(-1);
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d\t", *(p++));
	}
	free(ptr);
	ptr = NULL;
	p = NULL;
}

 3 realloc函数

有了realloc函数，我们就可以已经malloc或calloc开辟好且对容量不满意的空间进行重新调整。（调整:调大调小均可）

重新分配内存空间函数:void* realloc(void* ptr,size_t size)

参数说明:ptr为指向那块需要重新分配内存空间的那块空间，size为需要重新分配的空间大小，单位是字节。

下面以扩容为例：

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	for (int i = 0; i < 10; i++)
	{
		*(p + i) = i;//p没有改变指向
	}
	//希望放20个元素，空间不够，考虑用realloc扩容
	int p = (int*)realloc(p, 80);//error，万一realloc扩容失败，p接收到的是空指针，把原来p的指向覆盖（弄丢）了

	//函数原型:void* realloc(void* ptr,size_t size)
	//ptr:一个指针，指针指向的是扩容的空间的起始地址
	//size:扩容成功后希望得到的字节数
	int* temp = (int*)realloc(p, 80);//bingo
	if (temp != NULL)
	{
		p = temp;
	}
	free(p);
	p = NULL;

	return 0;
}

 realloc调整空间：

1. 如果要缩小空间:则在原空间上截取相应长度的空间，并返回原的首地址（也就是等于p）
2. 如果是扩大空间，分以下3种情况：

• 如果原空间在内存中的位置能够开辟出扩容后的所需要的空间大小，就相应开辟，并返回新空间的起始地址。
• 如果原空间在内存中的位置不能够开辟出扩容后所需要的空间大小，OS就会在堆内存中找一块足够容纳所需空间大小的一块新空间，将原空间里的值复制到新空间，并返回新空间的起始地址
• 如果在堆内存中的任意位置都不够开辟所需要的内存空间大小，则返回空指针。

4 常见的动态内存错误

	int main()
	{
		//way1:对NULL指针进行解引用
		int* p = (int*)malloc(INT_MAX + 1);
		//直接使用//error

		//way2:越界访问
		int* p = (int*)malloc(40);
		if (p == NULL)
		{
			perror("malloc");
			exit(-1);
		}
		for (int i = 0; i < 11; i++)//error
		{
			*(p + i) = i;
		}

		//way3:使用free函数释放非动态申请的内存
		int a = 10;
		int* p = &a;
		free(p);//error
		p = NULL;


		//way4:使用free函数释放动态申请的内存的一部分
		int* p = (int*)malloc(40);
		if (p == NULL)
		{
			perror("malloc");
			exit(-1);
		}
		for (int i = 0; i < 11; i++)//error
		{
			*p = i;
			p++;
		}
		free(p);//error
		p = NULL;

		//way5:对同一块动态申请的内存多次释放
		free(p);
		free(p);
		p = NULL;


	   //way6:忘记释放动态申请的内存


		return 0;
	}

5 2道经典的笔试题：

笔试题1：下面代码能打印出hello world吗？------>传值和传址

//错误代码:
void Getmory(char* p)
{
	p = (char*)malloc(100);
}

void test(void)
{
	char* str = NULL;
	Getmory(str);
	strcpy(str, "hello world");
	printf(str);
}

int main()
{
	test();
	return 0;

}

 答案：不能，按照代码本意：想通过Getmory函数给str动态开辟一段100个字节的空间，然后使用strcpy函数拷贝字符串‘hello world’并打印出来。

问题在于：Getmory函数的函数参数只是字符指针str的一份临时拷贝，形参的改变p不影响实参str，而且这样的话，p指向的那段空间在p所在的代码块内都没有得到释放，出Getmory函数代码块后，局部变量p被销毁，这段动态申请的空间也就没有得到销毁，也无法再销毁。

另外，连锁反应，str还是指向空，strcpy函数执行的时候由于源空间不够容纳"hello world“

，就会出现第二个问题。

正确代码：

//正确代码:
void Getmory(char** p)
{
	*p = (char*)malloc(100);
}

void test(void)
{
	char* str = NULL;
	Getmory(&str);
	strcpy(str, "hello world");
	printf(str);
}

int main()
{
	test();
	return 0;

}

 

笔试题2：下面的代码能打印出"hello world“吗”-------->“返回栈空间地址问题”

//错误代码:
char* Getmory(void)
{
	char p[] = "hello world";
	return p;
}

void test()
{
	char* str = NULL;
	str = Getmory();
	printf(str);
}

int main()
{
	test();

	return 0;
}

答案：不能，Getmory函数中，"hello world”被放在了一个字符数组里，返回时返回的是数组名，也就是这个数组首元素的地址，Getmory函数结束时字符数组所占用的空间自动销毁，但是返回了栈空间的地址，一旦在test函数内对这地址解引用进行访问，那就是非法的，未知的，上述代码的错误原因和下述代码的错误类似。

//错误代码
int* test()
{
	int a = 10;
	return &a;
}

int main()
{
	int* p=test();
	*p = 10;
	printf("%d\n", *p);
	printf("%d\n", *p);
	return 0;

}

6  柔性数组

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

struct s
{
	int num;
	double e;
	int arr[0];
	//或int arr[0];
};

柔性数组的特点：

1. 结构体中柔性数组成员前必须包含至少一个其他非柔性数组成员。
2. 包含柔型数组的结构体的内存大小不包含柔型数组的内存大小。
3. 包含柔性数组的结构体在开辟内存时得使用malloc函数动态内存开辟，且开辟的空间大小必须大于结构体的大小，以适应柔型数组的预期大小。

struct s
{
	int num;
	int arr[0];
	//或int arr[0];
};

int main()
{
	printf("sizeof(struct s):>%d\n", sizeof(struct s));
	struct s* ps = (struct s*)malloc(sizeof(struct s) + 40);

	ps->num = 100;
	for (int i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}

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

struct s
{
	int num;
	int arr[0];
	//或int arr[0];
};

int main()
{
	printf("sizeof(struct s):>%d\n", sizeof(struct s));
	struct s* ps = (struct s*)malloc(sizeof(struct s) + 40);
	if (ps == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	ps->num = 100;
	for (int i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}

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

	//柔性数组的柔性含义：可以realloc扩容
	struct s* temp = (struct s*)realloc(ps, sizeof(struct s) + 80);
	if (temp != NULL)
	{
		ps = temp;
	}

	for (int i = 0; i < 20; i++)
	{
		ps->arr[i] = i;
	}
	for (int i = 0; i < 20; i++)
	{
		printf("%d\t", ps->arr[i]);
	}
	free(ps);
	ps = NULL;
	return 0;
}