结构体基础 数组 做函数参数

最新推荐文章于 2022-10-06 15:57:06 发布
最新推荐文章于 2022-10-06 15:57:06 发布
阅读量1.3k 收藏
点赞数
分类专栏： c++ 就业
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/user_define_race/article/details/43370697
版权 
#include "stdio.h"
#include "stdlib.h"
#include "string.h"



//两个结构体变量之间的copy行为
struct Teacher
{
	char name[62];//64
	int age ; //4
};


//两个结构体变量之间可以copy数据，这个是c编译器给我提供的行为，我们要顺从
void main81()
{
	//告诉编译器要分配内存
	//第一种方法
	struct  Teacher t1 = {"dddd", 40};
	struct  Teacher t2 = {"t2", 50};
	struct  Teacher *  p = NULL;
	t2 = t1; //这个是=号操作，不是初始化
	p = &t2;

	printf("sizeof(t1): %d\n", sizeof(t1));
	printf("%s\n", t2.name);
	printf("%s\n", p->name);

	//用memcpy函数完成两个结构体变量之间的copy
	memcpy(&t2, &t1, sizeof(struct  Teacher));

	printf("%s\n", t2.name);
	printf("%s\n", p->name);

	//我们自己手工的域赋值
	//copyObj01(t1, t2);

	system("pause");
}

void copyObj01(struct  Teacher from, struct  Teacher to)
{
	memcpy(&to, &from, sizeof(struct  Teacher));
}

void  copyObj02(struct  Teacher *from, struct  Teacher *to)
{
	memcpy(to, from, sizeof(struct  Teacher));
}

//两个结构体变量之间可以copy数据，这个是c编译器给我提供的行为，我们要顺从
void main01()
{
	//告诉编译器要分配内存
	//第一种方法
	struct  Teacher t1 = {"dddd", 40};
	struct  Teacher t2 = {"t2", 50};
	//int a ;
	//结构体类型是复杂类型，结构体指针出来，就是一级指针
	struct  Teacher *  p = NULL;


	//我们自己手工的域赋值
	copyObj01(t1, t2);
	copyObj02(&t1, &t2);

	printf("%s\n", t2.name);
	printf("%s\n", p->name);
	
	system("pause");
}

struct  Teacher *  creatTArray(int count)
{
	int i = 0;
	struct  Teacher*p1 = (struct  Teacher *)malloc(count*sizeof(struct  Teacher ));
	if (p1 == NULL)
	{
		return NULL;
	}
	for (i=0; i<count; i++)
	{
		memset(&p1[i], 0, sizeof(struct  Teacher));
		memset(p1+i, 0, sizeof(struct  Teacher));
	}
	return p1;
}

void main7()
{
	//告诉编译器要分配内存
	//第一种方法
	struct  Teacher tArray[10];
	struct  Teacher *  pa= NULL;
	tArray[0].age = 10;
	
	creatTArray(2);
	pa[0].age = 10;

	system("pause");
}



#include "stdio.h"
#include "stdlib.h"
#include "string.h"

struct  Teacher_
{
	char name[62];//64
	int age;
};
int  printArray(struct Teacher_ * pArray,int num)
{
	int i=0;
	for(i=0;i<num;i++)
	{
		printf("%d\n",pArray[i].age);
	}
	return 0;
}
int sortArray(struct Teacher_ *pArray,int num)
{
   	int i=0,j=0;
	struct Teacher_ tmp;
	for(i=0;i<num;i++)
	{
		for(j=i+1;j<num;j++)
		{
			if(pArray[i].age<pArray[j].age)
			{
				tmp=pArray[i];
				pArray[i]=pArray[j];
				pArray[j]=tmp;
			}
		}
		printf("%d\n",pArray[i].age);
	}
	return 0;
}
void main()
{
	int i=0;
	struct  Teacher_ tArray[10];
	for(i=0;i<4;i++)
	{
		int tmp=0;
		printf("请输入age:");
		scanf("%d",&tArray[i].age);
	}
	printArray(tArray,4);
	sortArray(tArray,4);
	system("pause");
}

