结构体（c语言）

• 结构体类型的声明
• 结构体初始化
• 结构体成员访问
• 结构体传参

---

1. 结构体的声明 

---

1.1 结构的基础知识 

结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。

结构体：其实是一组不一定相同类型元素的集合 

1.2 结构的声明

 struct  tag（struct关键字不可少，tag根据实际情况给名字）
{
member-list;（成员列表（一个或多个）
}variable-list;（变量列表）

具体解释如下：

假如描述一个学生
成员列表描述：名字+年龄+性别

这一部分在声明结构体类型（此时还没有创建空间，无法初始化）
struct Stu
{
	/这里面是成员变量，是用来描述结构体对象的相关属性的
	char name[20];
	int age;
	char sex[5];//男 女  保密（一个汉字两个字符，两个汉字四个字符，给5个字符足够）
}





第一种类型：
声明结构体类型
struct Stu
{
	/这里面是成员变量，是用来描述结构体对象的相关属性的
	char name[20];
	int age;
	char sex[5];//男 女  保密（一个汉字两个字符，两个汉字四个字符，给5个字符足够）
} 
int main()
{
	struct Stu s1;//局部变量（这个是通过结构体类型创建的变量，此时创建了空间）
	Stu s2;

	return 0;
}





第二种类型：
声明结构体类型
struct Stu
{
	/这里面是成员变量，是用来描述结构体对象的相关属性的
	char name[20];
	int age;
	char sex[5];//男 女  保密（一个汉字两个字符，两个汉字四个字符，给5个字符足够）
} s2,s3,s4; /s2,s3,s4 就是结构体变量 - 全局变量（在这里创建变量，跟第一种类型struct Stu s1一样，只不过这里是全局变量）





第三种类型：（比第一种更方便）
typedef struct Stu（不加typedef和Stu是结构体类型，加了typedef和Stu指重命名为Stu，这里的Stu是 struct Stu的别名）
{
	//成员变量，是用来描述结构体对象的相关属性的
	char name[20];
	int age;
	char sex[5];//男 女  保密
} Stu;
int main()
{
	//struct Stu s1;//局部变量（这个是通过结构体类型创建的变量，此时创建了空间）
	Stu s2;(这里的s2就和s1是一个道理，这里的Stu就是用的重命名之后的）

	return 0;
}


注意：
 struct Stu（
{
	char name[20];
	int age;
	char sex[5];
} Stu;
int main()
{
	//struct Stu s1;
	Stu s2;当前面没有tytedef时，这里不能这样写，此时struct是不能省略的（在C语言中，没有对结构体类型typedef,struct关键字不能省略)
	return 0;
}

1.3 结构成员的类型

