分享一个结构体指针动态分配内存的C语言程序

最新推荐文章于 2024-08-27 23:06:02 发布
最新推荐文章于 2024-08-27 23:06:02 发布
阅读量3.3k 收藏 13
点赞数 7
分类专栏： C语言 结构体指针 文章标签： c语言 指针 malloc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ouguangjin/article/details/104346223
版权

C语言中不支持用变量来定义数组的个数，因此C语言中想要动态分配内存，常用的方法是指针+malloc()\calloc()\realloc()的方式。

这里仅针对结构体指针+calloc()实现“动态结构体数组”。这里之所以称之为”动态结构体数组“，是因为该种方法定义出来的本质上不是结构体数组，当在功能上却与结构体数组无大异。

同时在该程序中，我将结构体中的字符串数组全部定义为字符指针变量，并在其赋值时利用函数先为该字符指针变量分配最佳内存。

由此，利用该"动态结构体数组"，达到了内存的最佳利用。

程序中有详细的注释，有出错的地方，还望大家给予指正，下面附上代码。

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
/***
	0 - 结构体指针动态分配内存；1 - 静止结构体变量、数组  **/ 
#define MODE 0
/*******  技能结构体  ********/
typedef struct _skill
{
	char* pSkill_1;
	char* pSkill_2;
}structSkill;
/*******  英雄结构体（嵌套了技能结构体）  *******/
typedef struct _hearo
{
	int   id;
	char*  pName;
	int   age;
	char*  pPhone;
	
	structSkill sSkill;
}structHearo;
/************************************************************************/
/* 验证利用结构体指针传递函数形参的函数                                   */
/************************************************************************/
void Test( structHearo* spH )
{
	spH->age = 100;
	strcpy( spH->pName, "广州" );   // 这个地方传递了5个字节给地址pName所指的内存，倘若当时为pName所分配的内存小于5，则在释放该指针所指内存时会报错
}
/************************************************************************/
/* 获得包含结束符字符串的实际长度（相对应与定义长度）；
   注意，由于gets()得到的是以'\n'结束的字符串，暂不支持对其获得的字符串进行测量！
   输入：想要测量长度的字符串地址；输出：测量得到的字符串实际长度       */
