C进阶-动态内存管理+柔性数组

已于 2023-10-27 20:15:49 修改
阅读量138 收藏 1
点赞数 1
文章标签： c语言 开发语言
于 2023-10-20 20:19:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/syh163/article/details/133941416
版权

目录

1.为什么会存在动态内存分配

2.动态内存函数的介绍

2.1 malloc和free

2.2 calloc

2.3 realloc

3.常见的动态内存错误

3.1 对NULL指针的解引用操作

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

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

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

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

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

4.几个经典的笔试题

4.1 题目1：

4.2 题目2：

4.3 题目3：

4.4 题目4：

5.C/C++的内存开辟

6.柔性数组

6.1柔性数组的特点

6.2柔性数组的使用

 6.3柔性数组的优势

1.为什么会存在动态内存分配

根据我们学过的知识，要在内存中开辟一个空间，有两种方式：

    int c = 10;//创建一个变量
	int arr[10] = { 0 };//创建一个数组

但是上述开辟空间的方式有两个局限性：

1.空间开辟的大小是固定的

2.数组在声明的时候，必须指定数组的长度，他所需要的内存在编译时分配

但是有时候，我们只有在运行程序的时候，才能知道自己需要多大的空间，这时候空间已经开辟好了，不能再改变了，有可能大了，也有可能小了，所以上述开辟方式可能会在我们使用的时候带来极大的不便，这就是我们需要动态内存开辟的原因，动态内存管理会根据我们的需要，对开辟的空间进行放大和缩小。

2.动态内存函数的介绍

动态内存管理函数有4个：malloc、calloc、realloc、free

2.1 malloc和free

void*  malloc( size_t size );

这个函数向内存申请一块连续的空间，并返回指向这块空间的指针。

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

上述代码中，我们用数组申请了10个整型的空间，也可以用malloc向内存申请10个整型的空间（40个字节） 。

注意我们将这块空间的地址赋给指针p时，指针p是int*型，而malloc函数的返回类型是void*，所以要强制类型转化为int*。

这样我们就用malloc申请了空间，下面我们就可以直接使用了吗？

可能不行，因为malloc申请空间也是会失败的：

如果开辟成功，则返回一个指向开辟好的空间的指针。

如果开辟失败，则返回一个NULL指针

因此malloc的返回值一定要做检查：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");//打印错误信息
		return 1;
	}
	//开辟成功
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

用if语句判断是否开辟成功，如果开辟失败，则用perror函数打印错误信息，如果开辟成功，则打印出来。（注意使用perror时，要包含头文件<stdlib.h>）

下面我们再来讲一下malloc函数在内存中开辟的空间的具体体现：

之前我们学过，内存中分为栈区、堆区、静态区。栈区存放的是局部变量和形式参数等，静态区存放的是全局变量和静态变量等，那堆区存放的是什么呢？

就是动态内存开辟。

malloc函数申请的空间在堆区，指针变量p开辟的空间在栈区，存放所申请空间的地址。 

malloc申请到空间后，直接返回这块空间的地址，不初始化空间的内容，所以上述代码打印的结果是：

而当程序退出时，malloc申请的内存空间不会主动还给操作系统，这时候就需要用free函数了：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");//打印错误信息
		return 1;
	}
	//开辟成功
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", *(p + i));
	}
	//释放空间
	free(p);
	p = NULL;
	return 0;
}

当free释放掉malloc申请的内存空间后，此时栈区的指针变量p还在啊，它里面还从存放着已经释放掉空间的地址，如果我们不对它进行处理，那p就成了野指针，所以在free(p)后面还令p=NULL。

我们在使用free函数时也要注意，不是动态内存开辟的空间不能用free函数释放，如下面的写法就是错误的：

    int p = 0;
	int* ptr = &p;
	free(ptr);//error

2.2 calloc

void* calloc( size_t num, sizr_t size )

calloc函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0。

与函数malloc函数的区别是calloc函数会在返回前将申请的空间的每一个字节初始化为0。

看下面一段代码：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)calloc(40, sizeof(int));
	if (p == NULL)
	{
		perror("calloc\n");
		return 1;
	}
	//打印数据
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);
	}
	free(p);
	p = NULL;
	return 0;
}

运行结果：