结构的成员可以是标量(指变量的普通变量）、数组、指针，甚至是其他结构体。

例如：

struct S
{
	int a;
	char arr[5];
	int* p;
};
再定义一个：
struct B
{
	char ch[10];
	struct S s;（用上面的类型创建变量，这个里面是结构体包含一个结构体）
	double d;
};

int main()
{
	return 0;
}

1.4 结构体变量的定义和初始化

有了结构体类型，那如何定义变量，其实很简单。

例如：

这里想要创建struct S结构体变量，有三种方式：
1
struct S
{
	int a;
	char arr[5];
	int* p;
}s1 = {100, "bit", NULL};直接此类型创建，如s1(初始化了）（全局变量）
2
struct S s2 = {98, "hehe", NULL};（全局变量）（初始化了）
3
int mian()
{
    struct S s3 = {"abc", 99,NULL);(这样写是错误的，这里无法确定顺序）
    struct S s3 = {.arr="abc", .p=NULL, .a=0);(这样写，自定义了顺序，以.的方式确定成员，然后把值放进去）
    printf("%d %s %p\n", s3.a, s3.arr,s3.p)；.是成员访问操作符，顺序自定义
    return 0;
}






这里要初始化B，先初始化ch,再初始化s,再初始化d
struct S
{
	int a;
	char arr[5];
	int* p;
}s1 = {100, "bit", NULL};直接此类型创建，如s1

struct S s2 = {98, "hehe", NULL};（全局变量）

struct B
{
	char ch[10];
	struct S s;
	double d;
};

int main()
{
	struct S s3 = {.arr = "abc", .p = NULL, .a = 1};
	printf("%d %s %p\n", s3.a, s3.arr, s3.p);//. 结构成员访问操作符

	struct B sb = { "hello", {20, "qqq", NULL}, 3.14};先初始化ch,再初始化s,再初始化d
	printf("%s %d %s %p %.2lf\n", sb.ch, sb.s.a, sb.s.arr, sb.s.p, sb.d);打印（sb.s.a, sb.s.arr, sb.s.p打印的是s里面的内容，sb.ch打印的是ch里面的内容， sb.d打印的是d里面的内容）（%.2lf打印小数点后两位即可）

	return 0;
}

这里就讲到了结构体变量的创建，定义，初始化，怎么访问成员。

---

2. 结构体成员的访问

---

1.结构体变量访问成员

结构变量的成员是通过点操作符（.）访问的。点操作符接受两个操作数。（如上）

例如：

 我们可以看到 s 有成员 name 和 age ；

那我们如何访问s的成员？（如上有例题说明）

struct S s;
strcpy(s.name, "zhangsan");//使用.访问name成员
s.age = 20;//使用.访问age成员

2.结构体指针访问指向变量的成员
有时候我们得到的不是一个结构体变量，而是指向一个结构体的指针（有可能不是.，是箭头）

那该如何访问成员。
如下：

struct Stu
{
char name[20];
int age;
};

void print(struct Stu* ps)
{
printf("name  =  %s   age  =  %d\n", (*ps).name, (*ps).age);
  //使用结构体指针访问指向对象的成员
printf("name = %s   age = %d\n", ps->name, ps->age);
}
int main()
{
  struct Stu s = {"zhangsan", 20};
  print(&s);//结构体地址传参
  return 0;
}

举例：

struct Stu
{
	char name[20];
	int age;
};

void set_stu(struct Stu* ps) （当把s的地址传过来，此时这里不能写成void set_stu(struct Stu t)）
{
	（*ps).age = 20; 此时不能写成t.age = 20;

	//t.name = "张三";//错误，名字是数组，不能将它放到地址上，而是要将它放在地址所指向的空间里面

	strcpy(（*ps).name, "张三");//字符串拷贝（包含的头文件#include<string.h>)，不能写strcpy(t.name, "张三")
}

void print_stu(struct Stu t)（t来接收s）
{
	printf("%s %d\n", t.name, t.age);
}

int main()
{
	struct Stu s = {0};
	set_stu(&s);（设置stu里面的值，相当于初始化）(这里应该传地址，当传s本身，只是打印s本身，结果会出现错误，所以函数内部想改变外部的变量，要传地址）
	print_stu(s);
	return 0;





如上这样写太罗嗦，此时可以换一种写法：
struct Stu
{
	char name[20];
	int age;
};
void set_stu(struct Stu* ps) 
{
	ps->age = 20; //结构体指针->结构体成员
	strcpy(ps->name, "张三");
}
void print_stu(struct Stu t)
{
	printf("%s %d\n", t.name, t.age);
}
int main()
{
	struct Stu s = {0};
	set_stu(&s);
	print_stu(s);
	return 0;

---

3. 结构体传参

---

直接上代码：

struct S
{
   int data[1000];
   int num;
};
struct S s = {{1,2,3,4}, 1000};
/结构体传参
void print1(struct S s)
{
    printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps)
{
    printf("%d\n", ps->num);
}
int main()
{
    print1(s);  /传结构体
    print2(&s); /传地址
    return 0;
}
上述print1, print2那个方式更好呢？
 print2更好

上面的 print1 和 print2 函数哪个好些？
答案是：首选print2函数。
原因：
函数传参的时候，参数是需要压栈的。
如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的
下降。

结论：
结构体传参的时候，要传结构体的地址。