C语言指针，结构体与动态内存分配与释放复习

最新推荐文章于 2022-09-29 15:20:55 发布
最新推荐文章于 2022-09-29 15:20:55 发布
阅读量3.1k 收藏 37
点赞数 9
分类专栏： 数据结构 文章标签： 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43800761/article/details/107116376
版权

一、指针

1.1 指针的基本介绍

指针的重要性：指针是C语言的灵魂。
指针，也就是内存的地址;所谓指针变量，也就是保存了内存地址的变量。
在这里插入图片描述
地址：

是从内存单元的编号 ，是从0开始的非负整数 ，如：0–FFFFFFFF【4G-1】

指针：

指针就是地址 ，地址就是指针 。指针变量是存放在内存单元地址的变量， 指针的本质是一个操作受限的非负整数

基本概念

int i = 0;
int *p = &i;	//等价于int *p; 	p = &i;

详解这两步操作：
（1）p 存放了 i 的地址，所以我们说 p 指向了 i
（2）p 和 i 是完全不同的两个变量，修改其中的任意一个变量的值不影响另一个变量的值
（3）p 指向 i, *p 就是i变量本身。更形象的说所有出现 *p 的地方都可以换成 i，所有出现 i 的地方都可以换成 *p

注意：

指针变量也是变量，只不过它存放的不能算是内存单元的内存地址
普通变量前不能加 * ，常量和表达式前不能加&

实例：

#include<stdio.h>
int main()
{
	int *p;//p是个变量名，int * 表示该p变量只能存储int类型变量的地址
	int i = 10;
	int j;

	//j = *p;//p没保存地址，那么*p就不知道指向哪个地址
	
	p = &i;

	j = *p;	//等价于 j = i;
	//p = 10	//error
	printf("i = %d, j = %d, *p = %d\n", i, j, *p);
	return 0;
}

内存分析图：
在这里插入图片描述

1.2 指针的运算（++，–，+，-）

指针是一个用数值表示的地址。可以对指针执行算术运算。

数组名

一维数组名是个指针常量, 它存放的是一维数组第一个元素的地址, 它的值不能被改变，一维数组名指向的是数组的第一个元素

下标和指针的关系

a[i] <<==>> *(a+i)

假设指针变量的名字为p， 则 p+i 的值是p+i*(p所指向的变量所占的字节数)

实例：

#include<stdio.h>
int main()
{
	int arr[5] = {1,2,3,4,5};
	int i, *p;	//p是一个int* 指针
	
	p = arr;//p指向了arr数组的首地址
	for(i = 0;i < 5;i++)
	{
		printf("arr[%d] 地址=%p\n",i,p);
		printf("存储值：arr[%d]=%d\n",i,*p);
		p++;
	}

	return 0;
}

内存结构图：
在这里插入图片描述
● 数组在内存中是连续分布的
● 当对指针进行++时，指针会按照它指向的数据类型字节数大小增加，比如int* 指针，每++，就增加 4 个字
节。
● 所有指针变量只占4个字节，用第一个字节的地址表示整个变量的地址。

1.3 指针数组

要让数组的元素指向 int 或其他 数据类型的地址(指针)。可以使用指针数组。

指针数组定义：

数据类型 *指针数组名[大小]

如：int *arr[3];

arr 声明为一个指针数组 。
arr 由 3 个整数指针组成。因此，arr 中的每个元素，都是一个指向 int 值的指针。

比如：

#include<stdio.h>
int main()
{
	int arr[3] = {100,200,300};
	int i, *p[3];	//p是一个int* 指针

	for(i = 0;i < 3;i++)
	{
		p[i] = &arr[i];	//赋值为整数的地址
	}

	for(i = 0;i < 3;i++)//指针数组获取各个值
	{
		printf("arr[%d]=%d  p[%d]地址=%p\n",i,*p[i],i,&p[i]);
		
	}
	
	return 0;
}

内存布局：
在这里插入图片描述

1.4 指向指针的指针（多重指针）

指向指针的指针是一种多级间接寻址的形式，或者说是一个指针链。通常，一个指针包含一个变量的地址。当我们定义一个指向指针的指针时，第一个指针包含了第二个指针的地址，第二个指针指向包含实际值的位置。
在这里插入图片描述
（1）一个指向指针的指针变量必须如下声明，即在变量名前放置两个星号。例如，声明了一个指向int 类型指针的指针：int **ptr;
（2）当一个目标值被一个指针间接指向到另一个指针时，访问这个值需要使用两个星号运算符，比如**ptr

