全面复盘C语言struct 与 union

struct week{定义一  int x;  char y;   };  struct week p1,p2;  //声明变量p1,p2,里边都是week的值          //里边有x和y的值  //用.访问 ：p1.x  p2.x// p1.y, p2.y
struct{定义二                     int x;  char y;            }p1,p2;//在这里声明变量//p1和p2都是一种无名结构，// 里边有X和y  访问一样用.
struct week {定义三   int x;    int y;}p1,p2;//常用的一种结构定义声明形式  
对于第一和第三种形式，都声明了结构名week，但是第二种没有声明结构名,只是定义了两个结构变量，这种叫无名结构
无名结构： 可以定义无名结构体类型的变量。编译器对无名结构体的处理是随机生成一个不重复的变量名。无名结构的定义方式就是定义无名结构体时必须定义该结构体类型的至少一个变量。
优点：无名结构体的妙用就是可以避免相同类型的结构体的重复定义，这样可以对每一个具体类型的队列都可以定义一个结构体来管理该队列的头尾指针，即使定义多个相同具体类型的队列也不会引发重复定义的编译错误。这样定义了两个队列，其元素类型均为int类型，同时各得到了一个维护队列头尾指针的结构体
缺点：这里定义了一个无名的结构体，同时声明了三个此种类型的变量。但是，因为没有名字，我们在这句之后，无法内再定义与那三种变量相同类型的变量了。除非你再容次去定义一个这样的相同的结构体类型。还有一个重要的原因就是没有办法在其他位置定义我们所需要的结构体变量，每次需要新定义结构体变量的时候都必须要找到最开始结构体代码书写的位置才能定义新的结构体    所以实际编程中无名结构并不常用                        

