预处理指令

结构
一 构基础知识

        聚合数据类型( aggregate data type)能够同时存储超过一个的单独数据。C提供了两种类型的聚合数据类型，数组和结构。数组是相同类型的元素的集合，它的每个元素是通过下标引用或指针间接访问来选择的。
        结构也是一些值的集合，这些值称为它的成员(member)，但一个结构的各个成员可能具有不同的类型。结构和Pascal或Modula中的记录(record)非常相似。
        数组元素可以通过下标访问，这只是因为数组的元素长度相同。但是，在结构中情况并非如此。由于一个结构的成员可能长度不同，所以不能使用下标来访问它们。相反，每个结构成员都有自己的名字，它们是通过名字访问的。
        这个区别非常重要。结构并不是一个它自身成员的数组。和数组名不同，当一个结构变量在表达式中使用时，它并不被替换成一个指针。结构变量也无法使用下标来选择特定的成员。
        结构变量属于标量类型，所以你可以像对待其他标量类型那样执行相同类型的操作。结构也可以作为传递给函数的参数，它们也可以作为返回值从函数返回，相同类型的结构变量相互之间可以赋值。你可以声明指向结构的指针，取一个结构变量的地址，也可以声明结构数组。但是，在讨论这些话题之前，我们必须知道一-些更为基础的东西。

二 结构声明

在声明结构时，必须列出它所包含的所有成员。这个列表包含每个成员的类型和名字

（1）常见的声明

struct  tag
{
    member-list;
}variable-list;

例如：描述一个学生

struct Stu
 {     char name[20];//名字
       int age;//年龄
       char sex[5];//性别
       char id[20];//xue'hao
  };//分号不能丢

解析：

Stu为结构体的一个标签，相当于为结构体起了一个别名，这样它就在后续的声明中可以使用。标签允许多个声明使用同一个成员列表，并且创造同一种类型的结构。

（2）特殊的声明

在声明结构的时候，可以不完全声明。

例如

// 匿名结构体类型
struct {    
          int a;   
          char b;  
        float c;
        }x; 
 struct
 {   
     int a;  
     char b; 
     float c;
 }a[20], *p;

上面的两个结构体在声明的时候都省略了结构体标签（tag）。
那么问题来了
//在上面的代码基础上，下面的代码合法吗？
p = &x；

警告：

编译器会把以上的两个声明当成完全不同的两个类型，所以的。

提示

如果你想在多个源文件中使用同一种类型的结构,你应该把标签声明或typedef形式的声明放在一个头文件中。当源文件需要这个声明时可以使用#include指令把那个头文件包含进来。

三 结构体的成员

结构的成员可以是标量，数组，指针,甚至是其他结构体。

（1）结构体成员的直接访问

结构变量的成员是通过点操作符(.)访问的。点操作符接受两个操作数，左操作数就是结构变量的名字，右操作数就是需要访问的成员的名字。这个表达式的结果就是指定的成员。

我们可以看到 s 有成员 name和age；
那我们如何访问s的成员了

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

（2）结构体成员的间接访问

如果你拥有一个指向结构的指针，你该如何访问这个结构的成员呢?首先就是对指针执行间接访问操作，这使你获得这个结构。然后你使用点操作符来访问它的成员。但是，点操作符的优先级高于间接访问操作符，所以你必须在表达式中使用括号，确保间接访问首先执行。举个例子， 假定一个函数的参数是个指向结构的指针，如下面的原型所示:

struct S 
 {
     char name[20];  
     int age; 
 }s;
 void print(struct S* ps) 
 { 
     printf("name = %s age = %d\n", (*ps).name, (*ps).age);    
     printf("name = %s age = %d\n", ps->name, ps->age);
 }

四 结构的自引用

在一个结构体内部包含一个类型为该结构本身的成员是否合法了？如以下例子：

// 代码一
 struct Node
 {   
     int data;  
     struct Node next; 
 }; 
 //是否可行
 如果可以，那sizeof(struct Node)结果是多少？

