1.结构体

1.1结构体的定义与声明

//1先声明后定义
struct 结构体名
{
    成员列表
}；//最后的分号不可丢
struct 结构体名 变量名;


//2声明与定义同时进行
struct student
{
    int num;
    char name[20];
    int age;
    char sex;
    float score;
}stu1,stu2;

//3直接定义变量
struct
{
    int num;
    char name[20];
    int age;
    char sex;
    float score;
}stu;

1.2结构体变量的初始化

可以在定义时完成初始化，也可以定义之后初始化（要保证数据元素相互对应）

1.3 结构体变量的引用

结构体变量名.成员名

1.4结构体数组

stuct student stu[3];

2.1指向结构体类型的指针

结构体变量占用一定的内存空间。是该变量所占据的内存段的起始地址。
如果使用指针操作，可以使用“->”运算符来访问结构体中的数据成员。

{
    p->num;
    //等价
    (*p).num;
}

2.2结构体变量做函数的参数

三种方法：

每一个结构体成员，作为简单变量传递
整个结构体做参数
传递指向结构体的指针

2.共用体

2.1 共用体一般格式

 union  共用体名
 {
  	共用体成员列表
 }
 例 union student{
 	int a,b,c;
 }

2.2 共用体与结构体的区别

·共用体与结构体的区别：共用体的定义虽然是以结构体为基础，但与结构体却有着本质的区别，它们的内存使用方式不同。
共用体是多种数据的覆盖存储，几个不同的成员变量共占同一段内存，且都是从同一地址开始存储的，只是任意时刻只存储一种数据，因此分配给共用体的存储区域大小至少要有存储最大一个数据所需的空间。而对于结构体来说，由于结构体中不同的成员分别使用不同的内存空间，因此一个结构体所占内存空间的大小应是结构体每个成员所占内存大小总和，而且，结构体中每个成员相互独立，不占用同一存储单元。

可以看出x在内存中占用2+1+4=7个字节（实际占用字节数依运行环境而定），而y在内存中只需占用4个字节（float型）。因而在程序设计中采用共用体比采用结构体节省空间。
说明：1）由于共用体变量不是同时存放多个成员的值，因此共用体变量不能进行初始化。

     2）由于共用体变量不是同时存放多个成员的值，而只是存放其中的一个值，因此在程序中改变共用体的一个成员，其他成员也会随之改变，最终共用体中所有成员共用一个值（最后赋的值）。

例如：a.1=10; a.ch=‘H’; a.f=9.9; 依次执行完上述三个赋值语句之后，最终只有a.f的值有效。
考虑下面的代码，会运行什么结果。

#include<stdio.h>
 
int main()
{
    union exa
    {
        struct
        {
            int a;
            int b;
        }out;
        int c;
        int d;
    }e;
    e.c=1;e.d=3;
    e.out.a=e.c;
    e.out.b=e.d;
    printf("\n%d,%d\n",e.out.a,e.out.b);
    return 0;
}

3 枚举

3.1 枚举的使用

枚举是C语言中一种基本数据类型，它可以让数据简洁和易读

3.1.1定义格式为：

enum 枚举名{元素1,元素2};

3.1.2为什么要用枚举？

#define MON  1
#define TUE  2
#define WED  3
#define THU  4
#define FRI  5
#define SAT  6
#define SUN  7

例如以上这些代码，看起来很多很复杂，如果用枚举的方式：

enum DAY{MON=1,TUE,WED, THU, FRI, SAT, SUN};

注意：第一个枚举成员的默认值为整型的 0，后续枚举成员的值在前一个成员上加 1。我们在这个实例中把第一个枚举成员的值定义为 1，第二个就为 2，以此类推

enum nums{a,b,c,d=5,e};

没有指定值的枚举元素，其值为前一元素加1
枚举变量的定义

enum DAY{MON=1,TUE,WED,THU,FRI};
enum DAY day;

enum DAY{MON=1,TUE,WED,THU,FRI}day;//也可以在定义枚举类型时一起定义

enum{MON=1, TUE, WED, THU, FRI, SAT, SUN}day;//可以省略枚举名称

实例

#include <stdio.h>
enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};
int main()
{
    enum DAY day;
    day = WED;
    printf("%d",day);
    return 0;
}

遍历枚举类型