struct week{int x;int y;strcut week at;//在结构体又定义了名为at的一个和week同样参数的结构体变量        //其中可以用.运算符访问  see.at.x see.at.y}see;但是其实这样的方式是不建议（非法）的，因为这种声明实际上是一个无限循环，成员at是一个结构体，at的内部还会有成员是结构体，依次下去，无线循环。在分配内存的时候，由于无限嵌套，也无法确定这个结构体的长度，所以这种方式是非法的正确的方式是使用《结构体指针》，因为指针的长度是确定的:
struct week{int x;int y;strcut week *at;//在结构体内定义了一个指向和week一样类型的结构指针}see;          但是注意用指针访问时要用->运算符   see.at->x

strcut A;//不完整声明strcut B;//不完整声明strcut _A{               strcut _B{int x;          int x;int y;                 int y;struct _B a;        struct _A b;  //在结构B中定义了一个名为b的和A结构一样类型的结构变量                 //其中可以用点访问 A.a.x   B.b.x}A；                      }B；//但是注意这种方式犯了一个和上面第一个嵌套结构的错误，就是结构体A和B都是直接包含了对方，正确的用法还是使用指针：strcut _A{               strcut _B{int x;          int x;int y;                 int y;struct _B *a;      struct _A *b;  //在结构B中定义了一个名为b的和A结构一样类型的结构指针                       //其中指针要用->访问 A.a->x   B.b->x}A；                                 }B；  //但是注意这种方式犯了一个和上面第一个嵌套结构的错误，就是结构体A和B都是直接包含了对方，正确的用法还是使用指针：strcut _A{               strcut _B{int x;              int x;int y;                 int y;struct _B *a;       struct _A *b;  //在结构B中定义了一个名为b的和A结构一样类型的结构指针                 //其中指针要用->访问 A.a->x   B.b->x}A；                                }B；//所以使用互引用要注意：至少有一个结构必须在另一个结构体中以指针的形式被引用。

#include<stdio.h>typedef struct _node {
  int n;  char a[100];
}NODE;
void add(NODE a);//这种形式只是用来做值的传递
int main(void) {  //以传值方式传递结构需要对整个结构做一份拷贝  NODE t;  scanf("%d %d", &t.a[0], &t.n);//输入1  3
  printf("1-%d %d\n",t.a[0],t.n);//输出 1   3
  add(t);  printf("3-%d %d\n", t.a[0], t.n);//输出1  3
//也就是说在add函数里边做修改根本就影响不了主函数这边的值}
void add(NODE a) {
  a.a[0] = 100;//在这里能接受到NODE结构里边的成员  a.n = 666;
  printf("2-%d %d\n", a.a[0], a.n);//输出100   666
}  ****//解决办法是用指针（也是经常用的方式）：****#include<stdio.h>typedef struct _node {
  int n;  char a[100];
}NODE;
int  add(NODE a);//这种形式只是用来做值的传递
int main(void) {  //以传值方式传递结构需要对整个结构做一份拷贝  NODE t;  scanf("%d %d", &t.a[0], &t.n);//输入1  3
  printf("1-%d %d\n",t.a[0],t.n);//输出 1   3

  add(&t);//这里传进去的是t的地址  printf("3-%d %d\n", t.a[0], t.n);//输出100  666//传进去的是地址，所以就可以达到访问同一个变量的操作}
int  add(NODE *) {//定义一个结构指针
  a.a[0] = 100;//在这里能接受到NODE结构里边的成员  a.n = 666;
  printf("2-%d %d\n", a.a[0], a.n);//输出100   666  return a;//这里返回的是指针  所以能达到访问主函数里边调用的值  //使用指针才可以用返回值}//常用的方式

/*上面的第一个的方案，把一个结构传入了函数，然后在函数中操作，但是没有返回回去问题在于传入函数的是外面那个结构的克隆体，而不是指针，传入结构和传入数组是不同的，解决办法是在这个输入函数中，在里边创建一个临时的结构变量，然后把这个结构返回给调用者*/#include<stdio.h>typedef struct _node {  int x;  int y;}NODE;struct _node add();//定义结构类型的函数int main(void) {
  NODE a;  a.x = 0;  a.y = 0;  printf("1-%d %d\n", a.x, a.y);//   0 0
  a = add();//函数调用   /把n的值又返回到a
  printf("3-%d %d\n", a.x, a.y);//所以在这里的时候值已经被改变  return 0;}
struct _node add() {
  NODE n;  scanf("%d", &n.x);//输入1  3
  scanf("%d", &n.y);
  printf("2-%d %d\n", n.x, n.y);//在这里的时候赋值就成功了
  //return n;//把n的值带回出去}//这种方法也能达到“改变"的效果，但是往往开销内存较大，所以一般情况都是使用指针比较方便

//结构做函数参数例子 （输入今天计算明天）#include<stdio.h>#include<stdbool.h>//利用布尔数据类型struct date {  int year;  int month;  int day;
};
bool If(struct date p);//判断是否是闰年int number(struct date c);//判断是否是此月最后一天
int main(void) {
  struct date today,tomorrow;  printf("年-月-日\n");  scanf("%d %d %d", &today.year, &today.month, &today.day);
  //前面两个判断 是否此月最后一天  是否此年此月最后一天    if (today.day==number(today)&&today.month!=12) {//首月1号    tomorrow.day = 1;    tomorrow.month =today.month+1;    tomorrow.year = today.year;  }  else if (today.day == number(today) && today.month == 12) {//下一年    tomorrow.day = 1;    tomorrow.month = 1;    tomorrow.year =today.year+1;  }  else {    tomorrow.day =today.day+1;    tomorrow.month = today.month;    tomorrow.year = today.year;  }
  printf("明天是%d-%d-%d\n", tomorrow.year, tomorrow.month, tomorrow.day);  return 0;}
int number(struct date c)//这里的形参接收的today结构体数据{  int day;  const int a[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 };//这个月最大的天数
  if (c.month==22&&If(c)) {//查看是否是二月并且是润年    day = 29;//是润年  }  else {
    day = a[c.month - 1];  }
  return day;}
bool If(struct date p) {//这里的形参接收的today结构体数据  //润年的特点，能被4整除，但不能被100整数，能被100整除，但是不能被400整除  if (p.year % 4 == 0 && p.year / 100 != 0 || p.year % 400 == 0) {    return true;  }  else {    return false;  }}

//结构体做函数例子 （计算下一秒）#include<stdio.h>struct time {  int hour;  int minute;  int second;};
struct time times(struct time now);//利用结构做函数返回值，形参也是使用结构体做为传值
int main(void) {  struct time nows[5] = {    {11,50,20},{13,25,59},{12,59,59},{23,59,59},{00,00,00},  };
  int i;  for (i = 0; i < 5; i++) {    printf("时间是 %d:%d:%d\n", nows[i].hour, nows[i].minute, nows[i].second);
    nows[i] = times(nows[i]);
    printf("下一秒是 %d:%d:%d\n", nows[i].hour, nows[i].minute, nows[i].second);  }
  return 0;
}
struct time times(struct time now) {
  now.second++;  if (now.second == 60) {//60秒    now.minute++;    now.second = 0;
    if (now.minute == 60)//60分    {      now.hour++;      now.minute = 0;      now.second = 0;
      if (now.hour == 24) {//零点        now.hour=0;        now.minute = 0;        now.second = 0;      }    }  }
  return now;//返回类型必须也函数类型一致，换句话说只有结构体类型才能返回结构体类型
}

//例子：  //寻找学生中 学号最大的# include <stdio.h># include <string.h>
struct STU{  char name[20];  int age;  char sex[20];  char num[20];
};
void OutputSTU(struct STU stu[]);  //函数声明, 该函数的功能是输出成绩最大的学生信息
int main(void){  int i;  struct STU stu[5];
  for (i = 0; i < 2; ++i)  {    printf("请按照名字、年龄、性别、学号(1-9数字）输入第%d个学生的信息:", i + 1);
    scanf("%s %d %s %s", stu[i].name, &stu[i].age, stu[i].sex, stu[i].num);/*%c前面要加空格, 不然输入时会将空格赋给%c*/  }
  OutputSTU(stu);
  return 0;}
void OutputSTU(struct STU stu[]){  struct STU stumax = stu[0];//让临时结构stumax保存第一个学生的信息
  int j;  for (j = 1; j < 2; ++j)//第一个学生依次和后面的学生比较  {    if (strcmp(stumax.num, stu[j].num) < 0)  //strcmp函数的使用  s1>s2:1   s1<s2:-1    {      stumax = stu[j];//让临时结构保存那个学生的信息    }  }
  printf("学生姓名：%s 学生年龄：%d 学生性别：%s 学生分数：%s\n", stumax.name, stumax.age, stumax.sex, stumax.num);
}

#include<stdio.h>struct node{int x;int y;}my;int main(void) {  struct node *p = &my;//定义了一个指针p指向了my的结构体
  p->x = 11;//这是一种访问方式（常用的方式）  (*p).x = 12;//这是第二种方式，  printf("%d", p->x);//输出是12
}以下 2 种形式是等价的：(*指针变量).成员名。指针变量->成员名。其中第 2 种方式很重要，通常都是使用这种方式，另外两种方式用得不多。后面讲链表的时候用的也都是第 3 种方式。

#include<stdio.h>struct point {  int x;  int y;};struct point *gt(struct point*p);//结构指针函数
void  print(const struct point *p);//结构指针
void out(struct point p);//普通的结构体做函数参数
int main(void) {  struct point y = { 0,0 };//以point结构定义一个y的结构变量
  //以下三种调用  等价  //注意gt是一个结构体的指针函数  gt(&y); //这是一个函数的返回结果函数  //取y结构的地址传入函数  out(y);  out(*gt(&y));   // （里边）的都是做为参数  *gt(&y)做为指针返回值  这个函数它的返回用指针表示  print(gt(&y));  //gt(&y)是一个返回值   这样表示的是利用gt函数的返回值在print函数里边操作
  //*get(&y) = (struct point){ 1,2 };  //这也可以做的}
struct point* gt(struct point*p) {// *p要的是&y的地址    scanf("%d", &p->x);  scanf("%d", &p->y);  printf("a=%d,%d \n", p->x, p->y);//用->来访问指针结构里边的成员
  return p;// 用完指针后 返回指针}void out(struct point p) {  printf("b=%d,%d\n", p.x, p.y);}
void print(const struct point *p) {//加上const表示不再改动参数  printf("c=%d,%d\n", p->x, p->y);}

# include <stdio.h>struct qt{  char name[5];  int age;  char sex[5];  double scroe;};int main(void){    //定义了一个student的结构数组  struct qt student[5] = { {"李青", 20, "男", 99}, {"黄欢", 20,  "女", 80}, {"七七", 23, "男", 95} };  struct qt *p = student;  int i;  for (i = 0; i < 5; i++) {
    printf("%s ", p->name);//利用->可访问成员（访问意味着可以读写）    printf("%d ", p->age);    printf("%s ", p->sex);    printf("%f ", p->scroe);  }  return 0;}当结构体指针变量指向一个结构体变量数组的时候，此时指针变量的值就是结构体数组的首地址,此时指针变量 p 就指向了结构体数组的第一个元素，即指向 student[0]。我们知道，当一个指针指向一个数组后，指针就可以通过移动的方式指向数组的其他元素。这个原则对结构体数组和结构体指针同样适用，所以 p + 1 就指向 student[1] 的首地址；p + 2 就指向 student[2] 的首地址……所以只要利用 for 循环，指针就能一个个地指向结构体数组元素。
同样需要注意的是，要将一个结构体数组名赋给一个结构体指针变量，那么它们的结构体类型必须相同。

typedef & 复杂的变量声明理解复杂声明可用的“右左法则”：　　从变量名看起，先往右，再往左，碰到一个圆括号就调转阅读的方向；括号内分析完就跳出括号，还是按先右后左的顺序，如此循环，直到整个声明分析完。举例：　　int (*func)(int *p);　　首 先找到变量名func，外面有一对圆括号，而且左边是一个*号，这说明func是一个指针；然后跳出这个圆括号，先看右边，又遇到圆括号（只有函数后面才跟形参圆括号），这说明 (*func)是一个函数，所以func是一个指向这类函数的指针，即函数指针，这类函数具有int*类型的形参，返回值类型是int，此处就是声明函数。　　int (*func[5])(int *);　　func 右边是一个[]运算符，说明func是具有5个元素的数组；func的左边有一个*，说明func的元素是指针（注意这里的*不是修饰func，而是修饰 func[5]的，原因是[]运算符优先级比*高，func先跟[]结合）。跳出这个括号，看右边，又遇到圆括号，说明func数组的元素是函数类型的指 针，它指向的函数具有int*类型的形参，返回值类型为int。
也可以记住2个模式：type (*)(....)函数指针type (*)[]数组指针

//　内存对齐原则：//　　　1、第一个成员的首地址为0.//　　　2、每个成员的首地址是自身大小的整数倍//　　  3、结构体的总大小，为其成员中所含最大类型的整数倍。
#include<stdio.h>typedef struct _node {  //char t;//1  //int p; //4  //float y;//8//char t 要存放的偏移量为0，满足对齐方式，t占用一个字节，int p要存储在下一个可用的地址的偏移量为1.不是sizeof(int)=4的倍数，需要补足3个字节才能使偏移量变为4(使其满足对齐方式)，因此系统自动填充3个字节使偏移量增加到4，int p放到此位置，占用4个字节，下一可用的偏移量为8，满足sizeof(float）=4的对齐，所以float y直接存放在偏移量为8的位置上，它占用4个字节  总共就是  //1+3+4+4=12
  double a;//8  char b;//1  int c;//4//double a的要存放的偏移量为0，满足对齐方式直接存储，占用8个字节，char b要存储在下一的可用的地址的偏移量为9，直接存储，占用字节为1；int c要存储在下一个可用的地址的偏移量为9，9不满足sizeof（int）=4;所以系统会自动分配3的字节增加到12，12满足对齐方式，存储下去c占用4个字节。总共就是   //8+1+3+4=16
}NODE;
int main(void) {  printf("%d ", sizeof(NODE));}

#include<stdio.h>#pragma pack(2)// 值只能填1 2 4 8 16  这里最好是看结构里边最小的成员 这里是char 所以最好是填1    //但是当#pragma pack指定的值等于或者超过所有数据成员长度的时候，这个指定值的大小将不产生任何效果typedef struct _A {
  double x;//4  int y;//4  char p;//1  }NODE;
//8+4+1+1=14按n为2
//8+4+1+3=16按n为4以上或者使用系统自动对齐
#pragma pack(8)//设定为4字节对齐typedef struct test{  char m1;  double m4;  int m3;
}NODE2;
//1+1+4+8=14//按n为2//1+7+8+4=20 不满足8的倍数  加4等于24满足  总：1+7+8+4+4=24

int main(void) {
  printf("%d\n", sizeof(NODE));  printf("%d", sizeof(NODE2));
}结构、联合或者类的数据成员，第一个放在偏移为0的地方；以后每个数据成员的对齐，按照#pragma pack指定的数值和这个数据成员自身长度两个中比较小的那个进行；也就是说，当#pragma pack指定的值等于或者超过所有数据成员长度的时候，这个指定值的大小将不产生任何效果；

如：int 11 22 33 44在存储的时候大端：11 22 33 44   0  1   2  3   低地址----> 高地址
小端：44 33 22 11   0  1   2  3   低地址----> 高地址大小端的差异在于存放顺序不同常见的操作系统是小端，通讯协议是大端。

//结构体例子：使用尾插法创建链表#include<stdio.h>//单链表的创建
typedef struct _node {
  int nb;//数值  struct _node *nxte;//定义一个指向下一个的节点的指针
}NODE;
typedef struct _link{//利用这个结构体 封装 首尾节点
  NODE *head;  NODE *qt;
}link;
void  add(link *phead, link *qt, int n);//定义函数将 首尾指针传入
int main(void) {
  link head, q;//定义一个结构，连指针都不是的  head.head = q.qt = NULL;//初始化
  int n;
  for (scanf("%d", &n); n != -1; scanf("%d", &n)) {    add(&head, &q, n);//将地址 值传入  }
  NODE *t;  t = head.head;//利用临时结构将链表输出  for (; t; t = t->nxte) {    printf("%d ", t->nb);  }
  return 0;}
//尾插法void  add(link *phead, link *qt, int n) {
  NODE *p = (NODE*)malloc(sizeof(NODE));//为新结点开辟空间  p->nb = n;  p->nxte = NULL;
  if (phead->head == NULL) {//判断首结点是否为空    phead->head = p;//是空的就让首结点等于新结点  }  else {//不为空时，让尾结点依次跑到后面去    qt->qt->nxte = p;  }
  qt->qt = p;}

联合的定义:定义一个联合类型的一般形式为：union [name](联合名)   name是可选的{成员表};成员表中含有若干成员，成员的一般形式为： 类型说明符 成员名成员名的命名应符合标识符的规定。
union Data{   int i;   double f;   char  str[20];} data;

现在 Data所有的成员共享一个空间，同一时间只有一个成员是的值有效的，Data 类型的变量可以存储一个整数、一个浮点数，或者一个字符串。这意味着一个变量（相同的内存位置）可以存储多个多种类型的数据。您可以根据需要在一个共用体内使用任何内置的或者用户自定义的数据类型。共用体占用的内存应足够存储共用体中最大的成员。例如，在上面的实例中，Data 将占用 20 个字节的内存空间，因为在各个成员中，字符串所占用的空间是最大的。

typedef union _node {  int a;  double b;  char c;  union _node *p;
}NODE;
int main(void) {
  NODE a;//定义变量  NODE t;  a.b;//用.访问  t.p->a;//指针用->访问


}联合的使用规则几乎和结构体strtct的规则用法一样，只不过是内部表示的不同。
补充：还有一个是无名联合体，它是和无名结构体的工作原理是相同的

#include<stdio.h>//简单的例子#include<string.h>
typedef union _node{  int a;  double b;  char c[20];
}NODE;
int main(void) {
  NODE a;//这里只定义一个变量
  a.a = 666;  printf("%d\n", a.a);
  a.b = 9.99;  printf("%f\n", a.b);
  strcpy(a.c, "hello world!");  printf("%s\n", a.c);
  //我们看到，三个都被完整的输出了，因为在同一时刻，只有一个成员是有效的
}
输出：6669.990000hellow world!

//共用体综合例子：根据输入的数据类型输出需要的相应的数据#include<stdio.h>#include<string.h>//数据类型输出   5*4  m n     n的第几个x 
union node {  int a;  double b;  char c[30];
}add[10000];
char p[10000][30]; //保存的字符串数组
int main(void) {  int n, m;  scanf("%d %d", &n, &m);  int x;  double y;  char t[50];  int i, j;
  for (i = 0; i < n; i++) {//输入    scanf("%s", &p[i]);//作为字符串数组，需要取地址
    if (strcmp("INT", p[i]) == 0) {//整形      scanf("%d", &x);      add[i].a = x;    }    else if(strcmp("DOUBLE",p[i])==0){//浮点      scanf("%lf", &y);      add[i].b = y;    }    else if (strcmp("STRCING", p[i]) == 0) {//字符串      scanf("%s", t);      strcpy(add[i].c, t);    }
  }
  for (i = 0; i < m; i++) {//输出    scanf("%d", &j);
    if (strcmp("INT", p[j]) == 0) {      printf("%d\n", add[j].a);    }    else if (strcmp("DOUBLE", p[j]) == 0)    {      printf("%f\n", add[j].b);    }else if(strcmp("STRING",p[j])==0)    {      printf("%s\n", add[j].c);
    }
  }
  return 0;
}
//输入：/*5 4INT 456DOUBLE 123.56DOUBLE 0.476STRING welcomeToCSTRING LemonTree0124*/
//输出：/*456123.560.48LemonTree
*/