解析：这种类型的自引用是非法的，因为成员next是另一个完整的结构，其内部还将包含它自己的成员next。这第2个成员又是另一个完整的结构，它还将包括它自己的成员next。这样重复下去永无止境。这有点像永远不会终止的递归程序。但下面这个声明却是合法的，你能看出其中的区别吗?

 struct Node
 {   
     int data;  
     struct Node *next; 
 }; 

解析： 这个声明和前面那个声明的区别在于next现在是一个指针而不是结构。编译器在结构的长度确定之前就已经知道指针的长度，所以这种类型的自引用是合法的。
如果你觉得一个结构内部包含-一个指向该结构本身的指针有些奇怪，请记住它事实上所指向的是同一种类型的不同结构。更加高级的数据结构，如链表和树，都是用这种技巧实现的。每个结构指向链表的下一个元素或树的下一个分枝。

警告
注意下面这一个陷阱：

typedef struct 
 { 
     int data; 
      Node* next;
 }Node; // 这样写是否正确？

解析：这个声明的目的是为这个结构创建类型名Node. 但是，它失败了。类型名直到声明的末尾才定义，所以在结构声明的内部它尚未定义。
解决方案如下：

typedef struct Node 
 { 
     int data;  
     struct Node* next;
 }Node;

五 结构的不完整声明

        偶尔，你必须声明一些相互之间存在依赖的结构。也就是说，其中一个结构包含了另一个结构的一个或多个成员。和自引用结构样， 至少有一个结构必须在另一个结构内部以指针的形式存在。问题在于声明部分:如果每个结构都引用了其他结构的标签，哪个结构应该首先声明呢?
        这个问题的解决方案是使用不完整声明(incomplete declaration), 它声明一个作为结构标签的标识符。然后，我们可以把这个标签用在不需要知道这个结构的长度的声明中，如声明指向这个结构的指针。接下来的声明把这个标签与成员列表联系在一起。
考虑下面这个例子，两个不同类型的结构内部都有一个指向另一个结构的指针。

 struct B ；
 struct A
 {
     int _a;
     struct B* pb;
 }; 
 struct B 
 { 
 int _b;   
 struct A* pa;
 };//是否可行

分析：在A的成员列表中需要标签B的不完整声明。一旦A被声明之后，B的成员列表也可以被声明。

六 结构体变量的定义和初始化
（1）定义

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

 struct Point
 { 
     int x;  
     int y; }p1;  
     // ᰁ声明类型的同时定义类型 p1
 struct Point p2;    //定义结构体变量p2

（2）初始化

     结构的初始化方式和数组的初始化很相似。一个位于一对花括号内部、由逗号分隔的初始值列表可用于结构各个成员的初始化。这些值根据结构成员列表的顺序写出。如果初始列表的值不够，剩余的结构成员将使用缺省值进行初始化。
     结构中如果包含数组或结构成员，其初始化方式类似于多维数组的初始化。一个完整的聚合类型成员的初始值列表可以嵌套于结构的初始值列表内部。这里有一个例子:

//定义变量的同时初始化
struct Point p3 = { x, y };
struct Stu
 {   
     char name[15];   
     int age;     
 }; 
 struct Stu s = {"zhangsan", 20};
//结构体的嵌套初始化
struct Node 
 { 
     int data;   
     struct Point p;    
     struct Node* next; 
 }n1 = { 10, { 4, 5 }, NULL };            
 struct Node n2 = { 20, { 5, 6 }, NULL };

七 结构体的内存对齐

我们已经掌握了结构体的基本使用了。
现在我们深入讨论一个问题: 计算结构体的大小。
这也是一个特别热广]的考点: 结构体内存对齐

#include<stdio.h>
 struct S1 
 { 
     char a;  
     int b;    
     char c; 
 };
 struct S2 
 { 
     double d;  
     char c;   
     int i; 
 }; 
 struct S3
 {    
     char c1;
     struct S2 s2; 
     double d;
 };
 int main()
 {
     printf("%d\n", sizeof(struct S1));
     printf("%d\n", sizeof(struct S2));
     printf("%d\n", sizeof(struct S3));
         return 0;
 }

结果如下：

分析：