#include "stdio.h"
#include "stdlib.h"
#include "string.h"


//两个结构体变量之间的copy行为
struct Teacher
{
	char name[62];//64
	int age ; //4
};

int printtArray(struct Teacher *pArray, int num)
{
	int i = 0;
	for (i=0; i<num; i++)
	{
		printf("%d ", pArray[i].age);
	}
	return 0;
}

int sorttArray(struct Teacher *pArray, int num )
{
	int i = 0, j = 0;
	struct Teacher tmp;
	for (i=0; i<4; i++)
	{
		for (j=i+1; j<num; j++)
		{
			if (pArray[i].age < pArray[j].age)
			{
				tmp = pArray[i];
				pArray[i] = pArray[j];
				pArray[j] = tmp;
			}
		}
	}
	return 0;
}

struct Teacher *  creatTArray(int count)
{
	int i = 0;
	struct  Teacher*p1 = (struct  Teacher *)malloc(count*sizeof(struct  Teacher ));
	if (p1 == NULL)
	{
		return NULL;
	}
	for (i=0; i<count; i++)
	{
		memset(&p1[i], 0, sizeof(struct  Teacher));
		memset(p1+i, 0, sizeof(struct  Teacher));
	}
	return p1;
}

void main()
{
	int i = 0;
	struct Teacher *pArray  = creatTArray(4);
	if (pArray == NULL)
	{
		return ;
	}

	for (i=0; i<4; i++)
	{
		int tmp = 0;
		printf("\n请输入age: " );
		scanf("%d", &(pArray[i].age));
	}

	printf("\nsorted before\n");
	printtArray(pArray, 4 );

	printf("\nsorted after\n");
	sorttArray(pArray, 4 );
	printtArray(pArray, 4 );


	system("pause");
}

进阶2

#include "stdio.h"
#include "stdlib.h"
#include "string.h"


//两个结构体变量之间的copy行为
struct AdvTeacher
{
	char name[64];//64
	char *a_name; //4
	int age ; //4
};

int printtArray(struct AdvTeacher *pArray, int num)
{
	int i = 0;
	for (i=0; i<num; i++)
	{
		printf("\n %d ", pArray[i].age);
		printf("%s ", pArray[i].name);
		printf("%s ", pArray[i].a_name);
	}
	return 0;
}

int sorttArray(struct AdvTeacher *pArray, int num )
{
	int i = 0, j = 0;
	struct AdvTeacher tmp;
	for (i=0; i<4; i++)
	{
		for (j=i+1; j<num; j++)
		{
			if (pArray[i].age < pArray[j].age)
			{
				tmp = pArray[i];
				pArray[i] = pArray[j];
				pArray[j] = tmp;
			}
		}
	}
	return 0;
}

struct AdvTeacher*  creatTArray(int count)
{
	int i = 0;
	struct  AdvTeacher*p1 = (struct  AdvTeacher *)malloc(count*sizeof(struct  AdvTeacher ));
	if (p1 == NULL)
	{
		return NULL;
	}
	for (i=0; i<count; i++)
	{
		memset(&p1[i], 0, sizeof(struct  AdvTeacher));
		memset(p1+i, 0, sizeof(struct  AdvTeacher));
		p1[i].a_name = (char *)malloc(128*sizeof(char)) ;// char buf[128*4]
		memset(p1[i].a_name , 0, 128*sizeof(char));
	}
	return p1;
}

void freeTArray(struct AdvTeacher* tArray, int num)
{
	int i = 0;

	if (tArray == NULL)
	{
		return ;
	}

	for (i=0; i<num; i++)
	{
		char *p = tArray[i].a_name; //为什么这里需要释放
		if (p != NULL)
		{
			free(p);
		}

		//辅导的时候，如果谁犯这个错误，拿10元买水果。立字
		if (tArray[i].name != NULL) //这个地方要怎么做？
		{
			free(tArray[i].name);
		}
	}

	if (tArray != NULL)
	{
		free(tArray);
		tArray = NULL; //垃圾话语
	}
}