我们可以看到calloc函数开辟空间后确实将空间中每个字节初始化为全0

 当然，我们也可以来看一下开辟失败的结果：

以上就是calloc函数，它和malloc函数有区别，但是功能差不多，下面我们来讲最最重要的realloc函数：

2.3 realloc

realloc函数让动态内存管理更加灵活。

有时候我们发现申请的空间太小了，有时候我们又会觉得申请的空间太小了，那为了合理利用空间，我们一定会对内存的大小进行调整，那realloc函数就可以做到对动态开辟内存大小的调整。

vioe* realloc( void* ptr,size_t size )

ptr是要调整的内存地址，size是调整之后的大小 。

realloc函数的返回值是调整之后的内存起始地址，这个地址有可能和之前开辟空间的地址一样，也有可能是一个新的地址，为什么这么说呢？

这就要提到realloc函数调整空间的两种情况了。

假设我们已经用malloc函数开辟了40个字节的空间，但是我们用的时候觉得不够了，需要再增加40个字节的空间，此时要用realloc将空间大小调整为80个字节，但是realloc在调整时会出现如下两种情况：

下面来看一段代码：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//初始化1~10
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		p[i] = i + 1;
	}
	//增加空间
	p = realloc(p, 80);
	free(p);
	p = NULL;
	return 0;
}

 上述代码中，用p直接来接收realloc的返回地址行不行？

当然不行，要知道realloc函数开辟空间也会失败的，要是开辟成功了，我们用p接收可以，但是要是开辟失败了，这时realloc函数就会返回一个空指针NULL，那此时我们malloc函数开辟的空间的起始地址也是p啊，里面还存放着10个值呢？要是用p接收了空指针，我们这些数据该怎么办？

所以最好为realloc函数返回的新空间的起始地址重新创建一个指针变量ptr，经过判断后再将ptr赋给p:

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//初始化1~10
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		p[i] = i + 1;
	}
	//增加空间
	int*ptr = (int*)realloc(p, 80);
	if (ptr != NULL)
	{
		p = ptr;
        ptr = NULL;
	}
	else
	{
		printf("realloc");
		return 1;
	}
	//打印数据
	for (i = 0; i < 20; i++)
	{
		printf("%d\n", p[i]);
	}
	//释放空间
	free(p);
	p = NULL;
	return 0;
}

 打印结果（可以看到前10个数据还在，后面又开辟了10个int型大小的空间）：

以上就是使用realloc函数增加空间，要想减少空间的话，将传给size的值变小点就行了。

还有一点，要是传给realloc函数参数ptr的是空指针NULL，此时realloc函数和malloc函数的功能一样。

以上就是动态内存管理的4个函数的介绍。

3.常见的动态内存错误

3.1 对NULL指针的解引用操作

int main()
{
	int* p = (int*)malloc(INT_MAX);
	*p = 20;//如果p是NULL，就会出现问题
	free(p);
	return 0;
}

这个我们上文也讲过，要对p进行判断，是不是空指针，如果不是再使用。

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

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		p[i] = i + 1;//开辟了10个整型，访问20个整型，越界访问了
	}
	free(p);
    p = NULL;
	return 0;
}

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

上文中讲过：

    int p = 0;
	int* ptr = &p;
	free(ptr);//error

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

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*p = i ;
		p++;
	}
	free(p);
	p = NULL;
	return 0;
}

 上述代码中，我们使用了开辟的空间中的前5个元素，但是注意在使用后进行p++，那当我们运行完，p指向的就是第5个元素所在空间的地址，此时再用free释放，释放的是第5个元素后面的空间，这样程序会崩溃，也就是说，不能使用free释放一块动态开辟内存的一部分。

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

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

我们在写代码的时候很可能出现，前面已经对这块内存释放过了，后面忘记了，又释放了一次，这时就出现错误了，所以最好养成一个习惯，就是在每次释放之后，将p置为NULL，这样即使重复释放，后面的free也没有任何作用。

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

	free(p);
	p = NULL;

	free(p);
	p = NULL;
	return 0;
}

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

看下面一段代码：

void test()
{
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
 *p = 20;
 }
}
int main()
{
 test();
 while(1);
}

