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

最新推荐文章于 2024-05-11 08:42:26 发布
最新推荐文章于 2024-05-11 08:42:26 发布
阅读量3.2k 收藏 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;
}

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

 

ele_Maker_Ou
关注
  • 7
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
可以用malloc给结构体指针变量分配动态内存空间_指针——为你的C语言注入灵魂...
weixin_39651735的博客
12-03 3323
0x00众所周知，指针是C语言的核心，没有搞懂指针就相当于没有学过C语言。今天我们就来仔细盘一下指针这个玩意。本文正确食用方法：1.没了解过指针的可以学习指针 2.学习过指针但忘的差不多的可以用以回顾3.等未来忘了后用以温习指针(笔者写本文目的(ง •_•)ง)0x01什么是指针指针是指向另一数据对象的变量(加粗)，指针变量储存了它所指数据对象的地址信息。0x02如...
结构体指针变量及结构体内存的开辟
bsp_mrLI的博客
08-04 810
定义方式也较简单 如先定义一个结构体数组 struct stu-info stu01,那么如果需要一个指针指向这个数组，指针就应当定义为struct stu_info *p 这时p就能指向结构体数组stu01,其余指针的用法也就跟普通指针变量类似。1，找成员内占用空间最大的成员类型，以它的占用空间作为最小开辟单位，如结构体内为char short 则按2字节为最小开辟单位，如结构体内为 char short int则按4字节为最小开辟单位。占1字节后面空1字节。.
C语言 数组-结构体-指针
weixin_42522386的博客
06-10 1810
变量 变量是计算机这存储的数据，并且这个数据是可以变化的。但数据并不是直接存放在内存中，而是先申请内存空间（按照变量的类型申请一个合适大小的空间），然后将变量值放入空间中。 int a = 5； 与 int a； a = 5；等价，都是先申明一个int空间，int占用4个字节的内存，然后再将"5"存储到这个4个字节中。 int main(void) { printf("%d\n",sizeof(int));//占4个字节 printf("%d\n",sizeof(float));//占4字节 pri
【C语言】17_结构体实现动态数组（动态分配内存）
最新发布
m0_46301523的博客
05-11 115
【代码】【C语言】结构体实现动态数组（动态分配内存）
C语言知识点小结 | 指针 数组 结构体 堆栈 内存分配
一个博客
04-14 1011
不掌握指针就是没有掌握C的精华 地址指向该变量单元，地址即指针 在C/C++语言中定义一个指针，就是在栈区开辟一个内存空间用来存放它指向的内存地址，然后给指针赋值，就是把地址值赋值给刚才开辟的内存空间，然后通过访问该内存中的地址值来间接访问该地址下存放的数据。 指针可以有指针吗？ 有。指针可以指向一份普通类型的数据，例如 int、double、char 等，也可以指向一份指针类型的数据，例如 int *、double *、char * 等。 如果一个指针指向的是另外一个指针，我们就称它为二级指针，或者指向指
C语言之指针的基础与存储空间的分配-诺禾
yyone123的博客
08-05 1653
1.指针基础 泛型指针与类型转换泛型指针和类型转换是用来跨越和覆盖C语言的类型系统的途径。泛型指针指向某一数据而不需要理会数据的具体类型。类型转换允许临时地改变数据的类型。函数指针指针指向可执行代码段或指向调用可执行代码段的信息块，而不是指向某种具体数据。它们把函数当做一小段数据来存储和管理。 C语言之指针的基础与存储空间的分配 Figure 2.1. An illustration of some operations with pointers 对于其他类型的任何变量，除非我们显式地指定过，否则我们都不
结构体中动态内存的管理（malloc和free）
08-10
例如，如果你有一个结构体`struct student`，并且想要创建一个新的实例，你可以使用`malloc`来为这个结构体分配内存： ```c struct student *pstu = (struct student *)malloc(sizeof(struct student)); ``` 这将...
深入分析C语言中结构体指针的定义与引用详解
09-05
在C语言中，结构体是一种复合数据类型，它允许我们将...通过定义结构体指针，我们可以动态分配内存，引用结构体成员，以及高效地处理结构体数组。理解并熟练掌握结构体指针的使用对于编写高效、灵活的C程序至关重要。
结构体指针变量使用时的注意事项
08-03
3. **动态分配内存**：有时我们可能需要在运行时动态地创建结构体实例。这可以通过`malloc()`函数实现，它会返回一个新的内存块的地址，这个内存块足够存储指定大小的数据（这里是结构体）。例如： ```c struct ...
C语言 指针实验程序设计.rar_C语言实验程序设计 指针
09-20
5. **指针作为函数返回值**：函数可以返回一个指针，通常用于动态内存分配的情况，如`int *allocateMemory(int size)`。 6. **多级指针**：二级或多级指针可以指向指针本身，实现对指针的间接操作，常用于递归或...
深入理解C语言指针和结构体
06-12
C语言中的`malloc()`和`calloc()`函数用于动态分配内存，`free()`函数用于释放内存。动态内存管理提供了更大的灵活性，但需要程序员手动管理内存，避免内存泄漏和悬挂指针问题。 结构体是C语言中复合数据类型的一种...
C语言定义了一个结构体怎么分配内存？C\C++中结构体变量与结构体指针内存分配问题？
魏波
07-15 6549
C语言定义了一个结构体怎么分配内存？C\C++中结构体变量与结构体指针内存分配问题？
结构体中指针成员的动态分配
echo_bright_的博客
05-19 7862
示例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)
动态分配结构体空间并用指针进行操作
frueyang的博客
12-10 789
动态分配结构体空间并用指针进行操作 要求利用动态内存分配进行结构体指针的内存分配，然后设计函数，计算平均成绩，要求结构体指针作为函数参数，观察值的影响。 #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Student // 定义结构体类型，并声明别名 { ch...
C语言之指针、结构体、动态内存分配
zzjlhlcd的博客
11-07 147
在.cpp中，所有的成员函数，都可以操作该 静态成员变量 ------ 本例中，构造函数 操作 它。编译时，如果出现 不认识的 数据类型、函数--------把他们的头文件加上。编译------只编译 当前的 CPP文件 .h文件是不能编译的。则 2个类之间为 双向依赖-----强双向依赖-------导致 编译不过。静态成员函数 只能访问 静态成员变量。初学------只 编译当前的 cpp文件。-----肯定会 用到 静态成员函数。数学类-----工具类。为什么使用 静态成员变量？
C语言学习笔记——指针：动态内存分配
展翅飞翔mxq的博客
11-27 1344
C程序的内存映像 C程序的变量内存分配有三种： （1）从静态存储区分配：程序的全局变量和静态变量都在静态存储区上分配，且在程序编译时就已经分配好了，在程序运行期间都是存在的。只有在程序终止前，才被操作系统收回。 （2）在栈上分配：在执行函数调用时，函数内的局部变量及形参都是在栈上分配的，该函数执行结束时，这些内存被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是容量有限。 （3）从堆上分...
结构体、结构体指针的内存申请
qq_42543896的博客
07-03 5656
结构体、结构体指针的内存申请 、CSDN输入不同红色的字体 内存区间 在c语言中有4个内存区间，分别是代码区、全局变量和静态变量区、堆区和栈区，这四个区间相互扶持成为好兄弟。本文着重涉及堆区，主要针对包括结构体和结构体指针申请内存的过程的分析。 下面是一个结构体和结构体指针的内存从申请到释放的代码 #define _CRT_SECURE_NO_WARNINGS//vs编译器消除对scanf等函数的安全警告 #include <stdio.h> #include <stdlib.h>/
C语言结构体指针使用时出现的错误（没有给结构体分配内存）
kai123wen的博客
11-09 3750
最近学习数据结构，用C语言的结构体编写顺序表时出现了问题： 这是源代码： #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;malloc.h&gt; #define bool char #define true 1 #define false 0 #define MAXSIZE 6 struct SequenceList...
c语言结构体动态内存分配
03-31
C语言中，结构体是一种自定义的数据类型，可以将多个不同类型的变量组合在一起，形成一个新的数据类型。结构体的大小在编译时确定，但有时候我们需要在程序运行时动态地为结构体分配内存空间，这就是结构体的动态内存分配。 在C语言中，可以使用malloc函数来进行动态内存分配。malloc函数的原型如下： ```c void* malloc(size_t size); ``` 其中，size_t是一个无符号整数类型，表示要分配的内存空间的大小（以字节为单位）。malloc函数会在堆上分配一块指定大小的内存空间，并返回一个指向该内存空间的指针。 下面是一个示例代码，演示了如何使用动态内存分配来创建和释放结构体对象： ```c #include <stdio.h> #include <stdlib.h> typedef struct { int id; char name[20]; } Student; int main() { // 动态分配一个Student结构体对象 Student* student = (Student*)malloc(sizeof(Student)); if (student == NULL) { printf("内存分配失败\n"); return 1; } // 设置结构体成员的值 student->id = 1; strcpy(student->name, "Tom"); // 打印结构体成员的值 printf("学生ID：%d\n", student->id); printf("学生姓名：%s\n", student->name); // 释放动态分配的内存空间 free(student); return 0; } ``` 在上述代码中，首先使用malloc函数动态分配了一个Student结构体对象的内存空间，并将返回的指针强制转换为Student类型的指针。然后，通过指针访问结构体成员，并对其进行赋值和打印。最后，使用free函数释放了动态分配的内存空间。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值