如果某个机器的整型值长度为4个字节，并且它的起始存储位置必须能够被4整除，那么这一个结构在内存中的存储将如下所示:

系统禁止编译器在一个结构的起始位置跳过几个字节来满足边界对齐要求，因此所有结构的起始存储位置必须是结构中边界要求最严格的数据类型所要求的位置。因此， 成员a (最左边的那个方框)必须存储于一个能够被4整除的地址。结构的下一个成员是一个整型值，所以它必须跳过3个字节(用红色显示)到达合适的边界才能存储。在整型值之后是最后-一个字符。
如果声明了相同类型的第2个变量，它的起始存储位置也必须满足4这个边界，所以第1个结构的后面还要再跳过3个字节才能存储第2个结构。因此，每个结构将占据12个字节的内存空间但实际只使用其中的6个，浪费了6个，这个利用率可不是很出色。

（1）结构体对齐规则：

1.第一个成员在与结构体变量偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字(对齐数) 的整数倍的地址处。对齐数=编译器默认
的一个对齐数与该成员大小的较小值。( VS中默认的值为8 Linux中的默认值为4)
3.结构体总大小为最大对齐数(每个成员变量都有一个对齐数)的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体
的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。

（2）为什么存在内存对齐：

大部分的参考资料都是如是说的:
1.平台原因(移植原因):
不是所有的硬件平台都能访问任意地址上的任意数据的;某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2.性能原因:
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于：为了访问未对齐的内存，处理器需要作两次内存访问;而对齐的内存访问仅需要一次访问。

总体来说：结构体的内存对齐就是拿空间换取时间的做法。
（3）那在设计结构体的时候如何满足既要对齐，又要节省空间。如何做到？

可以在声明中对结构的成员列表重新排列，让那些对边界要求最严格的成员首先出现，
对边界要求最弱的成员最后出现。这种做法可以最大限度地减少因边界对齐而带来的空间损失。
例如,下面这个结构
：

struct S1
 {
     char c1;
     int i;
     char c2;
 };
 struct S2
 {
     char c1;
     char c2;
     int i;
 };
 int main()
 {
     printf("%d\n", sizeof(struct S1));
     printf("%d\n", sizeof(struct S2));
     return 0;
 }

结果如下：

     所包含的成员和前面那个结构一-样，但它只占用8个字节的空间，节省了33%。两个字符可以紧挨着存储， 所以只有结构最后面需要跳过的两个字节才被浪费。
提示：
     有时，我们有充分的理由，决定不对结构的成员进行重排以减少因对齐带来的空间损失。例如，我们可能想把相关的结构成员存储在一-起，提高程序的可维护性和可读性。但是，如果不存在这样的理由，结构的成员应该根据它们的边界需要进行重排，减少因边界对齐而造成的内存损失。

★ 当程序将创建几百个甚至几千个结构时，减少内存浪费的要求就比程序的可读性更为急迫。在这种情况下，在声明中增加注释可能避免可读性方面的损失。
（4）如何求某个成员的边界对齐的位置

sizeof 操作符能够得出一个结构的整体长度，包括因边界对齐而跳过的那些字节。如果你必须确定结构某个成员的实际位置，应该考虑边界对齐因素，可以使用offsetof宏(定义于stddef.h)。

#define offsetof (type,member) (size_t)&(((s*)0)->m)//求m在s的偏移量

type就是结构的类型，member 就是你需要的那个成员名。表达式的结果是一个size_ t值，表示这个指定成员开始存储的位置距离结构开始存储的位置偏移几个字节。例如，对前面那个声明而言，offsetof( struct S2, i)的返回值是4。

八 结构体传参

struct S 
{ 
    int data[1000];   
    int num;
    float n;
};
struct S s = { { 1, 2, 3, 4 }, 1000,0.0 }; 

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

上面的printf1函数好还是printf2函数好？
答案是： printf2 函 数 好。

