【C语言深入探索】结构体详解（一）：语法

C语言中的结构体（Struct）是一种复合数据类型，它允许将不同类型的数据项组合成一个单一的类型。结构体是用户自定义的数据类型，可以包含多个不同类型的成员（变量），这些成员可以是基本数据类型（如int、float、char等），也可以是其他结构体、数组、指针等复合类型。结构体在C语言中非常有用，特别是在处理复杂数据或需要组织相关数据时。

一、定义结构体

结构体定义使用struct关键字，后跟一个可选的标签（也称为结构体标签或名称），然后是花括号{}内的一个或多个成员声明。成员可以是基本数据类型（如int、float、char等），也可以是其他结构体、数组、指针等复合类型。

struct tag {  
    member-type1 member1;  
    member-type2 member2;  
    // ... 可以有更多成员  
};

tag是结构体的标签（或名称），它是可选的。如果提供了标签，可以使用这个标签来定义该类型的变量，或者通过struct tag来引用它。
member-typeN是每个成员的数据类型。
memberN是每个成员的名称。

二、结构体变量声明

一旦定义了结构体，就可以声明该类型的变量了。

2.1. 使用结构体标签声明变量

如果结构体定义时提供了标签，可以这样声明变量：

struct tag variable1, variable2;

或者，在定义结构体时直接声明变量：

struct tag {  
    // 成员列表  
} variable1, variable2;

2.2. 使用typedef简化声明

为了简化结构体类型的声明，可以使用typedef关键字为结构体类型定义一个新的名称（别名）。

typedef struct {  
    // 成员列表  
} NewTypeName;  
  
NewTypeName variable1, variable2;

或者，如果仍然想在typedef中使用结构体标签：

typedef struct tag {  
    // 成员列表  
} NewTypeName;  
  
NewTypeName variable1, variable2;

在这种情况下，struct tag和NewTypeName都可以用来声明变量，但通常会选择使用NewTypeName因为它更简洁。

三、访问结构体成员

结构体成员的访问使用.操作符（对于结构体变量）或->操作符（对于指向结构体的指针）。

// 假设有结构体变量stu  
struct tag stu;  
stu.member1 = value1; // 使用.操作符访问和修改成员  
  
// 假设有指向结构体的指针ptr  
struct tag *ptr = &stu;  
ptr->member1 = value1; // 使用->操作符访问和修改成员

四、结构体里可以填充的内容

在C语言中，结构体里可以填充几乎任何类型的内容，包括基本数据类型（如int、float、char等）、枚举类型（enum）、其他结构体类型、联合体（union）、指针类型等。

以下是一些可以在结构体中填充的内容的示例。

4.1. 基本数据类型

struct Person {  
    int age;  
    float height;  
    char name[50];  
};

4.2. 枚举类型

enum Color { RED, GREEN, BLUE };  
struct Pixel {  
    enum Color color;  
    int intensity;  
};

4.3. 其他结构体类型

struct Address {  
    char street[100];  
    char city[50];  
    char state[2];  
    int zip;  
};  

struct Contact {  
    char name[50];  
    struct Address address;  
};

4.4. 联合体（Union）

虽然联合体通常用于节省内存或表示多种类型的数据，但它们也可以作为结构体的一部分。

union Data {  
    int i;  
    float f;  
    char str[20];  
};  

struct Record {  
    char type;  
    union Data data;  
};

4.5. 指针类型

结构体中的成员可以是指向其他数据类型的指针，包括指向其他结构体的指针。

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

struct Image {  
    int width;  
    int height;  
    unsigned char *pixels; // 指向像素数据的指针  
};

4.6. 函数指针

结构体也可以包含函数指针，在实现回调函数或策略模式时非常有用。

typedef void (*PrintFunction)(const char *str);  

struct Printer {  
    PrintFunction print;  
};  

void printHello(const char *str) {  
    printf("Hello, %s\n", str);  
}  

struct Printer printer = { printHello };

4.7. 位字段（Bit-fields）

虽然位字段不是结构体本身的内容，但可以在结构体内部使用它们来定义占用特定位数的成员。

struct Flags {  
    unsigned int is_set : 1;  
    unsigned int value : 3;  
};

五、注意事项

在C语言中使用结构体（struct）时，有几个重要的注意事项可以帮助避免常见的错误和陷阱。以下是一些关键的注意事项。

5.1. 内存分配

当声明一个结构体变量时，系统会根据结构体的成员类型和数量自动为其分配内存。但是，如果结构体的成员是指针类型，那么这些指针本身只占用固定的内存空间（通常是4或8字节，取决于平台），而指针所指向的内存需要单独分配。
使用malloc、calloc或realloc等函数为结构体或其成员（如果是指针）动态分配内存时，请确保在不再需要时释放这些内存，以避免内存泄漏。