/************************************************************************/
int Get_String_LEN( char* str )
{
	int i;
	for( i=0; i<50; i++ )
	{
		if( str[i] == '\0' )
			return i+1;
		else ;
	}
	return 0;
}
/************************************************************************/
/* 主函数                                                               */
/************************************************************************/
int main( )
{
	int i, num;
	char aTempName[50];   // 此字符数组做中间数组，用于姓名\电话号码长度的测量，应定义足够大
	/***
		定义结构体数组，并初始化  **/
	structHearo saHearo[2] = { {9527, "唐伯虎", 250, "13843818438", {"放屁", "飞天"}},
				   {9528, "点秋香", 16,  "52020205200", {"化妆", "美颜"}} 
							 };
#if MODE == 0    // 结构体指针动态分配内存模式
	/***
		定义结构体指针变量 **/
	structHearo* spHearo;
	printf("\n");
	printf("请输入想要添加的英雄个数：");
	scanf( "%d", &num );   // 获取英雄个数，用于结构体指针动态分配内存
//	spHearo = (structHearo*)malloc(sizeof(structHearo)*num);
	spHearo = calloc( num, sizeof(structHearo) );

	printf("%d\n", _msize(spHearo) );   // 该函数可以获取指针所指区域的字节大小
	/***
		循环打印结构体数组中的内容  **/
	printf("系统自带英雄：编号\t名字\t年龄\t电话\t\t技能\n");
	for( i=0; i<2; i++ )
	{
		printf("              %-4d\t%-6s\t%-3d\t%s\t%-4s %-4s\n", 
			   saHearo[i].id,saHearo[i].pName,saHearo[i].age,saHearo[i].pPhone,saHearo[i].sSkill.pSkill_1,saHearo[i].sSkill.pSkill_2 );
	}
	printf("\n");
	for( i=0; i<num; i++ )
	{
		printf("请输入自定义英雄%d信息：\n", i );
		printf("编号：");
		scanf_s( "%d", &((spHearo+i)->id), 4 );
		printf("姓名：");
		scanf_s( "%s", aTempName, 50 );      // 先将字符串存放在中间字符串变量下
		/***
			将该中间字符串变量送去测长度，并将返回的长度用于结构体数组下的指针变量的空间分配  **/
		spHearo[i].pName = calloc( Get_String_LEN( aTempName ), sizeof(char) ); 
		//printf("%d\n", Get_String_LEN( aTempName ) );
		//printf("%d\n", _msize( spHearo[i].name ) );  // 可以取消该两处注释，看一下结构体中的指针变量的内存空间分配情况
		strcpy_s( spHearo[i].pName,  Get_String_LEN( aTempName ), aTempName ); // 采用字符串复制函数为结构体中的字符串赋值
		printf("%d\n", _msize( spHearo[i].pName ) );

		printf("年龄：");
		scanf_s( "%d", &(spHearo[i].age), 4 );

		printf("电话：");
		scanf_s( "%s", aTempName, 50 );      // 先将字符串存放在中间字符串变量下
		/***
			将该中间字符串变量送去测长度，并将返回的长度用于结构体数组下的指针变量的空间分配  **/
		spHearo[i].pPhone = calloc( Get_String_LEN( aTempName ), sizeof(char) ); 
		strcpy_s( spHearo[i].pPhone,  Get_String_LEN( aTempName ), aTempName ); // 采用字符串复制函数为结构体中的字符串赋值
		printf("%d\n", _msize( spHearo[i].pPhone ) );

		printf("技能1：");
		scanf_s( "%s", aTempName, 50 );      // 先将字符串存放在中间字符串变量下
		/***
			将该中间字符串变量送去测长度，并将返回的长度用于结构体数组下的指针变量的空间分配  **/
		spHearo[i].sSkill.pSkill_1 = calloc( Get_String_LEN( aTempName ), sizeof(char) ); 
		strcpy_s( spHearo[i].sSkill.pSkill_1,  Get_String_LEN( aTempName ), aTempName ); // 采用字符串复制函数为结构体中的字符串赋值
		printf("%d\n", _msize( spHearo[i].sSkill.pSkill_1 ) );

		printf("技能2：");
		scanf_s( "%s", aTempName, 50 );      // 先将字符串存放在中间字符串变量下
		/***
			将该中间字符串变量送去测长度，并将返回的长度用于结构体数组下的指针变量的空间分配  **/
		spHearo[i].sSkill.pSkill_2 = calloc( Get_String_LEN( aTempName ), sizeof(char) ); 
		strcpy_s( spHearo[i].sSkill.pSkill_2,  Get_String_LEN( aTempName ), aTempName ); // 采用字符串复制函数为结构体中的字符串赋值
		printf("%d\n", _msize( spHearo[i].sSkill.pSkill_2 ) );
	}
	printf("%d\n", _msize(spHearo) );

	printf("自定义  英雄：编号\t名字\t年龄\t电话\t\t技能\n");
	for( i=0; i<num; i++ )
		{
			printf("              %-4d\t%-6s\t%-3d\t%s\t%-4s %-4s\n", 
				   spHearo[i].id,spHearo[i].pName,spHearo[i].age,spHearo[i].pPhone,spHearo[i].sSkill.pSkill_1,spHearo[i].sSkill.pSkill_2);
		}

	Test( spHearo );
	printf("更改后自定义英雄：编号\t名字\t年龄\t电话\t\t技能\n");
	for( i=0; i<num; i++ )
	{
		printf("              %-4d\t%-6s\t%-3d\t%s\t%-4s %-4s\n", 
			spHearo[i].id,spHearo[i].pName,spHearo[i].age,spHearo[i].pPhone,spHearo[i].sSkill.pSkill_1,spHearo[i].sSkill.pSkill_2);
	} 

	for( i=0; i<num; i++ )
	{
		free( spHearo[i].sSkill.pSkill_1 );
		spHearo[i].sSkill.pSkill_1 = NULL;
		free( spHearo[i].sSkill.pSkill_2 );
		spHearo[i].sSkill.pSkill_2 = NULL;
	}
	for( i=0; i<num; i++ )
	{
		free( spHearo[i].pName );
		spHearo[i].pName = NULL;
		free( spHearo[i].pPhone );
		spHearo[i].pPhone = NULL;
	}
	free( spHearo );    // 释放内存空间
	spHearo = NULL;     // 空指针

#elif MODE == 1    // 静止结构体变量、数组 
	/***
		定义2组结构体；由于c语言中不可以以变量定义数组个数，因此直接定义结构体数组，不能动态构建结构体数组的个数  **/
	structHearo sHearo[2];     
	/*****	循环打印结构体数组中的内容  ***/
	printf("系统自带英雄：编号\t名字\t年龄\t电话\t\t技能\n"); 
	for( i=0; i<2; i++ )
	{
		printf("              %-4d\t%-6s\t%-3d\t%s\t%-4s %-4s\n", 
			   saHearo[i].id,saHearo[i].pName,saHearo[i].age,saHearo[i].pPhone,saHearo[i].sSkill.pSkill_1,saHearo[i].sSkill.pSkill_2 );
	}
	/*****	动态录入结构体变量中的成员值  ***/
	printf("\n");
	for( i=0; i<2; i++ )
	{
		printf("请输入自定义英雄%d信息：\n", i+1 );
		printf("编号：");
		scanf_s( "%d", &(sHearo[i].id), 4 );

		printf("姓名：");
		scanf_s( "%s", aTempName, 50 );      // 先将字符串存放在中间字符串变量下
		/***
			将该中间字符串变量送去测长度，并将返回的长度用于结构体数组下的指针变量的空间分配  **/
		sHearo[i].pName = calloc( Get_String_LEN( aTempName ), sizeof(char) ); 
		//printf("%d\n", Get_String_LEN( aTempName ) );
		//printf("%d\n", _msize( spHearo[i].name ) );  // 可以取消该两处注释，看一下结构体中的指针变量的内存空间分配情况
		strcpy_s( sHearo[i].pName,  Get_String_LEN( aTempName ), aTempName ); // 采用字符串复制函数为结构体中的字符串赋值
		printf("%d\n", _msize( sHearo[i].pName ) );

		printf("年龄：");
		scanf_s( "%d", &(sHearo[i].age), 4 );

		printf("电话：");
		scanf_s( "%s", aTempName, 50 );      // 先将字符串存放在中间字符串变量下
		/***
			将该中间字符串变量送去测长度，并将返回的长度用于结构体数组下的指针变量的空间分配  **/
		sHearo[i].pPhone = calloc( Get_String_LEN( aTempName ), sizeof(char) ); 
		strcpy_s( sHearo[i].pPhone,  Get_String_LEN( aTempName ), aTempName ); // 采用字符串复制函数为结构体中的字符串赋值
		printf("%d\n", _msize( sHearo[i].pPhone ) );
		
		printf("技能1：");
		scanf_s( "%s", aTempName, 50 );      // 先将字符串存放在中间字符串变量下
		/***
			将该中间字符串变量送去测长度，并将返回的长度用于结构体数组下的指针变量的空间分配  **/
		sHearo[i].sSkill.pSkill_1 = calloc( Get_String_LEN( aTempName ), sizeof(char) ); 
		strcpy_s( sHearo[i].sSkill.pSkill_1,  Get_String_LEN( aTempName ), aTempName ); // 采用字符串复制函数为结构体中的字符串赋值
		printf("%d\n", _msize( sHearo[i].sSkill.pSkill_1 ) );
		
		printf("技能2：");
		scanf_s( "%s", aTempName, 50 );      // 先将字符串存放在中间字符串变量下
		/***
			将该中间字符串变量送去测长度，并将返回的长度用于结构体数组下的指针变量的空间分配  **/
		sHearo[i].sSkill.pSkill_2 = calloc( Get_String_LEN( aTempName ), sizeof(char) ); 
		strcpy_s( sHearo[i].sSkill.pSkill_2,  Get_String_LEN( aTempName ), aTempName ); // 采用字符串复制函数为结构体中的字符串赋值
		printf("%d\n", _msize( sHearo[i].sSkill.pSkill_2 ) );
	}

	printf("自定义  英雄：编号\t名字\t年龄\t电话\t\t技能\n");
	for( i=0; i<2; i++ )
	{
		printf("              %-4d\t%-6s\t%-3d\t%s\t%-4s %-4s\n", 
			sHearo[i].id,sHearo[i].pName,sHearo[i].age,sHearo[i].pPhone,sHearo[i].sSkill.pSkill_1,sHearo[i].sSkill.pSkill_2);
	}

	Test( sHearo );
	printf("更改后自定义英雄：编号\t名字\t年龄\t电话\t\t技能\n");
	for( i=0; i<2; i++ )
	{
		printf("              %-4d\t%-6s\t%-3d\t%s\t%-4s %-4s\n", 
			sHearo[i].id,sHearo[i].pName,sHearo[i].age,sHearo[i].pPhone,sHearo[i].sSkill.pSkill_1,sHearo[i].sSkill.pSkill_2);
	}
	for( i=0; i<2; i++ )     // 释放内存
	{
		free( sHearo[i].sSkill.pSkill_1 );
		sHearo[i].sSkill.pSkill_1 = NULL;
		free( sHearo[i].sSkill.pSkill_2 );
		sHearo[i].sSkill.pSkill_2 = NULL;
	}
	for( i=0; i<2; i++ )   // 释放内存
	{
		free( sHearo[i].pName );
		sHearo[i].pName = NULL;
		free( sHearo[i].pPhone );
		sHearo[i].pPhone = NULL;
	}
#endif
	return 0;
}