实例：

#include<stdio.h>
int main()
{
	int var;
	int *p;//一级指针
	int **pp;//二级指针
	var = 1000;
	p = &var;//var变量的地址赋值给p
	pp = &p;//表示将p存放的地址，赋值给pp

	printf("var的地址=%p  var = %d\n",&var,var);
	printf("p本身的地址=%p  p存放的地址 = %d   *p = %d\n",&p,p,*p);
	printf("pp本身的地址=%p  pp存放的地址 = %d   *pp = %d\n",&pp,pp,*pp);

	return 0;
}

内存结构图：
在这里插入图片描述

1.4 传递指针（地址）给函数

当函数的形参类型是指针类型时，使用该函数时，需要传递指针，或者地址，或者数组给该形参。

如何通过被调函数修改主调函数中普通变量的值？

  1. 实参为相关变量的地址
  2. 形参为以该变量的类型为类型的指针变量
  3. 在被调函数中通过 *形参变量名 的方式就可以修改主函数中的变量的值

实例1（传地址或指针给指针变量）：

#include<stdio.h>

void f(int *p)	//不是定义了一个名字叫做*p的形参，而是定义了一个形参，该形参名字叫做p，它的类型是int *
{
	*p += 1;
}

int main()
{
	
	int i = 10;
	int *p = &i;//将i的地址赋值给p
	
	f(&i);//传地址
	printf("i = %d\n", i);//i=11
	
	f(p);//传指针
	printf("i = %d\n", i);//i=12
	return 0;
}

内存分析：
在这里插入图片描述

实例2（传数组给指针变量）：

#include <stdio.h>

/* 函数声明 */
double getAverage(int *arr, int size); //

int main ()
{
   /* 带有 5 个元素的整型数组  */
   int balance[5] = {1000, 2, 3, 17, 50};
   double avg;
   /* 传递一个指向数组的指针作为参数 */
   avg = getAverage( balance, 5 ) ;
   /* 输出返回值  */
   printf("Average value is: %f\n", avg );
   return 0;
}
//说明
//1. arr 是一个指针，
double getAverage(int *arr, int size)
{
  int i, sum = 0;       
  double avg;          
  for (i = 0; i < size; ++i)
  {
	  // arr[0] = arr + 0
	  // arr[1] = arr + 1个int字节（4） 
	  // arr[2] = arr +  2个int字节（8）
    sum += arr[i];// arr[0] =>数组第一个元素的地址 
	printf("\n arr存放的地址=%p \n", arr);
  }
  avg = (double)sum / size;
  return avg;
}

在前面说过 a[i] <<==>> *(a+i)，所以上面的 arr[i] 还可以写成 *(arr + i)。也可以这样：

    sum += *arr;
    arr++;  // 指针的++运算, 会对arr 存放的地址做修改

1.5 返回指针的函数

允许函数的返回值是一个指针(地址)，这样的函数称为指针函数。

实例：

#include <stdio.h>
#include <string.h>

char *strlong(char *str1, char *str2){ //函数返回的char * (指针)
	printf("\nstr1的长度：%d str2的长度：%d", strlen(str1), strlen(str2));
	if(strlen(str1) >= strlen(str2)){
		return str1;
	}else{
		return str2;
	}
}
int main(){
	char str1[30], str2[30], *str; // str 是一个指针类型，指向一个字符串
	printf("\n请输入第1个字符串：");
	gets(str1);
	printf("\n请输入第2个字符串：");
	gets(str2);
	str = strlong(str1, str2);
	printf("\nLonger string: %s \n", str);
	return 0;
}

注意事项：

  1. 用指针作为函数返回值时需要注意，函数运行结束后会销毁在它内部定义的所有局部数据，包括局部变量、局部数组和形式参数，函数返回的指针不能指向这些数据。
  2. 函数运行结束后会销毁该函数所有的局部数据，这里所谓的销毁并不是将局部数据所占用的内存全部清零，而是程序放弃对它的使用权限，后面的代码可以使用这块内存
  3. C语言不支持在调用函数时返回局部变量的地址，如果确实有这样的需求，需要定义局部变量为static变量

1.6 函数指针（指向函数的指针）

  • 一个函数总是占用一段连续的内存区域，函数名在表达式中有时也会被转换为该函数所在内存区域的首地址，这和数组名非常类似。
  • 把函数的这个首地址(或称入口地址)赋予一个指针变量，使指针变量指向函数所在的内存区域，然后通过指针变量就可以找到并调用该函数。这种指针就是函数指针。