5.2. 初始化

全局和静态声明的结构体变量会被自动初始化为零（对于基本数据类型成员）。但是，局部声明的结构体变量不会自动初始化，除非在声明时显式地初始化它们。
C99标准引入了指定初始化器（designated initializers），它允许以更直观的方式初始化结构体的成员。

5.3. 内存对齐和填充

编译器可能会在结构体的成员之间插入填充字节（padding），以确保每个成员都按照其自然对齐边界进行对齐。可能会影响结构体的大小和内存布局。
使用#pragma pack（在某些编译器中）或特定的编译器选项可以控制结构体的对齐和填充，但可能会影响程序的性能。

为了更具体地说明这些概念，以下是一个简单的例子：

#include <stdio.h>  
  
struct Nested {  
    char a;       // 1 字节  
    int b;        // 4 字节（假设int为4字节），但可能需要填充  
};  
  
struct Outer {  
    char x;       // 1 字节  
    struct Nested y; // 至少5字节（假设int为4字节，并考虑对齐）  
    short z;      // 2 字节，但可能因对齐而增加大小  
};  
  
int main() {  
    printf("Size of Nested: %zu\n", sizeof(struct Nested));  
    printf("Size of Outer: %zu\n", sizeof(struct Outer));  
    return 0;  
}

struct Nested 可能需要至少5个字节（假设int为4字节，并且存在1字节的填充以保持int的对齐），而 struct Outer 的大小将取决于编译器如何处理这些成员的对齐。如果编译器在y和z之间或z之后添加填充以确保最佳对齐，则struct Outer的大小可能会大于7字节（即x的1字节、y的至少5字节和z的2字节之和）。

要了解所使用的编译器和目标平台上的具体对齐和填充行为，可以使用sizeof运算符来检查结构体的大小，或者使用编译器的特定选项（如GCC的-Wpadded警告）来查找潜在的填充。

注意：实际的对齐和填充要求取决于编译器、目标平台和编译器选项。不同的编译器和平台可能会有不同的默认对齐规则。

5.4. 作用域和可见性

结构体的定义（包括其成员）在定义点之后是可见的，直到包含该定义的文件的末尾，除非它被其他作用域（如函数或代码块）隐藏。
如果需要在多个文件中共享结构体定义，通常会在头文件中声明结构体，并在源文件中包含该头文件。
C语言中的结构体不提供像C++中的类那样的访问控制（如public、private）。所有成员都是公开的。

5.5. 修改结构体的影响

如果在程序的不同部分修改了结构体的定义（例如，添加或删除成员），则必须确保所有使用该结构体的代码都已更新以匹配新的定义。否则，可能会导致编译错误、运行时错误或未定义行为。
在某些情况下，可能需要使用版本控制或兼容性层来管理不同版本的结构体定义。

5.6. 传递结构体给函数

结构体可以通过值、指针或引用（在C中通过指针实现）传递给函数。传递结构体值会复制整个结构体，可能会导致不必要的性能开销，特别是当结构体很大时。
传递结构体指针可以避免这种开销，但需要确保在函数外部正确地管理内存（例如，不要传递指向局部变量的指针）。

5.7. 类型安全

结构体提供了类型安全，因为可以通过结构体类型来引用其成员，而不是仅仅通过偏移量。有助于减少因类型不匹配而导致的错误。
然而，仍然需要小心处理结构体的指针和类型转换，以避免类型不安全的操作。

5.8. 命名冲突

确保结构体名称和成员名称不会与标准库中的名称或程序中其他部分的名称冲突。
使用具有描述性的命名约定可以帮助避免这种冲突。

5.9. 自引用

结构体不能直接包含自身类型的实例作为成员，但可以通过指针实现自引用。
结构体自引用是指一个结构体类型中包含一个指向相同类型结构体的指针作为成员。
这种自引用结构体常用于实现链表、树等数据结构。
下面是一个简单的结构体自引用示例，用于表示一个单向链表的节点。

#include <stdio.h>  
#include <stdlib.h>  
  
// 定义一个结构体，表示链表的节点  
struct ListNode {  
    int value;       // 节点的值  
    struct ListNode *next; // 指向下一个节点的指针，这里发生了自引用  
};  
  
// 创建一个新节点的函数  
struct ListNode* createNode(int value) {  
    struct ListNode *newNode = (struct ListNode*)malloc(sizeof(struct ListNode));  
    if (newNode == NULL) {  
        // 内存分配失败的处理  
        return NULL;  
    }  
    newNode->value = value;  
    newNode->next = NULL; // 新节点的next指针初始化为NULL，表示这是链表的末尾  
    return newNode;  
}  
  