void main()
{
	int i = 0;
	struct AdvTeacher *pArray  = creatTArray(4);
	if (pArray == NULL)
	{
		return ;
	}

// 	{
// 		//p
// 		char *p = (char *)malloc(100);
// 		free(p+1);
// 	}

	for (i=0; i<4; i++)
	{
		int tmp = 0;

		char *p = pArray[i].a_name;

		printf("\n请输入age: " );
		scanf("%d", &(pArray[i].age) ) ;

		printf("\n请输入名字: " );
		scanf("%s", pArray[i].name);

		printf("\n请输入别名: " );
		scanf("%s", p);
	}

	printf("\nsorted before\n");
	printtArray(pArray, 4 );

	printf("\nsorted after\n");
	sorttArray(pArray, 4 );
	printtArray(pArray, 4 );

	freeTArray(pArray, 4);


	system("pause");
}


综合

#include "stdio.h"
#include "stdlib.h"
#include "string.h"


//两个结构体变量之间的copy行为
struct AdvAdvTeacher
{
	char name[64];//64
	char *a_name; //4 //结构体里面套一级指针
	int age ; //4
	char **  stuname;//
};

int printtArray(struct AdvAdvTeacher *pArray, int num)
{
	int i = 0;
	int j = 0;
	for (i=0; i<num; i++)
	{
		printf("\n %d ", pArray[i].age);
		printf("%s ", pArray[i].name);
		printf("%s ", pArray[i].a_name);

		for (j=0; j<3; j++)
		{
			char **p2 = pArray[i].stuname;
			printf("%s ", p2[j]);
		}
	}
	return 0;
}

int sorttArray(struct AdvAdvTeacher *pArray, int num )
{
	int i = 0, j = 0;
	struct AdvAdvTeacher tmp;
	for (i=0; i<4; i++)
	{
		for (j=i+1; j<num; j++)
		{
			if (pArray[i].age < pArray[j].age)
			{
				tmp = pArray[i];
				pArray[i] = pArray[j];
				pArray[j] = tmp;
			}
		}
	}
	return 0;
}

struct AdvAdvTeacher*  creatTArray(int count)
{
	int i = 0;int j = 0;
	struct  AdvAdvTeacher*p1 = (struct  AdvAdvTeacher *)malloc(count*sizeof(struct  AdvAdvTeacher ));
	if (p1 == NULL)
	{
		return NULL;
	}
	for (i=0; i<count; i++)
	{
		memset(&p1[i], 0, sizeof(struct  AdvAdvTeacher));
		memset(p1+i, 0, sizeof(struct  AdvAdvTeacher));
		p1[i].a_name = (char *)malloc(128*sizeof(char)) ;// char buf[128*4]
		memset(p1[i].a_name , 0, 128*sizeof(char));
		//p1[i].stuname = (char **)malloc(100);

		{
			char **p2 = (char **)malloc(3*sizeof(char *));
			for (j=0; j<3; j++)
			{
				p2[j] =(char *) malloc(128*sizeof(char));
				memset(p2[j] , 0, 128*sizeof(char));
			}
			p1[i].stuname = p2;
		}
	}
	return p1;
}


void free2p(char **p ,int num)
{
	int i = 0; int j = 0;
	for (i=0; i<num; i++)
	{
		if (p[i] != NULL) 
		{
			free(p[i] );
		}			
	}
	free(p);
}
void freeTArray(struct AdvAdvTeacher* tArray, int num)
{
	int i = 0;

	if (tArray == NULL)
	{
		return ;
	}

	for (i=0; i<num; i++)
	{
		char *p = tArray[i].a_name; //为什么这里需要释放
		if (p != NULL)
		{
			free(p);
		}

// 		//辅导的时候，如果谁犯这个错误，拿10元买水果。立字
// 		if (tArray[i].name != NULL) //这个地方要怎么做？
// 		{
// 			free(tArray[i].name);
// 		}
		//释放手工的二维内存
		if (tArray[i].stuname != NULL) 
		{
			free2p(tArray[i].stuname, 3);
		}
	}

	if (tArray != NULL)
	{
		free(tArray);
		tArray = NULL; //垃圾话语
	}
}