原因：
     printf 1 函数虽然能够产生正确的结果，但它的效率很低， 因为C语言的参数传值调用方式要求把参数的一份拷贝传递给函数。在我们使用的机器上整型和浮点型都占4个字节，那么这个结构将占据4000多个字节的空间。要想把它作为参数进行传递，我们必须把4000多个字节复制到堆栈中，以后再丢弃。
     而printf 2 函数传递的是一个指向结构的指针。指针比整个结构要小得多，所以把它压到堆栈上效率能提高很多。传递指针另外需要付出的代价是我们必须在函数中使用间接访问来访问结构的成员。结构越大，把指向它的指针传递给函数的效率就越高。
     可能有人会觉得传值会更加安全，可能会对结构体变量修改。但只要在printf2函数传地址时加一个const关键字即可。例如：

struct S 
{ 
    int data[1000];   
    int num;
    float n;
};
struct S s = { { 1, 2, 3, 4 }, 1000,0.0 }; 

void print1(struct S s) //结构体传参
{  
    printf("%d\n", s.num); 
} 
void print2(const struct S* ps)//结构体地址传参
{  
    printf("%d\n", ps->num); }
int main()
{
    print1(s);  //传结构体 
    print2(&s);   //传地址
    return 0;
}

     在许多机器中，你可以把参数声明为寄存器变量，从而进一步提高指针传递方案的效率。在有些机器上，这种声明在函数的起始部分还需要一条额外的指令，用于把堆栈中的参数(参数先传递给堆栈)复制到寄存器，供函数使用。但是，如果函数对这个指针的间接访问次数超过两三次，那么使用这种方法所节省的时间将远远高于一条额外指令所花费的时间。

九 位段
（一）位段的定义

     关于结构，我们最后还必须提到它们实现位段(bit field)的能力。位段的声明和结构类似，但它的成员是一个或多个位的字段。这些不同长度的字段实际上存储于一个或多个整型变量中。
     位段的声明和任何普通的结构成员声明相同，但有两个例外。首先， 位段成员必须声明为int、signed, int或unsigned int 类型。其次，在成员名的后面是一个冒号和一个整数，这个整数指定该位段所告用的位的数目。
例如：

struct A 
{ 
    int _a : 2;   
    int _b : 5;   
    int _c : 10;   
    int _d : 30; 
};

A就是一个位段类型。
（二）位段的大小
那位段A 的大小是多少？

    printf("位段A的大小是：%d\n", sizeof(struct A));

结果如下

解析 ： 在三十二位机器上可能有两种创建的方法。（另一种是倒着存，先存d，在存c，在存b，在存a。与这种类似。）

这个例子说明了一个使用位段的好理由:它能够把长度为奇数的数据包装在一起，节省存储空
间。当程序需要使用成千，上万的这类结构时，这种节省方法就会变得相当重要。

（三）位段的内存分配

1.位段的成员可以是int unsigned int signed int 或者是char (属于整形家族)类型。
2.位段的空间上是按照需要以4个字节( int )或者1个字节( char )的方式来开辟的。
3.位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

（四）位段的跨平台问题

1. int位段被当成有符号数还是无符号数是不确定的。
   2.位段中最大位的数目不能确定。 (16位机器最大16，32位机器最大32，写成27，在16
   位机器会出问题。)
   3.位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
   4.当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一一个位段剩余的位
   时，是舍弃剩余的位还是利用，这是不确定的。

总结

跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。

（一）枚举定义

枚举顾名思义就是一一列举。把可能的取值一一列举 。比如我们现实生活中:
一周的星期一到星期日是有限的
月份有12个月，也可以一一列举
颜色也可以一一列举。
这里就可以使用枚举了

enum Day
{  
    Mon,  
    Tues,
    Wed, 
    Thur, 
    Fri,
    Sat,
    Sun 
}; 
enum Sex
{
    MALE,
    FEMALE,
    SECRET
};
enum Color
{
    RED,
    GREEN,
    BLUE
};

以上定义的enum Day , enum Sex, enum Color 都是枚举类型。
{ }中的内容是枚举类型的可能取值，也叫枚举常量。这些可能取值都是有值的， 默认从0开始，一次递增1，当然在定义的时候也可以赋初值。
如以下代码：

enum Color 
{  
    RED=1,  
    GREEN=2,  
    BLUE=4 
};

