结构体是 c 中 的数据类型
定义结构体 使用
struct 定义一个包含多个成员的新的数据类型
tag 是结构体标签。
member-list 是标准的变量定义，比如 int i; 或者 float f，或者其他有效的变量定义。
variable-list 结构变量，定义在结构的末尾，最后一个分号之前，可以指定一个或多个结构变量。
在一般情况下，tag、member-list、variable-list 这 3 部分至少要出现 2 个

  1. struct character  //人物  
  2. {
  3.    char  character1[50];
  4.    char  character2[50];
  5.    char  character3[100];
  6.    int   character4;
  7. }charact;

另外两种定义方法

  1. //此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
  2. //结构体的标签被命名为SIMPLE,没有声明变量
  3. struct SIMPLE
  4. {
  5.     int a;
  6.     char b;
  7.     double c;
  8. };
  9. //用SIMPLE标签的结构体，另外声明了变量t1、t2、t3
  10. struct SIMPLE t1, t2[20], *t3;
  12. //也可以用typedef创建新类型
  13. typedef struct
  14. {
  15.     int a;
  16.     char b;
  17.     double c; 
  18. } Simple2;
  19. //现在可以用Simple2作为类型声明新的结构体变量
  20. Simple2 u1, u2[20], *u3;

初始化结构体

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include "test.h"
  6. struct character  //人物  类型
  7. {
  8.    char  character1[50];
  9.    char  character2[50];
  10.    char  character3[100];
  11.    char   character4[100];
  12. }charact={"一号","二号","三号","四号"};
  14. int main(int argc, char *argv[]) {
  15.     printf("character1:%s\ncharacter2:%s\ncharacter3:%s\ncharacter4:%s\n",charact.character1,charact.character2,charact.character3,charact.character4);
  16.     system("pause");
  17.     return 0;
  18. }

显示
image.png
访问结构成员 >>>> 结构的用法 >>>成员访问运算符（.）

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include "test.h"
  6. struct character  //人物  类型
  7. {
  8.    char  character1[50];
  9.    char  character2[50];
  10.    char  character3[100];
  11.    char  character4[100];
  12. };
  14. int main(){
  16.     struct character a1;  //声明 a1 ，类型为 characrter
  17.     struct character a2;  //一个结构体 使用在结构上 
  19.     //a1 详述
  20.     strcpy(a1.character1,"超人"); // strcpy  复制
  21.     strcpy(a1.character2,"巨人");
  22.     strcpy(a1.character3,"蝙蝠侠");
  23.     strcpy(a1.character4,"外星人");
  25.     //a2
  26.     strcpy(a2.character1,"一号");  
  27.     strcpy(a2.character2,"二号");
  28.     strcpy(a2.character3,"三号");
  29.     strcpy(a2.character4,"四号");
  31.     //输出a1 
  32.     printf("character1:%s\n",a1.character1);
  33.     printf("character2:%s\n",a1.character2);
  34.     printf("character3:%s\n",a1.character3);
  35.     printf("character4:%s\n",a1.character4);
  36.     //a2
  37.     printf("character1:%s\n",a2.character1);
  38.     printf("character2:%s\n",a2.character2);
  39.     printf("character3:%s\n",a2.character3);
  40.     printf("character4:%s\n",a2.character4); //成员访问运算符  .
  42.     system("pause");
  43.     return 0;
  44. }

显示
image.png
结构作为函数传参
结构作为函数参数，传参方式与其他类型的变量或指针类似 ```c

include

include

include

include “test.h”

struct character //人物 类型 { char character1[50]; char character2[50]; char character3[100]; char character4[100]; }; //声明 void printcharacter( struct character c1); int main(){

  1. struct character a1;  //声明 a1 ，类型为 characrter
  2. struct character a2;  //一个结构体 使用在结构上 
  4. //a1 详述
  5. strcpy(a1.character1,"超人"); // strcpy  复制
  6. strcpy(a1.character2,"巨人");
  7. strcpy(a1.character3,"蝙蝠侠");
  8. strcpy(a1.character4,"外星人");
  10. //a2
  11. strcpy(a2.character1,"一号");  
  12. strcpy(a2.character2,"二号");
  13. strcpy(a2.character3,"三号");
  14. strcpy(a2.character4,"四号");
  16. printcharacter(a1);
  17. printcharacter(a2);
  19. system("pause");
  20. return 0;

} void printcharacter( struct character c1) //（定义 struct 结构体 新的类型） { printf(“character1:%s\n”,c1.character1); printf(“character2:%s\n”,c1.character2); printf(“character3:%s\n”,c1.character3); printf(“character4:%s\n”,c1.character4);

}

  1. 指向结构的指针<br /> 定义指针 ：struct   character   *c1;<br /> 指针变量中存储结构变量的地址： c1 = &a1;<br /> 为了使用指向该结构的指针访问结构的成员，您必须使用 -> 运算符 ：c1->character1;
  2. ```c
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include "test.h"
  8. struct character  //人物  类型
  9. {
  10.    char  character1[50];
  11.    char  character2[50];
  12.    char  character3[100];
  13.    char  character4[100];
  14. };
  15. //声明
  16. void printcharacter( struct character *c1);
  17. int main(){
  19.     struct character a1;  //声明 a1 ，类型为 characrter
  20.     struct character a2;  //一个结构体 使用在结构上 
  22.     //a1 详述
  23.     strcpy(a1.character1,"超人"); // strcpy  复制
  24.     strcpy(a1.character2,"巨人");
  25.     strcpy(a1.character3,"蝙蝠侠");
  26.     strcpy(a1.character4,"外星人");
  28.     //a2
  29.     strcpy(a2.character1,"一号");  
  30.     strcpy(a2.character2,"二号");
  31.     strcpy(a2.character3,"三号");
  32.     strcpy(a2.character4,"四号");
  34.     printcharacter(&a1);
  35.     printcharacter(&a2);
  37.     system("pause");
  38.     return 0;
  39. }
  40. void printcharacter( struct character *c1)    //（定义 struct  结构体  新的类型）
  41. {
  42.     printf("character1:%s\n",c1->character1);
  43.     printf("character2:%s\n",c1->character2);
  44.     printf("character3:%s\n",c1->character3);
  45.     printf("character4:%s\n",c1->character4);
  47. }