#include <stdio.h>
enum DAY{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;
int main(){
    // 遍历枚举元素
    for (day = MON; day <= SUN; day++) {
        printf("枚举元素：%d \n", day);
    }
}

如果像以下枚举类型不连续，则无法进行遍历

enum{
    day1,
    day2 = 10,
    day3
};

#include<stdio.h>
enum DAY{MON=1, TUE, WED, THU=6, FRI, SAT, SUN}day;
int main(){
    for(day=MON;day<=SUN;day++){
        printf("%d\t",day);
    }
    return 0;
}
//以上的输出结果会变成 1	 2	 3	 4	 5	 6	 7	 8	 9

3.1.3枚举在实例中的运用

#include <stdio.h>
#include <stdlib.h>
int main(){
    enum color { red=1, green, blue };
    enum  color favorite_color;
    printf("请输入你喜欢的颜色: (1. red, 2. green, 3. blue): ");
    scanf("%u", &favorite_color);
    switch (favorite_color){
    case red:
        printf("你喜欢的颜色是红色");
        break;
    case green:
        printf("你喜欢的颜色是绿色");
        break;
    case blue:
        printf("你喜欢的颜色是蓝色");
        break;
    default:
        printf("你没有选择你喜欢的颜色");
    }
    return 0;
}

将整数转换为枚举

**#include<stdio.h>
#include<stdlib.h>
int main(){
    enum day{saturday,sunday,monday,tuesday,wednesday,thursday,friday}workday;
    int a=1;
    enum day weekend;
    weekend=(enum day)a;
    printf("weekend:%d",weekend);
    return 0;
}
**

（题目来自牛客网）

在32位机器上
设有以下说明和定义：

typedef union {
    long i;
    int k[5];
    char c;
} DATE;
struct data {
    int cat;
    DATE cow;
    double dog;
} too;
DATE max;
则语句 printf("%d",sizeof(struct data)+sizeof(max));的执行结果是：

52

共享体
union 维护足够的空间来置放多个数据成员中的“一种”，而不是为每一个数据成员配置空间，在union 中所有的数据成员共用一个空间，同一时间只能储存其中一个数据成员，所有的数据成员具有相同的起始地址。例子如下： 
union StateMachine 
{ 
char character; 
int number; 
char *str; 
double exp; 
};

一个union 只配置一个足够大的空间以来容纳最大长度的数据成员，以上例而言，最大长度是double 型态，所以StateMachine 的空间大小就是double 数据类型的大小。

结构体【内存对齐】
（转自http://blog.csdn.net/szchtx/article/details/8801583）

结构体变量的所有成员占用不同的存储空间，结构体中的成员可以是不同的数据类型，成员按照定义时的顺序依次存储在连续的内存空间。和数组不一样的是，结构体的大小不是所有成员大小简单的相加，需要考虑到系统在存储结构体变量时的地址对齐问题。

看下面这样的一个结构体：

[cpp] view plain copy print?
struct stu1  
{  
     int i;  
     char c;  
     int j;  
}；  

用sizeof求该结构体的大小，发现值为12。int占4个字节，char占1个字节，结果应该是9个字节才对啊，为什么呢？

先介绍一个相关的概念——偏移量。偏移量指的是结构体变量中成员的地址和结构体变量地址的差。结构体大小等于最后一个成员的偏移量加上最后一个成员的大小。显然，结构体变量中第一个成员的地址就是结构体变量的首地址。因此，第一个成员i的偏移量为0。第二个成员c的偏移量是第一个成员的偏移量加上第一个成员的大小（0+4）,其值为4；第三个成员j的偏移量是第二个成员的偏移量加上第二个成员的大小（4+1）,其值为5。

然而，在实际中，存储变量时地址要求对齐，编译器在编译程序时会遵循两条原则：

  （1）结构体变量中成员的偏移量必须是成员大小的整数倍（0被认为是任何数的整数倍） 

  （2）结构体大小必须是所有成员大小的整数倍，也即所有成员大小的公倍数。

上面的例子中前两个成员的偏移量都满足要求，但第三个成员的偏移量为5，并不是自身(int)大小的整数倍。编译器在处理时会在第二个成员后面补上3个空字节，使得第三个成员的偏移量变成8。结构体大小等于最后一个成员的偏移量加上其大小，上面的例子中计算出来的大小为12，满足要求。

再来看另外一个例子：

[cpp] view plain copy print?
struct stu2  
{  
      int k;  
      short t;  
}；  

成员k的偏移量为0；成员t的偏移量为4，都不需要调整。但计算出来的大小为6，显然不是成员k大小的整数倍。因此，编译器会在成员t后面补上2个字节，使得结构体的大小变成8从而满足第二个要求。 
由此可见，结构体类型需要考虑到字节对齐的情况，不同的顺序会影响结构体的大小。

对比下面两种定义顺序：

[cpp] view plain copy print?
struct stu3  
{   
       char c1;   
       int i;  
       char c2;  
}  

struct stu4  
{  
       char c1;  
       char c2;  
       int i;  
 }  

虽然结构体stu3和stu4中成员都一样，但sizeof(struct stu3)的值为12而sizeof(struct stu4)的值为8。

对于嵌套的结构体，需要将其展开。对结构体求sizeof时，上述两种原则变为：