上述代码中，我们在test函数中用malloc申请了100个字节空间，当test函数结束时，指针变量p就自动销毁了，但是malloc申请的那100个字节的空间还在（没有用free释放），只要程序不结束，它就永远不会销毁，而我们在主函数中写了一个while(1)死循环，所以动态开辟的空间泄露了。

内存泄漏造成的问题很严重，它可能会使电脑崩溃，像我们生活中使用的各种APP，之所以我们不论何时登录上去都能使用，是因为它每时每刻都在运行，而要是内存泄漏的话，它每运行一次内存就泄漏一点，直到有一天内存被泄露完了，你的电脑也就崩溃了，这时如果重启一下电脑会发现电脑又好了，但是一旦你打开那个APP，多次使用，总有一天你的电脑又会崩溃。

总结一下，动态内存开辟的空间不会因为出了作用域就销毁，只有两种方式销毁（还给操作系统）：1.free  2.程序结束（退出）。

4.几个经典的笔试题

4.1 题目1：

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

请问运行test函数会出现什么样的结果？能不能打印出“hello world”？

答案是不能，我们来分析一下原因：

要想成功打印出“hello world”，传参的时候就应该传&str。

上述代码还有一处错误，就是没有释放动态内存开辟的空间，所以改正后的代码应该是如下写法：

#include<stdio.h>
#include<stdlib.h>
void GetMemory(char** p)
{
	*p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);
	strcpy(str, "hello world");
	printf(str);
	//释放内存
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

有人说，上面printf(str)的写法不是错误的吗？

其实这种写法没有错，因为我们在打印字符串时用的是printf("hello world")，这里我们传给printf函数的其实只是首字符h的地址，而如果我们把字符串赋给指针char*p="hello world";这里p中存的也是首字符h的地址，那要打印的时候就可以用printf(p)。

同理，上述写法也能打印出"hello world"

 4.2 题目2：

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

运行这段代码会发现，打印出来一串随机值，这是为什么呢？

上述代码中p只是一个局部变量，它在出了函数GetMeory后就会销毁，而出函数GetMeory之前return p返回了p所指向空间的地址，当str根据p的地址找过去时，p所指向的空间已经销毁，str就成了野指针，所以就会非法访问了。

如果要改正上述代码，我们只需要加上static延长p的生命周期就行：

#include<stdio.h>
#include<stdlib.h>
char* GetMemory(void)
{
	static char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main()
{
	Test();
}

下面我们再来举一个相似的例子：

#include<stdio.h>
#include<stdlib.h>
int* test()
{
	int a = 10;
	return &a;
}
int main()
{
	int* p = test();
	printf("%d\n", *p);
}

 这段代码实际上和上文的代码是一样的道理，但是我们运行一下会发现，竟然打印出了10，这是为什么？

其实很容易解释，当进入test函数后，为a变量开辟了一块空间存放10，返回了a的地址，我们在主函数中用p接收到了这个地址，然后根据*p打印，此时虽然a已经销毁，我们依旧侥幸找到了存放10的空间，但是如果我们在printf函数之前任意写一段代码，那要为这段代码开辟空间，就会立即覆盖掉a的空间，这样打印出的值就不是10了。

以上题目统称为返回栈空间地址的问题：

在栈上开辟空间的变量，进入作用域创建，出了作用域，它就销毁了，如果你在出作用域之前将该变量的地址返回了，并且在其他地方用指针接受了，那这个指针就变成了一个野指针。

4.3 题目3：

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就行：

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(p);
 p=NULL;
}

4.4 题目4：

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

 这段代码也是非法访问内存了，在给str开辟了100个字节的空间后，用strcpy函数将"hello"拷贝进去了，接着就释放了这块空间，但是在if语句中，又对str用strcpy函数想将"world"拷贝进去，此时str所指向空间已经被释放，所以非法访问了。

改正（释放空间后，将str置为NULL）：

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

5.C/C++的内存开辟

下面通过一张图来了解一下C/C++中程序内存区域的划分：

有了这幅图，我们就可以更好的理解在《C语言初识》中讲的static关键字修饰局部变量的例子了。

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

上文中我们也讲过，全局变量和静态变量是存放在静态区中的，局部变量和形式参数是存放在栈区中的，而堆区中存放的是malloc、calloc、realloc开辟的空间，下面我们来看一个例子：