本程序，倾注了笔者的不少心血。未经作者允许，严禁转载与商用！！

 

c语言结构体指针动态存储空间,[转载]【C语言】动态分配内存、void指针、结构体指针（部分内容摘自《c程序设计...
weixin_30728435的博客
05-17 739
程序的内存分配一个由C/C++编译的程序占用的内存分为以下几个部分：1、栈区(stack)：由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。2、全局区(静态区)(static)：全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。3、堆区(heap)：一般...
c语言结构体指针动态存储空间,c语言指针与结构体之内存动态分配
weixin_36068140的博客
05-17 1626
struct dangdangtest{char email[];char name[];char addr[];int num;int bugnum;char tel[];char phone[];double RMB;};void main2(){//struct dangdangtest dd[1024*1024];//数组越界//动态分配一个元素struct dangdangtest *p...
C语言重难点总结（2）-指针操作与结构体、动态内存
最新发布
weixin_71180088的博客
08-27 1732
1.分治策略： 是将规模比较大的问题可分割成规模较小的相同问题。问题不变， 规模变小。扩容情况2：如果后空间不足就会额外另外开一块大空间，将原始空间的数据拷贝到新空间当中并进行原空间的释放，返回新空间的地址。递归： 若一个函数直接地或间接地调用自己，则称这个函数是递归的函数。分解： 将问题划分成一些子问题， 子问题的形式与原问题一样， 只是规模更小。如果子问题的规模足够小， 则停止递归， 直接求解。3) 使用小规模的解，可以合并成， 该问题原规模的解。1) 该问题的规模缩小到一定的程度就可以容易地解决。
C语言之指针、结构体、动态内存分配
zzjlhlcd的博客
11-07 290
/等号左边定义了1个数组，现在要给数组的20个元素赋值-----等号右边是每个元素 的 值 数组名-----是h字符的地址。//就是简单的赋值， = 两边的类型一致 就可以了----因为不是定义的同时进行初始化。//等号左边 是 地址变量-----等号右边 也必须是 地址。//就是简单的赋值， = 两边的类型一致 就可以了。2、sizeof()的参数为 真数组名、假数组名时，结果不同。指针数组 int *a[20]={&a,&b};
结构体中指针成员的动态分配
echo_bright_的博客
05-19 7917
示例1：typedef struct _a{ int type; char dat[1]; }A;int main(void) { char* ptr = "hello_world"; A *a = malloc(sizeof(A) + strlen(ptr) + 1); memcpy(a->dat, ptr, strlen(ptr) + 1)
C语言实现学生信息管理系统(结构体指针、动态内存)
weixin_42617375的博客
11-25 3931
一.功能： 1.连续增加学生信息 2.删除学生信息 3.修改学生信息 4.查找学生信息 5.列出学生信息 6.保存学生信息到文件 7.从文件中加载学生信息 二.学生信息结构体 首先定义一个学生结构体，再直接定义一个全局指针变量stu,让下面的函数都可以访问到这个动态内存 学生类结构体的信息大家可以自己添加。 struct Student{ int no; //学号 char name[4...
c语言字符指针分配内存,关于指针内存分配问题
weixin_26731219的博客
05-17 1596
该楼层疑似违规已被系统折叠隐藏此楼查看此楼程序的可用内存有三种：静态存储区、栈存储区、堆存储区。静态存储区是全部变量和static变量占据的，在程序开始运行之前就分配好了，它们从不释放；栈存储区在函数调用前分配，函数调用返回时释放；而堆存储区的分配释放完全在程序员手中，你用malloc/free进行分配与释放。每个变量都要有它的内存分配，如：static int global_var;即是在静态...
C语言 结构体指针强制转换,c中结构体指针的强制类型转换
weixin_42506706的博客
05-20 4779
1、结构体到结构体指针之间的转换a、结构体指针的强制类型转换即结构体的数据成员在内存段当中的重新分配，结构体的存储“内存对齐”请参看上篇博客，该论述实例如下：#include #include struct A{int num;};struct B{int num;char type;int age;};int main(){struct A a;a.num = 5;char* tmp1 = (c...
C语言 malloc 为结构体成员指针申请内存
Turf96的博客
10-24 9765
问题：当一个结构体的成员为指针类型时，为这个结构体申请内存时，并不会给指针成员分配内存。 程序如下： #include <stdio.h> #include <stdlib.h> typedef struct example { int *a; char *b; }example_t; int main(int argc, char** argv) { ex...
C语言中指向结构的指针的动态内存分配
新华编程特战队
07-17 357
指向结构的指针包含整个结构的添加。它用于创建复杂的数据结构，如链表、树、图等。可以使用称为箭头运算符 （ -> ） 的特殊运算符来访问结构的成员。
C语言之_动态内存分配、结构体指针、链表
走向CTO的路上...
08-27 1094
1、动态内存分配 malloc free 1.1动态内存分配---自动内存分配 区别 int main(int argc,char *argv[]) { int a=10; int *p=(int *)malloc(4); *p=10; return 0; } 更实用的例子 是Student中的name name 是 地址变量----随机数
数据结构基础——指针及动态内存分配(malloc)
sweetfather的博客
11-02 1256
一、指针 C语言中的指针是一种数据类型，比如说我们用int *a;就定义了一个指针a，它指向一个int类型的数。但是这个指针是未初始化的，所以，一般的，我们都在创建指针时初始化它，以免出错，在还不吃的它该指向谁的时候，我们就这样创建 int *a=NULL; /* NULL表示的地址是0*00000000 也就是空，实际上，NULL就等于0，只不过用于指针时，通常用NULL，便于阅读。
用指针实现内存动态分配
m0_74073121的博客
04-09 1405
如果要确保指针学懂了，那么要确认这几点：1.掌握指针作为函数的参数进行熟练编程，通过函数调用改变主调函数变量的值 2.利用指针进行数组相关操作（(1) 实参是数组名 (2) 形参是指针变量 可以写成数组形式） 3.能够使用字符串常用处理函数进行编程（包含在头文件string.h里面），并能使用字符指针进行字符串相关操作（利用指针指向系统原有的字符串） 4.通过指针实现动态内存分配。虽然存储块是动态分配的，但它的大小在分配后也是确定的，不要越界使用。到特定指针类型，赋给一个指针】。
结构体指针内的指针变量成员的内存分配
热门推荐
风尘叹
02-02 1万+
但凡有指针的内存分配，都必须为每个指针变量单独分配内存空间！
C语言结构体数组指针的动态分配
EFM32的专栏
03-03 4990
目前有在开发一个linux的底层驱动，涉及到很多种Modbus设备。程序是通过解析json配置文件，来获知到底是访问的什么设备。刚开始，由于485设备的种类并不是很多，而且主机的每个485口下挂的设备数目，也不是很多，因此采用了静态结构体数组的方式来做设备属性和数值的缓存（Shadow）。但是目前485种类是越来越多，而且规定每个485口下，最多可以挂64个设备，如果全部用静态数组的形式，则够主机...
void函数调用时显示不允许使用不完整的_[读书笔记]CSAPP：22[VB]内存分配：显示分配器
weixin_39743414的博客
10-23 225
视频地址：【精校中英字幕】2015 CMU 15-213 CSAPP 深入理解计算机系统 课程视频_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili​www.bilibili.comhttps://www.bilibili.com/video/BV1iW411d7hd?p=20​www.bilibili.com课件地址：http://www.cs.cmu.edu/afs/cs/academic/...
【C语言】自定义结构体类型及内存分布
qq_40663638的博客
04-29 725
自定义结构体类型及内存分布 1、结构体：结构体是一些值得集合，这些值成为成员变量，成员的每个变量可以是不同的类型，例如标量，指针，数组，其他的结构体. 2、结构体定义 struct Peo_data { char name[10]; int age; }; struct为结构体的关键字，Peo_data,是我们为这个结构体起的名字。里面的成员包含一个数组，和一个整形变量。 当我们使用它的时候我们 ...
C语言——结构体、动态存储分配、链表
mango660的博客
03-10 1275
文章目录结构体引入结构体定义结构的一般形式：结构体变量的引用结构体变量的初始化结构体数组指向结构体类型数据的指针结构指针变量作函数参数将一个结构体变量的值传递给另一个函数，有一下方法：动态存储分配常用的内存管理函数：malloc 函数 结构体 引入结构体 问题定义：将不同类型的数据组合成一个有机整体 举例：学生（学号、姓名、性别、年龄、地址）等属性： struct { int num; cha...
c语言结构体动态内存分配
03-31
结构体的大小在编译时确定，但有时候我们需要在程序运行时动态地为结构体分配内存空间，这就是结构体的动态内存分配。 在C语言中，可以使用malloc函数来进行动态内存分配。malloc函数的原型如下： ```c void* ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值