结构体(基础知识)

结构声明：

方式：

struct tag { member-list } variable-list;

例子：

struct {
        int a;
        char b;
        float c;
} x;

声明了一个名叫x的变量，包含三个成员：一个整数、一个字符、一个浮点数。

struct {
        int a;
        char b;
        float c;
} y[2], *z;

创建了y和z，y是一个数组，包含20个结构。z是一个指针，指向这个类型结构。

警告：这两个声明被编译器当作两种截然不同的类型，即使它们的成员列表完全相同。因此，变量y和z的类型和x的类型不同，所以下面这条语句是非法的。

z  = &x;

标签(tag)字 段允许为成员列表提供-一个名字，这样它就可以在后续的声明中使用。标签允许多个声明使用同一个成员列表，并且创建同-种类型的结构。这里有个例子。

struct SIMPLE {
    int a;
    char b;
    float c;
};

这个声明把标签SIMPLE和这个成员列表联系在一起。该声明并没有提供变量列表，所以它并未创建任何变量。标签标识了一种模式，用于声明未来的变量，但无论标签还是模式本身都不是变量。

struct SIMPLE x;
struct SIMPLE y[20], *z;

这些声明使用标签来创建变量。它们创建和最初两个例子一样的变量，但存在一个重要的区别一现在x、y和z都是同一种类型的结构变量。声明结构时可以使用的另一种良好技巧是用typedef创建一种新的类型。

typedef struct {
    int a;
    char b;
    float c;
} Simple;

这个技巧和声明一个结构标签的效果几乎相同。区别在于Simple现在是个类型名而不是个结构标签，所以后续的声明可能像下面这个样子:

Simple x;
Simple y[20], *z;

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

结构成员：

结构体外部生命的任何变量都可以作为结构的成员，尤其是标量、数组、指针、甚至其他的结构。

结构体的成员可以与其他结构体成员的名字相同，这是结构访问方式决定的。

结构成员的直接访问：

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

struct COMPLEX comp;

名字为a的成员是-一个数组，所以表达式comp.a就选择了这个成员。这个表达式的结果是个数组名，所以你可以把它用在任何可以使用数组名的地方。类似地,成员s是个结构,所以表达式comp.s的结果是个结构名，它可以用于任何可以使用普通结构变量的地方。尤其是，我们可以把这个表达式用作另一个点操作符的左操作符，如(comp.s).a, 选择结构comp的成员s (也是一个结构)的成员a。点操作符的结合性是从左向右，所以我们可以省略括号，表达式comp.s.a表示同样的意思。

这里有一个更为复杂的例子。成员sa是一个结构数组，所以comp.sa是一个数组名，它的值是一个指针常量。对这个表达式使用下标引用操作，如(comp.sa)[4]将选择一个数组元素。 但这个元素本身是一个结构，所以我们可以使用另一个点操作符取得它的成员之一。下面就是一个这样的表达式:

( (comp.sa)[4] ).c

下标引用和点操作符具有相同的优先级，它们的结合性都是从左向右，所以我们可以省略所有的括号。下面的表达式和前面那个表达式是等效的。

comp.sa[4].c

结构成员的间接访问:
 

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

void func ( struct COMPLEX *CP );

函数可以使用下面这个表达式来访问这个变量所指向的结构的成员f:
 

(*cp).f

对指针执行间接访问将访问结构，然后点操作符访问一个成员。
C语言提供了一个更为方便的操作符来完成这项工作一--->操作符(也称箭头操作符)。和点操作符一样，箭头操作符接受两个操作数，但左操作数必须是一个指向结构的指针。箭头操作符对左操作数执行间接访问取得指针所指向的结构，然后和点操作符一样，根据右操作数选择一个指定的结构成员。但是，间接访问操作内建于箭头操作符中，所以我们不需要显式地执行间接访问或使用括号。这里有一一些例子，像前面一样使用同一个指针。
 

cp -> f
cp -> a
cp -> s

结构的自引用：

在一个结构内部包含一个类型为该结构本身的成员是否合法呢?
 

struct SELF_REF1 {
    int a;
    struct SELF_REF1 b;
    int c;
}

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

struct SELF_REF2 {
    int a;
    struct SELF_REF2 b;
    int c;
}

这个声明和前面那个声明的区别在于b现在是一个指针而不是结构。编译器在结构的长度确定之前就已经知道指针的长度，所以这种类型的自引用是合法的。

如果你觉得一个结构内部包含一个指向该结构本身的指针有些奇怪，请记住它事实上所指向的是同一种类型的不同结构。更加高级的数据结构，如链表和树，都是用这种技巧实现的。每个结构指向链表的下一个元素或树的下一个分枝。
警告：警惕下面的陷阱

typedef struct {
    int a;
    SELF_REF3 *b;
    int c;
} SELF_REF3;

这个声明的目的是为这个结构创建类型名SELF_ REF3. 但是，它失败了。类型名直到声明的末尾才定义，所以在结构声明的内部它尚未定义。

解决方案是定义一个结构标签来声明b,如下所示:

typedef struct SELF_REF3_TAG {
    int a;
    struct SELF_REF3_TAG *b;
    int c; 
    
} SELF_REF3;

在公司经常使用的和这个差不多：
 

typedef struct SELF_REF3_TAG SELF_REF3;
struct SELF_REF3_TAG {
    int a;
    struct SELF_REF3_TAG *b;
    int c; 
    
};

感觉这样更加整洁了。

不完整的声明：

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

struct B;
struct A {
    struct B *partner;
    /* other declaratons */
};

struct B {
    struct A *partner;
    /* other declaratons */
};

可以改成这个样子：
 

typedef struct BTAG B;
typedef struct ATAG A;
struct ATAG {
    struct B *partner;
    /* other declaratons */
};
A num;
struct BTAG {
    struct A *partner;
    /* other declaratons */
};

结构体的初始化：
 

结构的初始化方式和数组的初始化很相似。一个位于一 对花括号内部、由逗号分隔的初始值列表可用于结构各个成员的初始化。这些值根据结构成员列表的顺序写出。如果初始列表的值不够，剩余的结构成员将使用缺省值进行初始化。
四种方法：

/*
**定义
*/
struct InitMember
{
    int first；
    double second；
    char* third；
    float four;
};

/*
**方法一：定义时赋值
*/
struct InitMember test = {-10,3.141590, "method one", 0.25};

/*
**方法二：定义后逐个赋值
**因为是逐个确定的赋值，无所谓顺序啦。
*/
struct InitMember test;

test.first = -10;
test.second = 3.141590;
test.third = "method two";
test.four = 0.25;

/*
**方法三：定义时乱序赋值（C风格）
**这种方法类似于第一种方法和第二种方法的结合体，既能初始化时赋值，也可以不考虑顺序；
**这种方法在Linux内核（kernel）中经常使用，在音视频编解码库FFmpeg中也大量频繁使用，还是很不错的一种方式。
*/
struct InitMember test = {
    .second = 3.141590,
    .third = "method three",
    .first = -10,
    .four = 0.25
};

/*
**方法四：定义时乱序赋值（C++风格）
**这种方法和前一种类似，网上称之为C++风格，类似于key-value键值对的方式，同样不考虑顺序。
*/
struct InitMember test = {
    second：3.141590,
    third："method three",
    first：-10,
    four：0.25
};