通过上图打印出来的地址，会发现存放在栈区的a、b的地址接近，存放在静态区的c、d的地址接近。 

以上就是动态内存分配的全部内容，下面我们来讲一个特殊的数组--柔性数组

6.柔性数组

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

例如：

struct S
{
    int n;
    int arr[];//柔性数组成员
}
int main()
{
     retrun 0;
}

有些编译器中编译不过，可以将arr[]写成arr[0]。

struct S
{
    int n;
    int arr[0];//柔性数组成员
}
int main()
{
     retrun 0;
}

6.1柔性数组的特点

1. 结构中的柔性数组成员前面必须至少一个其他成员。

这个前面的代码就可以看出来，struct S中的柔性数组前面有一个成员n。

2.sizeof返回的结构大小不包含柔性数组内存

下面我们可以用sizeof计算一下结构的大小：

可以看到计算的结果是4，一个int型的变量n的大小就是4，由此可见，sizeof在计算结构大小的时候不包含柔性数组的大小。

3. 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

下面我们来为struct S开辟空间：

#include<stdio.h>
struct S
{
	int n;
	int arr[];
};
int main()
{
	struct S*ps=(struct S*)malloc(sizeof(struct S) + 40);
	return 0;
}

上述代码是我们在结构体成员变量n的基础上一次性开辟44个字节的空间，40是柔性数组预期的大小。

6.2柔性数组的使用

我们也可以对上述结构体类型的变量初始化：

#include<stdio.h>
struct S
{
	int n;
	int arr[];
};
int main()
{
	struct S*ps=(struct S*)malloc(sizeof(struct S) + 40);
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	ps->n = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i + 1;
	}
	//释放
	free(ps);
	ps = NULL;
	return 0;
}

上述代码中开辟的内存空间如下图所示：

当我们觉得空间不够用了，也可以用realloc增容：

#include<stdio.h>
struct S
{
	int n;
	int arr[];
};
int main()
{
	struct S*ps=(struct S*)malloc(sizeof(struct S) + 40);
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	ps->n = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i + 1;
	}
	struct S* ptr = (struct S*)realloc(ps,sizeof(struct S) + 60);
	if (ptr != NULL)
	{
		ps = ptr;
	}
	else
	{
		perror("realloc");
		return 1;
	}
	ps->n = 15;
	for (i = 0; i < 15; i++)
	{
		printf("%d\n", ps->arr[i]);
	}
	//释放
	free(ps);
	ps = NULL;
	return 0;
}

 打印结果：


 

 6.3柔性数组的优势

其实上述柔性柔性数组的使用，我们也可以用一下代码来模拟它：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
struct S
{
	int n;
	int* arr;
};
int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		perror("malloc");
		return 1;
	}
	ps->n = 100;
	ps->arr = (int*)malloc(40);
	if (ps->arr == NULL)
	{
		perror("malloc->arr");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i + 1;
	}
	//调整
	int* ptr = (int*)realloc(ps->arr, 60);
	if (ptr != NULL)
	{
		ps->arr = ptr;
	}
	else
	{
		perror("realloc");
		return 1;
	}
	//打印
	for (i = 0; i < 15; i++)
	{
		printf("%d\n", ps->arr[i]);
	}
	//释放
	free(ps->arr);
	ps->arr = NULL;

	free(ps);
	ps = NULL;
	return 0;
}

注意使用了两次malloc，所以要free两次，先free内层的，后free外层的。

 运行结果：

上述代码开辟空间的方式与柔性数组不同，经过两次开辟得到：

 

虽然开辟空间方式不同，但是第二种方式和柔性数组一样，n和arr都在堆区，也能通过realloc实现增加空间，也可以进行赋值和打印，由此可见我们第二种实现方法也能像柔性数组一样，那为什么还要使用柔性数组呢？

柔性数组也是有优势的，

首先，第二种方式虽然实现了柔性数组的功能，但是开辟空间是用了两次malloc，而用了malloc就要free，一旦你忘记free就有可能出现错误。

其次，我们说开辟的内存和内存之间是有缝隙的，malloc用的越多，缝隙（内存碎片）越多，对内存的利用率就越低，而柔性数组只用了一次malloc,所以柔性数组对内存的利用率比较高。

