动态内存、指针与函数

z呀哈哈z

已于 2022-07-14 15:11:31 修改

阅读量846

点赞数

分类专栏： C语言文章标签： c语言

于 2022-04-08 22:13:06 首次发布

本文链接：https://blog.csdn.net/m0_60292931/article/details/123994995

版权

C语言专栏收录该内容

2 篇文章 1 订阅

订阅专栏

一、指针和动态内存

1、malloc、 calloc、 realloc、free

2、内存泄漏

二、指针与函数

1、返回指针的函数

2、指向函数的指针 int (*p)( );

3、指针函数的应用-->回调函数

一、指针和动态内存

1、malloc、 calloc、 realloc、free

程序是在栈上运行，每运行一个函数就会开辟新的栈帧/内存，函数结束就销毁，动态内存是在堆上开辟内存空间，需要手动销毁。

void* malloc(size_t size); size = 要分配的字节数；

malloc 会在堆上找到空闲的内存（找不到返回NULL），预留指定大小的空间，然后通过指针返回该空间的起始地址，不会对其进行初始化(可能会有脏数据)，用完一定要释放，不然会浪费内存（即内存泄漏）

void *calloc(size_t nmemb, size_t size); nmemb*size = 要分配的字节数

calloc和malloc类似，但会对分配的空间进行初始化，使其为0

void *realloc(void *ptr, size_t size); ptr=已分配内存的指针，size=新内存块的字节数

realloc可以增加或减少已分配的内存，返回修改后空间的起始地址（一般在在原地址进行增减，如果不能在之前的基础上增加，则新开辟内存，拷贝原来的内容，再释放掉之前的内存）

realloc(NULL,size) 相当于 malloc realloc(p,0) 相当于 free(p)

void free(void *ptr);

free函数释放ptr所指向的内存空间，这些空间必须是由之前调用malloc()、calloc()或realloc()返回的。否则，或者如果之前已经调用了free(ptr)，则会发生未定义的行为。如果ptr为NULL，则不执行任何操作。（直接翻译的man手册，懒得总结了）

尽管释放了内存，但ptr 仍然指向那段内存的起始地址，仍然可以修改地址里的值，ptr就是所谓的野指针

#include<stdio.h>
#include <stdlib.h>

/*
	所用编译器版本
	gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.1)
*/

void print(int *p,int n){
	for(int i=0;i<n;i++){	
		printf("P[%d] = %d\n",i,p[i]);
	}
}

int main(){
	int n,m = 0;
	printf("输入数组的大小：\n");
	scanf("%d",&n);
	
	//int *p = (int *)calloc(n,sizeof(int));
	//int *p = (int *)realloc(NULL,n*sizeof(int));
	int *p = (int *)malloc(n*(sizeof(int)));
	
	printf("p = %d\n",p);
	//free(&p[n-1]); //错误，只能free(p);

	//初始化
	for(int i=0;i<n;i++){
		p[i]=i+1;
	}
	print(p,n);
	
	printf("输入更改后数组的大小：\n");
	scanf("%d",&m);


    //使用malloc更改内存
    int *q = (int *)malloc(m*(sizeof(int)));
	int size = 0;
	size = m>n?n:m;
	for(int i=0;i<size;i++){
		q[i]=p[i];
	}
	free(p);
	p = q;
	printf("p = %d\n",p);
	print(p,size);
	
    //使用realloc更改内存
	//int *q = (int *)realloc(p,m*sizeof(int));
	//printf("q = %d\n",q);
	//print(q,m);
	//free(q);
	//free(p);  //释放q = 释放p 一起释放会报错
    
	//realloc(p,m*sizeof(int));//可以这样用，但是会有警告
	//print(p,m);
	//print(p,n>m?n:m); //减小空间后，原来的值不会修改为0
	

    //其他测试
	//p = (int *)realloc(p,0); //段错误
	//realloc(p,0); //等同于 free(p);
	//print(p,m);
	
	//free(p); //释放后依然可以修改该段内存
	//printf("p = %d\n",p);
	//p[0]=5;
	//print(p,m);
	
}

使用malloc更改

使用 realloc更改

2、内存泄漏

在栈上申请内存，调用结束后会自动回收，但在堆上申请内存不会自动回收（除非程序结束），必须显式的回收，即调用free()。不回收就会在堆上成了垃圾，一直占着内存资源，多次调用不回收，会使程序占用的内存越来越大。

二、指针与函数

1、返回指针的函数

可以从栈底向上传参数，不能从栈顶向下返回参数，即尽量不要返回在栈顶的局部变量的地址。

程序是是栈上运行的，每调用一个函数，这个函数被会放在栈顶，会给这个函数分配一定的内存，在这个函数里定义的所有变量都在这个内存上，函数执行完会自动释放内存，这些变量也会被销毁，当新的函数执行可能会覆盖这段内存。

#include<stdio.h>
/*
	所用编译器版本
	gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.1)
    理解n=1的情况就行
*/

int num = 3;
void check(){
	printf("返回成功\n");
}
int *sum(int a,int b,int n){
	
	if(n==1){

       //函数返回后会被销毁，返回的地址可能被其他数据覆盖

		printf("c为变量 p为指针指向c，返回p\n");
		int c;
		c = a + b;
		int *p;
		p = &c;
		return p; //直接返回&c会喜提段错误
	}
	else if(n==2){	
		printf("c为指针，直接返回c\n"); 

        //错误的语法确能运行，还能不被销毁？
        //我的编译器总能执行这段，甚至每次地址都不一样

		int *c;
		*c = a + b; 

		printf("%d\n",c);
		return c;
	}
	else if(n==3){
		return &num;  //可以返回全局变量的地址
	}
}

//也可返回常量的地址
char *fun(void){
	
	return "hello";

}

int main(){
	
	int a = 1;
	int b = 2;
	int n = 0;
	
	
	printf("\n请输入n:");
	scanf("%d",&n);

	//char *p = fun();//返回常量
	int *c = sum(a,b,n);
    
	check();
	printf("a+b = %d\n\n",*c);
    //printf("p[0] = %c\n",*(p+0));

}

2、指向函数的指针 int (*p)( );

*p必须加括号。函数也有地址，函数名就相当于指向该地址的指针

int sum(int a,int b){
	
	return a+b;
}

char* fun(){
	 return "hello";
}
	
int main(){
	
	//*p必须加括号，不加就成了一个返回指针的函数
    //定义的时候和函数差不多，去掉参数就行
	int (*p)(int,int);
	p = sum;
	printf("%d\n",p(1,2));
	
	//&sum ,sum 都可以拿到函数的地址
	//*p = &sum;
	//printf("%d\n",(*p)(1,2));
	
	char* (*q)();
	q = fun;
	printf("%s\n",q());
	
	return 0;
}

3、指针函数的应用-->回调函数

就是函数作为参数传入函数

int sum(int a,int b,char* (*q)(void)){
	
	printf("%s\n",q());
	return a+b;
}

char* fun(void){
	 return "调用成功";
}
	
int main(){
    
    //定义时只需要去掉参数 
	int (*p)(int,int,char* (*)(void));
	p = sum;

    //虽然定义写了一大堆，但用的时候就很方便
	printf("%d\n",p(1,2,fun));

	return 0;
}