函数指针定义：


returnType (* pointerName)(param list);
  1. returnType 为函数指针指向的函数返回值类型
  2. pointerName 为函数指针名称
  3. param list为函数指针指向的函数的参数列表
  4. 参数列表中可以同时给出参数的类型和名称，也可以只给出参数的类型，省略参数的名称
  5. 注意( )的优先级高于*，第一个括号不能省略，如果写作returnType *pointerName(param list);就成了函数原型，它表明函数的返回值类型为returnType*

实例（用函数指针来实现对函数的调用，返回两个整数中最大值）：

#include <stdio.h>

int max(int a,int b)
{
	return a>b?a:b;
}
int main(){
	int x,y,maxVal;
	//说明函数指针
	//1.函数指针的名字pmax
	//2. int表示该函数指针指向的函数是返回int类型
	//3. (int, int)表示该函数指针指向的函数形参是接收两个int
	//4.在定义函数指针时，也可以写上形参名int (*pmax)(int x, int y) = max;
	int (*pmax)(int , int)= max; 

	printf("Input two numbers:"); 
	scanf("%d %d", &x, &y);
	// (*pmax)(x, y)通过函数指针去调用函数max
	maxVal = (*pmax)(x, y);
	printf("Max value: %d pmax=%p pmax本身的地址=%p\n", maxVal, pmax, &pmax);
	return 0;
}

内存结构图分析：
在这里插入图片描述

1.7 指针的注意事项和细节

  1. 指针变量存放的是地址，从这个角度看指针的本质就是地址。
  2. 变 量声明的时候，如果没有确切的地址赋值，为指针变量赋一个NULL值是好的编程习惯。
  3. 赋为NULL值的指针被称为空指针，NULL指针是一个定义在标准库<stdio.h>中 的值为零的常量 #define NULL 0

二、结构体

2.1 为什么要有结构体

比如有一个学生有学号，名字，年龄等属性，多个学生如果按常规变量赋值就会使得代码冗余，那么就要把其各个属性抽象出来，形成一个新的类型，所以结构体诞生了。也就是：为了表示一些复杂的数据，而普通的基本类型变量无法满足要求。

2.2 什么是结构体

结构体是用户根据实际需要自己定义的复合数据类型。其实结构体就是面向对象语言中类，只是结构体中没有方法，并且最后有分号。

class Student
{
	int sid;
	String name;
	int sage;

	void inputStudent()
	{
	}
	void showStudent()
	{
	}
}

struct Student
{
	int sid;
	char *name;
	int sage;
}; //分号不能省
2.2.1 结构体和结构体变量的区别与联系
  1. 结构体是自定义的数据类型，表示的是一种数据类型.
  2. 结构体变量代表 一个具体变量，好比：
int numl; //int 是数据类型,而num1是一个具体的int变量
struct Student stu;// Student 是结构体数据类型，而 stu是一个Cat变量

2.3 如何使用结构体

两种方式：

struct Student st = {1000,"zhangsan",20};
struct Student *pst = &st;
  1. st.sid
  2. pst->sid

实际使用如下：

#include <stdio.h>
#include<string.h>

struct Student
{
	int sid;
	char *name;//名字，用指针，指向一个字符串
	int age;
};//分号不能省

int main(){
	
	struct Student st = {1000,"zhangsan",20};

	//第一种方式
	/*
	st.sid = 99;
	//st.name = "lisi"; //error
	st.name = "lisi";
	st.age = 19;
	*/

	//第二种方式（常用）
	struct Student *pst;
	pst = &st;
	pst->sid = 99;	//pst->sid 等价于 (*pst).sid， 而(*pst).sid等价于st.sid，所以pst->sid等价于st.sid
	pst->name = "wangwu";
	pst->age = 21;

	printf("%d %s %d \n",st.sid,st.name,st.age);
	return 0;
}

2.4 注意事项

  • 结构体变量不能加减乘除，但可以相互赋值
  • 普通结构体变量和结构体指针变量作为函数传参问题
#include <stdio.h>
#include<string.h>

typedef struct Student
{
	int sid;
	char *name;//名字，用指针，指向一个字符串
	int age;
}Student;//分号不能省


void f(Student *pst)
{
	pst->sid = 88;
	pst->name = "mayun";
	pst->age = 18;
}

//这种方式消耗内存，耗时间，不推荐
void g(Student st)
{
	printf("%d %s %d \n",st.sid,st.name,st.age);
}