   （1）展开后的结构体的第一个成员的偏移量应当是被展开的结构体中最大的成员的整数倍。

   （2）结构体大小必须是所有成员大小的整数倍，这里所有成员计算的是展开后的成员，而不是将嵌套的结构体当做一个整体。

看下面的例子：

[cpp] view plain copy print?
struct stu5  
{  
      short i;  
      struct   
      {  
           char c;  
           int j;  
      } ss;   
      int k;  
}  

结构体stu5的成员ss.c的偏移量应该是4，而不是2。整个结构体大小应该是16。

下述代码测试原则2：

[cpp] view plain copy print?
struct stu5  
{  
      char i;  
      struct   
      {  
           char c;  
           int j;  
      } ss;   
      char a;  
      char b;  
      char d;  
      char e;  
      char f;  
}  

结构体ss单独计算占用空间为8，而stu5的sizeof则是20，不是8的整数倍，这说明在计算sizeof(stu5)时，将嵌套的结构体ss展开了，这样stu5中最大的成员为ss.j，占用4个字节，20为4的整数倍。如果将ss当做一个整体，结果应该是24了。

另一个特殊的例子是结构体中包含数组，其sizeof应当和处理嵌套结构体一样，将其展开，如下例子：

[cpp] view plain copy print?
struct ss  
{  
    float f;  
    char p;  
    int adf[3];  
};  
cout<<sizeof(ss)<<endl;  

其值为20。float占4个字节，到char p时偏移量为4，p占一个字节，到int adf[3]时偏移量为5，扩展为int的整数倍，而非int adf[3]的整数倍，这样偏移量变为8，而不是12。结果是8+12=20，是最大成员float或int的大小的整数倍。

如何给结构体变量分配空间由编译器决定，以上情况针对的是Linux下的GCC。在Windows下的VC平台也是这样，至于其他平台，可能会有不同的处理。

数组
数组是相同类型的元素的集合，只要会计算单个元素的大小，整个数组所占空间等于基础元素大小乘上元素的个数。
————————————————
版权声明：本文为CSDN博主「zmysang」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u010223431/article/details/54376040

一、结构体的相关知识：

1、定义结构体类型，只说明该类型的组成情况，并没有分配内存空间。只有当定义属于结构体类型的变量时，系统才会分配空间给该变量。

2、结构体定义类型中不允许对结构体本身的递归定义。

3、结构体定义中可以包含另外的结构体，即结构体是一嵌套的。

4、结构体变量可以在定义时进行初始化赋值。

例如：struct person{

char name[20];

char sex;

}girl1={“tangtang”,’F’};

二、共用体的相关知识：

1、结构体和共用体都是由多个不同的数据类型成员组成，但在任一时刻，共用体中只存放了一个被选中的成员，而结构体的所有成员都存在。对于共用体的不同成员赋值，将会对其他成员重写，原来成员的值就不存在了，而对于结构体的不同成员赋值是互不影响的。

2、共用体占用内存为个成员中占用最大者内存。而结构体占用内存与具体的sizeof有关。

三、枚举的相关知识：

1、对于枚举中，如果不给枚举常量赋初值，编译器会为每一个枚举量赋一个不同的整型值，第一个为0，第二个为1等。当枚举表中某个常量赋值后，其后的成员则按一次加1的规则确定其值。

四、sizeof的计算：

1、sizeof(int):4； short:2;；long:4；float:4；double:8；char:1； 指针：4；

2、struct的空间计算：

（1）整体空间时占用空间最大的成员（的类型）所占字节的整数倍。

（2）整数对齐原则——内容按结构体成员的先后顺序排序，当排到该成员变量时，其前面已摆放的空间大小必须是该成员类型大小的整数倍，如果不够则补齐。

例如：

struct s1{

char a;    

double b;

int c;

char d;

};

struct s2{

char a;

char b;

int c;

double d;

};

cout<

pragma pack(n),n为字节对齐数，其取值为1、2、4、8、16等，默认为8。如果这个值比结构体成员的sizeof值小，那么该成员的偏移量应该以此值为准。

4、空结构体的大小不为0，为1。

5、共用体（Union）的sizeof就是每个成员sizeof的最大值。

6、枚举类型的sizeof为4。