// 向链表头部添加节点的函数  
void addToListHead(struct ListNode **head, int value) {  
    struct ListNode *newNode = createNode(value);  
    if (newNode == NULL) {  
        // 创建节点失败的处理  
        return;  
    }  
    newNode->next = *head; // 新节点的next指向原来的头节点  
    *head = newNode;       // 更新头节点为新节点  
}  
  
// 打印链表的函数  
void printList(struct ListNode *head) {  
    struct ListNode *current = head;  
    while (current != NULL) {  
        printf("%d -> ", current->value);  
        current = current->next;  
    }  
    printf("NULL\n");  
}  
  
int main() {  
    struct ListNode *head = NULL; // 初始时链表为空  
  
    // 向链表中添加节点  
    addToListHead(&head, 1);  
    addToListHead(&head, 2);  
    addToListHead(&head, 3);  
  
    // 打印链表  
    printList(head);  
  
    // 注意：这里应该添加释放链表内存的代码，以避免内存泄漏  
    // 但为了简洁起见，这里省略了  
  
    return 0;  
}

struct ListNode 是一个自引用的结构体，因为它包含了一个指向同类型结构体的指针 next。利用这个自引用特性来构建了一个简单的单向链表。

需要注意的是，在实际应用中，当链表不再需要时，应该遍历链表并释放每个节点所占用的内存，以避免内存泄漏。在这个示例中，为了保持代码的简洁性，释放内存的代码被省略了。

5.10 指针与数组

结构体中可以包含指针和数组，为处理复杂数据结构如链表、栈、队列、树和图等提供了极大的灵活性。然而，使用指针和数组时，必须谨慎管理内存，以避免内存泄漏和越界访问等问题。

下面是一个使用结构体包含指针和数组的示例，将实现一个简单的动态字符串数组（字符串列表），并展示如何安全地管理内存。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义一个结构体，包含指向字符串数组的指针和数组的大小
typedef struct {
    char **strings; // 指向字符指针数组的指针
    int size;       // 数组当前的大小
    int capacity;   // 数组的总容量
} StringArray;

// 初始化字符串数组
StringArray* createStringArray(int initialCapacity) {
    StringArray *array = (StringArray *)malloc(sizeof(StringArray));
    if (array == NULL) return NULL;

    array->strings = (char**)malloc(initialCapacity * sizeof(char*));
    if (array->strings == NULL) {
        free(array);
        return NULL;
    }

    array->size = 0;
    array->capacity = initialCapacity;

    return array;
}

// 向字符串数组中添加字符串
void addString(StringArray *array, const char *str) {
    if (array->size == array->capacity) {
        // 如果当前大小等于容量，则需要扩容
        char **newStrings = (char**)realloc(array->strings, 2 * array->capacity * sizeof(char*));
        if (newStrings == NULL) return; // 扩容失败，不处理错误，仅返回

        array->strings = newStrings;
        array->capacity *= 2;
    }

    // 分配内存给新字符串并复制内容
    array->strings[array->size] = strdup(str); // 注意：strdup会分配内存，需要释放
    if (array->strings[array->size] == NULL) return; // 内存分配失败，不处理错误，仅返回

    array->size++;
}

// 释放字符串数组的内存
void freeStringArray(StringArray *array) {
    if (array == NULL) return;

    for (int i = 0; i < array->size; i++) {
        free(array->strings[i]); // 释放每个字符串的内存
    }

    free(array->strings); // 释放字符串指针数组的内存
    free(array); // 释放StringArray结构体的内存
}

// 打印字符串数组的内容
void printStringArray(StringArray *array) {
    for (int i = 0; i < array->size; i++) {
        printf("%s\n", array->strings[i]);
    }
}

int main() {
    StringArray *myArray = createStringArray(5); // 初始容量为5

    addString(myArray, "Hello");
    addString(myArray, "World");
    addString(myArray, "C Programming");

    printStringArray(myArray);

    freeStringArray(myArray); // 释放内存，避免内存泄漏

    return 0;
}

创建了一个StringArray结构体，它包含了一个指向字符串数组的指针（char **strings）、一个表示当前大小的整数（size）和一个表示总容量的整数（capacity）。我们使用malloc和realloc来动态分配内存，并在不再需要时通过free来释放内存，以避免内存泄漏。同时，我们也使用了strdup来复制字符串，但请注意，strdup也会分配内存，因此我们也需要在适当的时候释放它。

此外，我们还展示了如何检查内存分配是否成功，并在失败时进行处理（在这个简单的示例中，我们只是返回而不做任何错误处理，但在实际应用中，可能需要更复杂的错误处理逻辑）。

这个示例演示了如何在结构体中使用指针和数组，并展示了如何安全地管理内存。