（二）枚举的优点：

可能会有人问：我们可以使用#define 定义的常量，为什么要有枚举？
看以下代码：

#define RED
enum Color
{
    RED,
    GREEN,
    BLUE
};
int main()
{ 
   enum Color c = 0;
   RED = 20;//有无问题？
}

分析：上述代码是错误的，在c语言中，它不会报错，但是有错误，RED的值依然为1：但在c++中，直接报错。因为在c++中更严谨。使用#define定义的常量，它没有类型检查，所以尽量不使用。

使用枚举的好处

1.增加代码的可读性和可维护性
2.和#define定义的标识符比较枚举有类型检查，更加严谨。
3.防止了命名污染(封***r> 4.便于调试
5.使用方便，一次可以定义多个常量
**

联合
（一）联合的定义

联合的声明和结构类似，但它的行为方式却和结构不同。联合的所有成员引用的是内存中的相同位置。当你想在不同的时刻把不同的东西存储于同一个位置时，就可以使用联合。如以下例子：

// 联合类型的声明
union Un
{    
    char c;   
    int i;
};
//联合变量的定义
union Un un;

（二）联合的特点

研以下代码：

union Un {

    int i;  

    char c;

}; union Un un;

int main()

{

    // 下面输出的结果是什么？

    printf("%p\n", &(un.i));

    printf("%p\n", &(un.c));

    //下面输出的结果是什么？

    un.i = 0x11223344;
    un.c = 0x55;
    printf("%x\n", un.i);

}

结果

联合的成员是共用同一块内存空间的，这样一个联合变量的大小， 至少是最大成员的大小(
因为联合至少得有能力保存最大的那个成员)。

i 长度为四个字节，c 长度为一个字节，它俩共占一个字节。由于在同一块内存中，所以它们的地址一样。

常见的面试题：判断当前机器的大小端存储？
（1）常见的代码如下：

#include<stdio.h>
int check_sys()
{
    int i = 1;
    return *((char *)&i);//小端返回1，大段返回0；
}
int main()
{

    int ret = 0;
    ret = check_sys();
    if (ret == 1)
    {
        printf("小端存储\n");
    }
    if (ret == 0)
    {
        printf("大端存储\n");

    return 0;
}

（2） 巧妙利用联合的特点：

#include<stdio.h>

int check_sys()
{
    union Un
    {
        int i;
        char c;
    }un;
    un.i = 1;

    return un.c;//小端返回1；大段返回0；
}
int main()
{

    int ret = 0;
    ret = check_sys();
    if (ret == 1)
    {
        printf("小端存储\n");
    }
    if (ret == 0)
    {

        printf("大端存储\n");
        return 0;
    }
}

（三）联合的初始化

联合变量可以被初始化，但这个初始值必须是联合第1个成员的类型，而且它必须位于一对花
括号里面。例如：

union Un
    {
        int i;
        float b;
        char c[4];
    }un = {5};

把un.i初始化为 5。
我们不能把这个类量初始化为一个浮点值或字符值。如果给出的初始值是任何其他类型，它就
会转换(如果可能的话)为一个整数并赋值给un.a。

（四）联合的大小

●联合的大小至少是最大成员的大小。
●当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。

例如以下代码：

union Un1
{ 
    char c[5];    
    int i;
};
union Un2
{ 
    short c[7];  
    int i; 
}; 
int main()
{
    printf("%d\n", sizeof(union Un1));
    printf("%d\n", sizeof(union Un2))；
}

结果如下：

（五）联合和结构体的巧妙应用

如何将一个long型的IP地址转换为点分十进制的形式

union ip_addr
{
    unsigned long addr; 
    struct   
    {
        unsigned char c1;      
        unsigned char c2;      
        unsigned char c3;       
        unsigned char c4;
    }ip;
};
int main()
{
     union ip_addr my_ip;
     my_ip.addr = 176238749;
     printf("%d.%d.%d.%d\n", my_ip.ip.c4, my_ip.ip.c3, my_ip.ip.c2, my_ip.ip.c1);
    return 0;
}

结果如下：