void g2(Student *pst)
{
	printf("%d %s %d \n",pst->sid,pst->name,pst->age);
}

int main(){
	Student st;
	f(&st);
	//g(st);
	g2(&st);
	
	return 0;
}
typedef的用法
typedef struct Student
{
	int sid;
	char *name;
	int age;
}Student,*pStudent;//等价于Student代表了struct Student ，pStudent代表了struct Student *

用法：

#include <stdio.h>
#include<string.h>

typedef struct Student
{
	int sid;
	char *name;
	int age;
}Student,*pStudent;//等价于Student代表了struct Student ，pStudent代表了struct Student *  


int main(){
	Student st;//struct Student st;
	pStudent ps = &st;//struct Student *st = &st; 
	ps->sid = 999;
	printf("%d\n",ps->sid);

	return 0;
}

三、动态内存分配与释放

3.1 不同数据在内存中的分配

在这里插入图片描述

  1. 全局变量一一内存中的静态存储区
  2. 非静态的局部变量——内存中的动态存储区——stack栈
  3. 临时使用的数据——建立动态内存分配区域，需要时随时开辟，不需要时及时释放——heap 堆
  4. 根据需要向系统申请所需大小的空间，由于未在声明部分定义其为变量或者数组，不能通过变量名或者数组名
    来引用这些数据，只能通过指针来引用

3.2 内存动态分配相关函数

头文件 #include <stdlib.h> 声明了四个关于内存动态分配的函数，下面我只介绍最常用的函数malloc和free。

  1. 函数原型 void * malloc (usigned int size)
    ● 作用：在内存的动态存储区(堆区)中分配一个长度为size的连续空间。
    ● 形参size的类型为无符号整型，函数返回值是所分配区域的第-一个字节的地址，即此函数是一个指针型函数，返回的指针指向该分配域的开头位置（函数首地址）。
    ● malloc(100); 开辟100字节的临时空间，返回值为其第一个字节的地址

  2. 函数原型: void free (void *p)
    ● 作用：释放变量p所指向的动态空间，使这部分空间能重新被其他变量使用。
    ● p 是最近一次调用calloc或malloc函数时的函数返回值
    ● free函数无返回值
    ● free(p);//释放p所指向的已分配的动态空间

C99标准把以上malloc,calloc,realloc函数的基类型定为void类型,这种指针称为无类型指针(typeless pointer) ,即不指向哪一种具体的类型数据,只表示用来指向一个抽象的类型的数据,即仅提供一个纯地址,而不能指向任何具体的对象。
在这里插入图片描述

代码示例：

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

int main(){
	int a[5] = {4,10,2,8,6};//静态分配内存

	int len;
	printf("请输入你要分配的数组长度：len = ");
	scanf("%d",&len);

	// 在堆区开辟-一个5*4的空间，并将地址(void*) ，转成(int*),赋给pArr
	int *pArr = (int *)malloc(sizeof(int) * len);

	/*
	*pArr = 4;	//类似于a[0] = 4;
	pArr[1] = 10; //类似于a[1] = 10;
	printf("%d %d\n",*pArr,pArr[1]);//4  10
	*/


	//pArr完全可以当做普通数组来使用
	for(int i = 0;i < len;i++)
	{
		scanf("%d",&pArr[i]);
	}

	for(i = 0;i < len;i++)
	{
		printf("%d\n",*(pArr + i));
	}


	free(pArr);	//把pArr所代表的动态分配的20个字节内存释放
	return 0;
}

内存结构图：
在这里插入图片描述