void main()
{
	int i = 0; int j = 0;
	struct AdvAdvTeacher *pArray  = creatTArray(4);
	if (pArray == NULL)
	{
		return ;
	}

	// 	{
	// 		//p
	// 		char *p = (char *)malloc(100);
	// 		free(p+1);
	// 	}

	for (i=0; i<2; i++)
	{
		int tmp = 0;

		char *p = pArray[i].a_name;

		printf("\n请输入age: " );
		scanf("%d", &(pArray[i].age) ) ;

		printf("\n请输入名字: " );
		scanf("%s", pArray[i].name);

		printf("\n请输入别名: " );
		scanf("%s", p);

		for (j=0; j<3; j++)
		{
			char **p2 = pArray[i].stuname;
			printf("\n请输入学生的名字");
			scanf("%s", p2[j]);
		}
	}

	printf("\nsorted before\n");
	printtArray(pArray, 2 );

	printf("\nsorted after\n");
	sorttArray(pArray, 2 );
	printtArray(pArray, 2 );

	freeTArray(pArray, 2);


	system("pause");
}



#include "stdio.h"
#include "stdlib.h"
#include "string.h"


//两个结构体变量之间的copy行为
struct AdvAdvTeacher
{
	char name[64];//64
	char *a_name; //4 //结构体里面套一级指针
	int age ; //4
};

struct AdvAdvTeacher*  creatTArray(int count)
{
	int i = 0;int j = 0;
	struct  AdvAdvTeacher*p1 = (struct  AdvAdvTeacher *)malloc(count*sizeof(struct  AdvAdvTeacher ));
	if (p1 == NULL)
	{
		return NULL;
	}
	for (i=0; i<count; i++)
	{
		memset(&p1[i], 0, sizeof(struct  AdvAdvTeacher));
		p1[i].a_name = (char *)malloc(128*sizeof(char)) ;// char buf[128*4]
		memset(p1[i].a_name , 0, 128*sizeof(char));
		//p1[i].stuname = (char **)malloc(100);
	}
	return p1;
}
void freeTArray(struct AdvAdvTeacher* tArray, int num)
{
	int i = 0;

	if (tArray == NULL)
	{
		return ;
	}

	for (i=0; i<num; i++)
	{
		char *p = tArray[i].a_name; //为什么这里需要释放
		if (p != NULL)
		{
			free(p);
		}
	}

	if (tArray != NULL)
	{
		free(tArray);
		tArray = NULL; //垃圾话语
	}
}

//深copy 浅copy
void  copyObj03(struct  AdvAdvTeacher *from, struct  AdvAdvTeacher *to)
{
	memcpy(to, from, sizeof(struct  AdvAdvTeacher));
	to->a_name = (char *)malloc(128);
	strcpy(to->a_name, from->a_name);
}

void main01()
{
	//struct AdvAdvTeacher t1;
	//struct AdvAdvTeacher t2;

	struct AdvAdvTeacher*  p1 =creatTArray(1);
	struct AdvAdvTeacher*  p2 =creatTArray(1);

	printf("\n请输入age: " );
	//scanf("%d", &(p1->age) ) ;
	p1->age = 11;

	printf("\n请输入名字: " );
	//scanf("%s", p1->name);
	strcpy(p1->name, "11");

	printf("\n请输入别名: " );
	//scanf("%s", p1->a_name);
	strcpy(p1->a_name ,"2");

	(*p2) = (*p1); 

	freeTArray(p1, 1);
	freeTArray(p2, 1);
	system("pause");
}

