C语言 结构体 共用体 枚举

一.结构体

 结构体定义时需要先定义结构体类型，然后再用类型来定义变量。

结构体是用来解决数组所有的元素的类型必须一致缺陷的，可以将结构体理解为一个其中元素类型可以不相同的数组。

// 定义类型
struct people
{
    char name[20];
    int age;
};
 
// 定义类型的同时定义变量。
struct student
{
    char name[20];
    int age;
}s1;
 
// 将类型struct student重命名为s1，s1是一个类型名，不是变量
typedef struct student
{
    char name[20];
    int age;
}s1;
 

结构体变量中的元素访问方式：

只有一种，用 . 或者->的方式来访问。

struct score
{
    int a;
    int b;
    int c;
};
 
struct myStruct
{
    int a;            // 4 
    double b;        // 8
    char c;
};
 
int  main()
{
    struct myStruct s1;
    s1.a = 12;              // int *p = (int *)&s1; *p = 12;
    s1.b = 4.4;             // double *p = (double *)(&s1 + 4); *p = 4.4;
    s1.c = 'a';            // char *p = (char *)((int)&s1 + 12); *p = 'a';
    
    int a[3];        // 3个学生的成绩，数组方式
    score s;        // 3个学生的成绩，结构体的方式
    
    s.a = 12;        // 编译器在内部还是转成指针式访问 int *p = s; *(p+0) = 12;
    s.b = 44;        // int *p = s; *(p+1) = 44;
    s.c = 64;        // int *p = s; *(p+2) = 44;
}

结构体对齐：

对齐访问牺牲了内存空间，换取了速度性能。

struct mystruct1
{                    // 1字节对齐        4字节对齐
    int a;            // 4            4
    char b;            // 1            2(1+1)
    short c;        // 2            2
};

typedef struct mystruct2
{                    // 1字节对齐      4字节对齐
    char a;            // 1            4(1+3)
    int b;            // 4            4
    short c;        // 2            4(2+2)
}MyS2;

typedef struct myStruct5
{                            // 1字节对齐       4字节对齐
    int a;                    // 4            4
    struct mystruct1 s1;    // 7            8
    double b;                // 8            8
    int c;                    // 4            4    
}MyS5
 
int main()
{
    printf("sizeof(struct mystruct1) = %d.\n", sizeof(struct mystruct1));       //   8

    printf("sizeof(struct mystruct2) = %d.\n", sizeof(struct mystruct2));   //12
    printf("sizeof(struct mystruct5) = %d.\n", sizeof(MyS5));  //24

    return 0;
}

二.共用体

共用体union和结构体struct在类型定义、变量定义、使用方法上很相似。

共用体中的各个成员其实是一体的，彼此不独立，他们使用同一个内存单元。

 

union中的元素不存在内存对齐的问题，因为union中实际只有1个内存空间，都是从同一个地址开始的，所以不涉及内存对齐。

用union来测试机器的大小端模式：

#include <stdio.h>
 
// 共用体中很重要的一点：a和b存放都是从u1的低地址开始的。
// 假设u1所在的4字节地址分别是：0、1、2、3的话，那么a存放顺序自然就是0、1、2、3；
// b所在的地址是0而不是3.
union myunion
{
    int a;
    char b;
};
 
// 如果是小端模式则返回1，小端模式则返回0
int is_little_endian(void)
{
    union myunion u1;         //1对应十六进制就是0x0000_0001
    u1.a = 1;                // 地址0的那个字节内是1（小端）或者0（大端）
    return u1.b;
}
 
int main(void)
{
    int i = is_little_endian();
    if (i == 1)
    {
        printf("小端模式\n");      //在X86下的Linux中验证是小端模式
    }
    else
    {
        printf("大端模式\n");
    }
    
    return 0;                      
}

三.枚举

枚举本质就是int类型的常量，每个符号和一个常量绑定。

宏定义和枚举的区别：

枚举是将多个有关联的符号封装在一个枚举中（譬如一星期有7天，譬如一个月有31天，适合用枚举），而宏定义是完全散的。也就是说枚举其实是多选一。

#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};

枚举变量的定义：

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);
    }
}

#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