c语言学习记录——动态内存分配

最新推荐文章于 2024-07-09 21:26:16 发布

小黑的尾巴呀

最新推荐文章于 2024-07-09 21:26:16 发布

阅读量196

点赞数 1

文章标签： c语言

本文链接：https://blog.csdn.net/weixin_54906953/article/details/121512653

版权

c/c++学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

1开始

我们知道：

栈上开辟空间的大小是固定的，但是有时候需要动态的空间。节约空间？

栈区stack：函数执行结束时，局部变量的存储单元自动被释放，栈内存分配运算效率高，空间小。
堆区heap：程序员分配释放
静态区static：全局变量，程序结束时由系统释放。

2动态内存函数的介绍

malloc

void* malloc (size_t size);

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

细节：

开辟成功，返回开辟好的空间的指针
开辟失败，返回NULL（所以需要判断）
返回值类型为void*，（具体返回类型需要自己来定义）
如果size为0，malloc的结果是未定义的，取决于编译器。
头文件 <stdlib.h>

如：

#include<stdio.h>
#include<stdlib.h>//
#include<errno.h>//errno的头文件


int main() {
	int* p = (int*)malloc(10 * sizeof(int));//向内存申请10个整型的空间
	if (p == NULL) {//可以只是 return 0;
		//打印错误原因的一个方式
		printf("%s\n", strerror(errno));
	}
    //正常使用
    int i = 0;
	for (i = 0;i < 10;i++) {
		*(p + i) = i;
	}
	for (i = 0;i < 10;i++) {
		printf(" %d ", *(p + i));
	}
}

free

动态内存的释放与回收

void free(void* pt);

具体：

如果参数pt指向的空间不是动态开辟的，那么free函数的行为是未定义的。
如果参数pt是NULL指针，则函数什么事都不做。
声明在<stdlib.h> 中

//在上边例子中的main函数中尾部加上

free(p);
p=NULL;

calloc

void* calloc (size_t num,size_t size);

函数的功能是为num个大小为size的元素开辟一块空间，并且初始化为0。
与malloc的区别>初始化为0；

（更换开始例子中malloc函数，然后直接输出得到的便是10个0）

realloc

void* realloc （void*pt，size_t size）;

对申请开辟的空间大小调整。

pt为要调整的内存地址
size为调整后的新大小
返回值为调整之后的内存起始位置
函数在调整原空间大小的基础上，还会将用来的内存中的数据移动到新的空间

调整内存中存在的两种情况：

①如果原来p指向的空间之后有足够的内存空间可以追加，则直接追加，返回p。
②如果p后没有足够空间追加，则函数会重新找个新的内存区域，开辟满足需求的空间，并且拷贝原内存的内容，释放旧的空间。最后返回新开辟的内存空间地址。（使用一个新的（不用也可以）指针变量来接收返回值。用来判断是否成功。成则赋回给原指针）

int main() {
	int* p = malloc(100);
	if (p != NULL) {
		;//
	}
	else {
		return 0;
	}
	int* pt = NULL;
	pt = (int*)realloc(p, 1000);
	if (p != NULL) {//避免指针丢失
		p = pt;
	}
	;//
	free(p);
	p = NULL;
}

3常见动态内存错误

（1）对NULL指针的解引用操作

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

如：第一个例子循环超过10的赋值

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

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

void text() {
	int* p = (int*)malloc(100);
	p++;
	free(p);//此时p指向的不是开辟的动态内存的起始位置
}

（5）重复释放

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

==》动态开辟内存要释放，并且正确释放

4柔性数组

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

typedef struct S {
	int i;
	int arr[0];//柔性数组成员
}S;

int main() {
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int));
    //柔性数组分配空间（加的那部分）
	ps->i = 100;
    printf("%d",ps->i);
    //
    free(ps);
    ps=NULL;
}

特点：

柔性数组成员前必须至少有一个其他成员。
sizeof（）返回的这种结构体大小不包括柔性数组的内存。
含柔性数组的结构用malloc函数进行的内存动态分配，分配的空间应该大于结构体大小

5其他

（1）

void Get(char* p) {
	p = (char*)malloc(100);
}

void text() {
	char* str = NULL;
	Get(str);
	strcpy(str, "hello world!");
	printf(str);
}

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

结果：

1 运行代码会出现崩溃的现象
2 程序存在内存泄露的问题
3 str是以值传递的形式给p ，p为Get函数的形参，只能函数内部有效，函数返回后，动态开辟内存尚未释放并且找不到，所以会内存泄漏。

（2）

void Get(char** p) {
	*p = (char*)malloc(100);
}

//char* Get(char* p) {
//	p = (char*)malloc(100);
//	return p;
//}

void text() {
	char* str = NULL;
	Get(&str);
//str = Get(str);//
	strcpy(str, "hello world!");
	printf(str);
    free(str);
    str=NULL;
}

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

结果：

hello world！