3.3 动态分配内存注意事项

  1. 避免分配大量的小内存块。分配堆上的内存有一些系统开销，所以分配许多小的内存块比分配几个大内存块的系统开销大
  2. 仅在需要时分配内存。只要使用完堆上的内存块，就需要及时释放它(如果使用动态分配内存，需要遵守原则:(谁分配，谁释放)，否则可能出现内存泄漏
  3. 总是确保释放已分配的内存。在编写分配内存的代码时，就要确定在代码的什么地方释放内存
  4. 在释放内存之前， 确保不会无意中覆盖堆上已分配的内存地址，否则程序就会出现内存泄漏。在循环中分配内存时，要特别小心
许你常欢
关注
  • 9
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C程序设计基础-复习(与“指针”有关文档共23张).pptx
11-16
文件指针用于访问文件内容，而文件结构体在文件关闭后会被释放。 总之，C程序设计基础复习涉及了从基本的数值表示到高级的控制结构和内存管理等多个方面，每个知识点都是学习C语言不可或缺的部分。理解和熟练运用...
c语言 结构体指针 free 释放内存
xiaolan7777777的博客
08-20 1830
c语言 结构体 free 释放内存 链表
C语言 结构体指针强制转换
热门推荐
caisense的专栏
05-27 1万+
最近写c程序遇到的结构体指针强转的坑,记录一下. 是一个简单的菜单程序,程序用到链表,表中存储了9个不同命令.每次将用户输入的命令与表中存储的命令名作对比(遍历查询),然后执行相应功能.总体结构:linktable.h:定义通用模块化链表数据结构,以及相关操作 linktable.c:实现头文件中定义的链表操作 main.c:主函数通用链表节点:(抽象定义)typedef struct LinkT
C++中指针问题
CSDN19971022的博客
04-21 780
一、基础知识 1、声明指针：typeName * pointName; 2、初始化（3种）： int a=10; int *p; p=&a; 也可以在声明中初始化 int a=5; int *pt=&a; *运算符两边的空格是可以选的，传统C程序员使用这种格式： int *p 这强调的是*p是一个int类型的值。但很多C++程序员使用这种格式： int* p，这强调的是：int*是一种类型---指向int的指针，在哪里添加空格没有任何区别，甚至可以这样做int*p； ...
指针中--【内存申请与释放】变量与空间//内存分配与释放//基本数据类型空间的申请与使用//数组与malloc关系// calloc realloc的使用区别
howardhaowang的博客
04-13 447
1.3.4 内存申请与释放 1.3.4.1 变量与空间 1.3.4.1.1 宏观上 多个程序同时运行是怎么个情况 所有程序/软件（程序=软件一个面对用户一个面对程序员）的运行，是由操作系统统一调配的。操作系统是程序的运行环境。 运行中的多个程序之间，内存是不交叉的 程序结束，操作系统还要释放其使用的资源 不释放会咋样？资源会被一直占用，别的程序无法使用了。 1.3.4.1.2 微...
C/C++使用malloc为结构体数组分配内存（及free释放内存）的三种方法
Ayka的博客
12-09 8430
以 template<typename Key, typename Value> struct Node {}; 为例，试创建有n个Node类型的node的数组。 方法一（nodes[i]为指针）： struct Node<int, int> *nodes[n]; for (size_t i = 0; i < n; i++) nodes[i] = (struct Node<int, int>*)malloc(sizeof(struct Node&
C语言结构体.ppt
04-09
C语言结构体类型 C语言结构体类型是一种复杂的数据类型，它允许用户建立一种集不同数据类型于一体的数据构造类型。结构体类型的定义需要在程序中自己建立所需的结构体类型，包括成员的声明，每个成员所具有的数据...
C语言精简复习资料，可用于学习与复习参考
11-05
`malloc()`, `calloc()`, `realloc()`和`free()`函数用于动态内存分配和释放。 12. **复杂类型定义**： 结构体和联合体允许我们组合不同类型的数据，通过typedef可以创建新的数据类型。 13. **宏定义**： 宏...
c语言指针讲义复习资料.pdf
11-10
学习C语言指针，需要重点理解地址、指针变量的概念，以及如何定义、赋值和引用指针。通过指针可以实现更灵活的数据操作，包括动态内存管理、函数参数传递和结构体操作等。熟悉这些概念和操作是成为熟练的C语言程序员...
C语言学习基础提升与综合训练复习题
08-13
复习范围涵盖了C语言课本的2-13章，这意味着我们需要了解变量、数据类型、运算符、流程控制、函数、数组、指针、结构体等核心概念。 1. **算法**： - 程序的灵魂是算法，沃思公式指出，程序 = 数据结构 + 算法。 ...
对C语言指针强转的理解
liaojunwu的博客
11-17 317
1.什么是表达式, 表达式的属性是什么 写得好的博客贴在这里:https://blog.csdn.net/astrotycoon/article/details/50857326 定义:概括说来表达式是由一系列运算符（operators）和操作数（operands）组成的。这既是表达式的定义，同时也指明了表达式的组成成份。运算符指明了要进行何种运算和操作，而操作数则是运算符操作的对象 属性:...
C语言结构体在函数内的申请与释放
weixin_42252910的博客
08-19 1332
在函数内实现malloc的方式 1-使用指针作为函数返回值的方式 dataStc *func1() { dataStc *p; p = (dataStc *)malloc(sizeof(dataStc)); p->size = 6; return p; } 2-使用二级指针的方式 void func2(dataStc **p) { *p = (dataStc *)malloc(sizeof(dataStc)); (*p) -> size = 8;
结构体变量内存申请与释放
千里小马哥的博客
09-29 1457
结构体是C、C++开发中不可或缺的数据结构，往往涉及到函数的入参以及出参等，也必然涉及到参数的初始化。对于字符串往往是需要在堆上开辟一定空间的，本篇文章记录下相关知识！
c语言结构体里面定义指针变量必须要开辟内存吗,c语言野指针与结构体指针动态内存分配小解...
weixin_42429120的博客
05-18 1412
首先我们来看一道题：#include #include #include struct student { char *name; //改 char name [ ]; int score; }*pstu; int main(){ pstu=(struct student*)malloc(sizeof(struct student)); ///将地址转成struct student* 型 改：ch...
关于指针变量所占内存空间大小的问题【转】
Uaena的博客
10-03 4486
（转自：https://blog.csdn.net/cool_oyty/article/details/8078632） 在编译器里定义一个指针变量，编译器会给这个指针变量分配一个空间，这个空间里存放的是一段内存的首地址，先解释一段内存，一段内存的大小是与你所定义的指针类型相关的，比如int，这段内存占四个字节（当然要看你的机器是多少位的了），则这段内存的首地址是第一个字节的地址，如char类...
指针与指针变量的区别（C语言）
weixin_48627356的博客
03-26 5771
提示：本章主要谈及个人对C语言指针和指针变量的理解 文章目录前言一、指针是什么？二、指针变量是什么？三、知识拓展总结 前言 指针是C语言中的一个很重要的concept，掌握指针的应用，可以使程序更加简洁、紧凑和高效。可以说，没有掌握指针就是没有掌握C语言的精华。 提示：以下是本篇文章正文内容，下面案例可供参考 一、指针是什么？ 通过学习C语言我们知道，在定义变量的时候，系统会自动给该变量分配内存空间。编译系统根据程序中定义的变量类型，分配一定长度的空间。 思考这样一个问题： 要怎么才能知道系统分配给.
c/c++动态内存申请与释放
liugg2016的博客
08-09 4241
1，C中内存申请有哪些（标准库函数） 函数名 函数原型 作用 例子 二维数组的申请，释放 malloc void * malloc（size_t size） 动态内存的申请 函数本身不知内存类型，关心内存的总字节数 int * p =（int *）malloc（sizeof（int）* length）; ...
c:局部变量不释放所指向内存空间
Blog of Meredith
09-22 3207
记住指针和它所指向的东西是完全不同的。 局部变量在函数返回时就 会释放, 但是在指针变量这个问题上, 这表示指针被释放, 而 不是它所指向的对象。 用 malloc() 分配的内存直到你明确释放它之前都会保留 在那里。 一般地, 对于每一个 malloc() 都必须有个对应的 free() 调用 代码如下：     animal person,*animalPtr;     strcpy(p
C语言—内存的管理和释放
little_rookie__的博客
01-08 1万+
C语言—内存的管理和释放一、Linux下内存分配管理1.编译好的C程序文件分区2.C程序运行时内存分区3.为什么要进行内存分配4.内存分配方式二、详解堆和栈1.堆和栈的简介2.堆和栈的区别三、内存管理函数四、其它知识1.（嵌入式开发中）程序编译完成后的大小统计2.数据存储区域实例3.字符串与字符数组 一、Linux下内存分配管理 1.编译好的C程序文件分区 分析C语言下程序的内存分配，我们从一段简单C程序源码test.c开始。如下所示： #include <stdio.h> #include
动态内存分布和结构体
最新发布
05-30
动态内存分配是指程序在运行过程中根据需要动态地申请内存空间。C语言提供了两个函数malloc()和free()来实现动态内存分配，通过malloc函数可以动态地分配内存，而通过free函数可以释放已经分配的内存。 结构体是C语言中的一种用户自定义数据类型，它可以包含多个不同类型的成员变量。结构体可以用来组织复杂的数据结构，例如链表、树等。结构体可以通过“.”运算符访问其中的成员变量。 如果结合起来说，动态内存分配可以为结构体提供更加灵活的内存管理方式，例如在需要动态创建一个结构体对象时，可以使用malloc函数动态分配内存空间，然后再对成员变量进行初始化。在使用完毕后，还需要使用free函数释放分配的内存空间，以避免内存泄漏等问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值