void main()
{
	struct AdvAdvTeacher t1;
	struct AdvAdvTeacher t2;
	t1.age = 11;
	t1.a_name = (char *)malloc(100);
	strcpy(t1.a_name, "t1111");

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

	//t2 = t1; //编译器赋值操作 编译器等号=操作
	copyObj03(&t1, &t2);
	if (t1.a_name != NULL)
		free(t1.a_name);

	if (t2.a_name != NULL)
		free(t2.a_name);
	system("pause");
}


user_define_race
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
结构体数组及结构体变量作函数参数
qq_45613195的博客
08-17 3338
结构体变量可以像普通变量一样作为函数的参数。
结构体作为函数参数
frueyang的博客
12-10 727
结构体作为函数参数 当结构体作为函数参数时，参数传递的方式为“传值调用”，即将当前的值复制一份给函数的接口参数。 示例如下： /* * 需求：给定2个学生的信息，包括姓名、学号及5门课的成绩，要求利用函数计算每个学生的平均成绩 * */ #include <stdio.h> // 定义结构体类型 struct Student { char name[100]; long num;...
【C 语言】结构体 ( 结构体 数组 作为函数参数 | 数组 在 栈内存创建 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
12-01 4942
一、结构体 数组 作为函数参数 ( 数组 在 栈内存创建 )、 二、完整代码示例
C语言数组、结构体、结构体数组作为函数参数
chingax_csdn
03-27 1万+
数组作为函数参数 如果想把一个数组名参数传递给函数，正确的函数形参应该是怎样的？它是应该声明为一个指针还是一个数组？ 调用函数时实际传递的是一个指针，所以函数的形参实际上是一个指针，但为了使程序员新手更容易上手一些，编译器也接受数组形式的函数形参。因此，下面这两个函数原型是相等的： int strlen(char *string); int strlen(char string[]); 结构体作为函数参数 举例结构体： typedef struct { char product[20]; } trans
【C语言】1. 结构体struct（结构体概念、结构体指针、结构体作为函数参数、传值与传地址、内存对齐（struct与union））
瞌睡的博客
11-27 1万+
/创建结构体模板 struct Student {int _age;//使用该模板创建3个变量stu1,stu2,stu3 struct Student stu1 , stu2 , stu3;缺点就是定义变量时必须带上struct可以使用typedef进行简写，这样在定义变量时比较简洁//结构体模板struct Student重新命名为Stu typedef struct Student {int _age;} Stu;
C++笔记 函数形式参数的三种传递方式 一维数组、结构体、结构体数组作为函数参数 typedef关键字与结构体、结构体指针的定义 附C语言常见运算符优先级
weixin_40933653的博客
08-02 7055
传值与传址 《C和指针》函数的参数一节(7.3节)指出，C函数的所有参数均以“传值调用”方式进行传递，这意味着函数将获得参数值的一份拷贝。这样函数可以放心地修改这个拷贝值，而不必担心会修改调用程序实际传递给它的参数。.........
向基类构造函数传递参数
Arivn_emb
11-21 1226
在创建派生类的构造函数时，有两种方法对数据进行初始化 第一种：在派生类中创建一个构造函数，然后初始化所有数据（从基类哪里继承来的数据和子类的数据） 这种方法显然是多余的，因为基类已经有了恰当的构造函数，为何还要重复构造呢，况且在派生类中对基类进行初始化这种做法 也是不可取的 第二种：在派生类中创建一个构造函数，用该构造函数调用基类的构造函数并且向构造函数传递初始值 显然第二种做法效率要高
结构体中数组成员赋值
08-20
结构体中数组成员赋值 ...在结构体中数组成员赋值时，我们需要注意使用 `strcpy` 函数来拷贝字符串，并且理解字符串常量的类型是 `char *`。同时，我们也需要了解数组和指针的关系，以便正确地使用它们。
C语言中数组作为函数的参数以及返回值的使用简单入门
01-01
函数通过数组作为参数 如果想通过一个一维数组作为函数的参数，就必须声明函数形式参数，使用以下三种方式与所有三个声明方法之一产生类似的结果，因为每一种方式告诉编译器，一个整数指针将会要被接收。类似的方式...
使用pybind11封装C++结构体作为参数的函数实现步骤
01-20
pybind11是一个轻量级的只包含头文件的库，它主要是用来在已有的 C++代码的基础上做扩展，它的语法和目标非常像Boost.Python，但Boost.Python为了兼容现有的基本所有的C++编译器而变得非常复杂和庞大，而因此付出的...
C++结构体作为函数参数传参的实例代码
01-21
*结构体作为函数参数传参 */ //值传递 void printStufdent1(struct Student st3) { cout << 子函数 << endl; st3.age = 100; cout << 名字： << st3.name << 年龄： << ...
基于C#调用c++Dll结构体数组指针的问题详解
08-28
基于C#调用C++ Dll结构体数组指针的问题详解 C#调用C++ Dll文件是一件很麻烦的事情，首先面临的是数据类型转换的问题。相信经常做C#开发的都和我一样把学校的那点C++基础都忘光了吧（语言特性类）。网上有一大堆得...
C++ 笔记（29）— 结构体、结构体作为函数参数、作为返回值、结构体数组、结构体指针、typedef 定义结构体
whl0071的专栏
08-23 1862
C++ 笔记（29）— 结构体、结构体作为函数参数、作为返回值、结构体数组、结构体指针、typedef 定义结构体
结构体数组作为函数的形式参数
weixin_42048463的博客
03-17 4590
#include<stdio.h> struct STU{ char name[9]; char sex; int score[2]; }; void fun(struct STU a[]) { struct STU b={"Zhao", 'm', 85, 90}; a[1]=b; } int main() { struct STU c[2]={"Qian", 'f', 95, 92, "Sun", 'm', 98, 99}; fun(c.
结构体作为函数的参数
xiawucha159的博客
10-06 6180
结构体作为函数的参数 使用结构体变量作为函数的参数时，也是传值的，会将结构体变量的全部内存单元的内容拷贝一份传递给被调函数。在传值的过程中，程序的空间和时间开销比较大，且传递的是一份拷贝，并不能改变实参本身的值。在被调函数modify中，要使用指向运算符->访问结构体成员或者使用括号，因为他的参数是一个结构体指针。只要结构体成员是一个具有单个值的数据类型，便可把它作为参数传递给接受该特定类型的函数。结构体变量名与数组变量名不同，结构体变量名不是它的地址。如果在被调函数中要修改结构体成员的值，
结构体数组作为函数参数传递_CPlusPlus 结构体函数和共同体基础知识详解
weixin_36415835的博客
01-14 613
1.结构体变量作函数参数结构体变量可以被当做普通变量来作为函数参数，减少函数参数个数，使代码简洁。实例：#includeusing namespace std;struct Person //定义结构体 Person{ int index ; char name[20]; short age ;};void ShowStructMessage( struct Person myinfo) //自定...
【C语言】结构体变量作函数参数（三个方法）
热门推荐
KinglakeINC的博客
03-03 2万+
前言 如果对结构体变量的使用不太熟悉，可以先看看博主的这篇文章【C语言】结构体变量定义、初始化、使用。 首先声明结构体类型，注意，若要跨函数使用结构体，结构体类型的声明必须在函数外部： struct students { char name[20]; int age; }; 然后初始化结构体变量及指向结构体变量的指针： struct students stu1={"Allen",18},*pstu; pstu=&stu1; 方法 1结构体变量作为参数 函数体： ...
c++ 成员函数和全局函数的转换
user_define_race的专栏
04-12 1467
#include using namespace std; class Test1 { public: Test1(int a=0,int b=0) { this->a=a; this->b=b; } //成员函数 Test1& t_add(Test1 &t2) { this->a=this->a + t2.a; this->b=this->b + t2
结构体数组指针做函数参数
最新发布
06-05
结构体数组指针作为函数参数时，可以方便地传递多个结构体的信息，并且在函数内对结构体数组进行操作。具体的介绍如下： 1. 结构体数组指针的定义方式如下： ``` struct Student { char name[20]; int age; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值