还有，柔性数组开辟的内存是连续的，这就意味着柔性数组的访问速度更快。

总结一下柔性数组的优势：

1.方便内存释放，对内存的利用率高

2.有利于提高访问速度

那么到这就是我们今天的全部内容了，未完待续。。。

成屿
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
C语言第四版（PDF+实例）
07-28
C语言第四版对C99标准进行了详尽的阐述，增加了许多新特性，如复数类型、柔性数组成员、变量长度数组等。 该书首先从基本语法入手，包括数据类型、变量、运算符、控制结构（如if语句、switch语句、循环）等，使初学...
C语言思维导图（单张图）
08-30
同时，C语言中也提供了柔性数组来实现动态内存管理。 C语言中的字符串函数包括strlen、strcpy、strcat、strcmp、strncpy、strncat、strncmp、strstr、strtok、strerror、perror等，这些函数可以实现字符串的操作和...
【C语言进阶】动态内存管理及柔性数组
2401_83283514的博客
05-29 1610
如果分配成功则返回指向被分配内存的指针，否则返回空指针NULL。返回类型为void*，所以malloc函数并不知道开辟空间的类型，具体在使用时侯使用者自己来决定。如果参数size为0，malloc的行为是标准为定义的，取决于编译器。free是专门用来做动态内存的释放和回收的：如果参数ptr指向的空间不是动态开辟的，那么free的行为是未定义的如果参数ptr是NULL指针，则函数什么事都不做malloc函数与free函数的声明都在stdlib.h中//malloc函数的使用int main()
C语言进阶-动态内存管理/柔性数组
~
10-01 1300
动态内存管理的使用即注意事项有关于动态内存管理的寄到笔试题讲解柔性数组的使用为什么存在动态内存分配一般的开辟空间方式：//在栈空间上开辟四个字节//在栈空间上开辟10个字节的连续空间特点：空间开辟大小是固定的（数组申明必须指定数组的长度，它所需要的内存在编译时分配）但有时候我们需要的空间大小在程序运行的时候才能知道， 那数组的编译时开辟空间的方式就不能满足了，由此动态内存开辟就来了动态内存函数的介绍。
【进阶C语言】动态内存管理+柔性数组
Shun_Hua的博客
01-12 1181
动态管理+柔性数组
动态内存管理+柔性数组+经典笔试题
深入解析C/C++编程技巧，带你探索高效开发之路
10-15 718
头文件均为stdlib.h忘记释放不再使用的动态开辟的空间会造成内存泄漏。切记：动态开辟的空间一定要释放，并且正确释放。只有当我们完全不再需要动态分配的内存时，才应该释放它，而且不要试图释放不属于我们的内存。
C语言进阶--动态内存管理
weixin_36194037的博客
06-29 915
C语言进阶--动态内存管理
C语言进阶⑰(动态内存管理)四个动态内存函数+动态通讯录+柔性数组_malloc+free
热门推荐
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
02-09 3万+
C语言进阶⑰（动态内存管理）四个动态内存函数malloc+free+calloc+reallc，动态通讯录，四道经典笔试题，柔性数组，知识点+笔试题。
C语言基础：012 C进阶语法 - 动态内存和柔性数组
changlif的博客
06-07 249
动态内存和柔性数组
【C语言进阶：动态内存管理】柔性数组
FLASH的博客
04-13 328
但是 malloc 两次，free 两次，维护难度加大，容易出错。内存碎片就会增多，内存利用率就下降了。malloc 一次，free 一次，容易维护空间，不容易出错。内存碎片就会减少，内存利用率就较高一些。也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。连续的内存有益于提高访问速度，也有益于减少。柔性数组的特点和使用。好处是：方便内存释放。
C语言进阶-动态内存管理
m0_56900257的博客
03-08 905
这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。如果开辟成功，则返回一个指向开辟好空间的指针。如果开辟失败，则返回一个NULL指针,因此malloc的返回值一定要做检查。返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候来决定。如果参数 size 为0，malloc的行为标准是未定义的，取决于编译器。int main()//动态开辟return 1;//使用i < 10;i++)//即使没有free。
C大学教程第5版 经典C语言教程 .chm格式 阅读非常方便
10-24
本书第五版的更新，意味着它可能包含了最新的C语言标准，如C99或C11，这些标准引入了新的特性，如柔性数组成员、匿名结构体、动态内存管理改进等。 首先，C语言的基本结构包括变量声明、常量、数据类型（如int、...
你必须知道的495个C语言问题
10-04
10. **C99和C11新特性**：如柔性数组成员、匿名结构体和联合体、窄整型等。 通过对这些问题的深入学习和实践，开发者不仅可以提升对C语言的精通程度，还能提高解决实际编程问题的能力。无论你是初学者还是资深...
modernC：Jens Gustedt撰写的Modern C挑战练习
02-24
4. **柔性数组成员**：结构体的最后一个成员可以是一个未指定大小的数组，这种设计在实现动态数据结构时非常有用。 5. **枚举与类型安全**：C11引入了带类型的枚举（`enum class`），增强了枚举的类型安全性，防止...
C学习（数据结构）--＞ 实现顺序结构二叉树
最新发布
weixin_47298551的博客
08-22 979
一般堆使用顺序结构的数组来存储数据，堆是一种特殊的二叉树。具有二叉树的特性的同时，还具有其它的特性。
C学习（数据结构）--＞二叉树
weixin_47298551的博客
08-22 686
对于深度为 K 的，有 n 个结点的二叉树，当且仅当其每一个结点都与度为 K 的满二叉树编号从 1 至 n 的结点一一对应时称之为完全二叉树。即一个二叉树是结点的一个有限集合，由一个根结点加上两棵别称为左子树和右子树的二叉树组成或者为空。也就是说，如果这个二叉树的层数为 K ，且结点总数是 2^k-1，那么它就是满二叉树。一般把堆（一种二叉树）使用顺序结构的数组来存储，要注意的是，这里的堆和操作系统虚拟进程地址空间中的堆是两回事，这里的堆是指数据结构。例如：深度为3，有6个结点的完全二叉树。
第2章 C语言基础知识
m0_70617423的博客
08-14 2910
C语言
python爬虫爬取某图书网页实例
2301_77698138的博客
08-14 4070
下面是通过requests库来对ajax页面进行爬取的案例，与正常页面不同，这里我们获取url的方式也会不同，这里我们通过爬取一个简单的ajax小说页面来为大家讲解。循环遍历URL（这里为大家提供具体url的获取方法，并循环了1至9页的数据为大家做案例），并发送了带有随机User-Agent的GET请求。设置代码来保存图片到以文章名命名的文件中，并将作者、文章名和简介信息写入到"./biquge.txt"文件中。首先进入网页，点击F12打开自定义与控制工具，点击fecth/XHR，此时显示部分为空白。
C语言中的动态数组和柔性数组有何异同？
06-20
在C语言中，动态数组和柔性数组（flexible arrays）是两种处理数组大小的不同方法。 动态数组（也称为动态内存分配）通常是在程序运行时根据需要动态地分配和释放内存空间的数组。程序员需要使用`malloc()`或`calloc()`等函数来分配内存，并使用`free()`来释放内存。动态数组的大小在编译时并不固定，可以根据需要改变。由于数组大小的灵活性，它们更适用于需要频繁调整大小的情况，但对内存管理的要求较高。 柔性数组（在C99标准后引入）是数组的一种特殊形式，它允许数组名后面跟一个可选的省略的整数，这个整数表示数组的有效元素数量，但不是数组的实际大小。例如，`int arr[10]; int arr[];`中，`arr[]`就是一种柔性数组，编译器会自动为它预留一定数量的内存，直到遇到第一个非数组元素。柔性数组的最大好处是代码简洁，不需要显式指定大小，但它们的大小仍然受限于栈的大小，不能像动态数组那样任意增长，且不能跨多个函数调用。 相同点： - 都允许数组的大小在一定程度上具有灵活性。 - 可以在声明时不明确指定数组的大小。 不同点： - 动态数组：内存分配在运行时完成，可以在程序执行过程中创建和销毁。大小可动态调整，需要手动管理内存。 - 柔性数组：数组大小在编译时确定，但可以通过数组名称后的省略整数部分灵活指定有效元素的数量，不能动态扩展，且受限于栈空间。 - 内存管理：动态数组需要程序员手动分配和释放内存，柔性数组由编译器自动管理，无需显式释放。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

成屿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值