C语言构造数据类型：结构体、数组与共用体详解

1. 构造数据类型：C语言中的复合结构体

在C语言的世界里，构造数据类型就像乐高积木一样，允许我们将基本的数据块组合成更复杂的结构。当我们需要描述一个包含多个属性的实体时——比如学生的学号、姓名、成绩，或者一个三维坐标点的x、y、z值——构造数据类型就派上了大用场。

C语言提供了三种主要的构造数据类型：数组、结构体和共用体。数组让我们可以存储同一类型的多个数据；结构体允许我们将不同类型的数据组合在一起；而共用体则提供了在同一内存位置存储不同数据类型的能力。这三种构造类型构成了C语言处理复杂数据的基础工具集。

提示：理解构造数据类型的关键在于明白它们是如何在内存中布局的。结构体的成员在内存中是连续存储的，而共用体的成员则共享同一块内存空间。

2. 结构体：自定义复合类型的利器

2.1 结构体的定义与声明

结构体是C语言中最常用的构造数据类型之一。它允许我们将不同类型的数据组合成一个整体。定义结构体的基本语法如下：

c复制struct 结构体名 {
    数据类型 成员1;
    数据类型 成员2;
    // 更多成员...
};

例如，我们可以定义一个表示学生的结构体：

c复制struct Student {
    int id;          // 学号
    char name[20];   // 姓名
    float score;     // 成绩
};

定义好结构体后，我们可以声明结构体变量：

c复制struct Student stu1, stu2;

C99标准还允许在定义结构体的同时声明变量：

c复制struct Point {
    int x;
    int y;
} p1, p2;

2.2 结构体的初始化和访问

结构体变量可以通过多种方式初始化：

c复制// 方式1：按定义顺序初始化
struct Student stu1 = {1001, "张三", 89.5};

// 方式2：指定成员初始化(C99特性)
struct Student stu2 = {.name = "李四", .score = 92.0, .id = 1002};

// 方式3：先声明后逐个赋值
struct Student stu3;
stu3.id = 1003;
strcpy(stu3.name, "王五");
stu3.score = 76.5;

访问结构体成员使用点运算符(.)：

c复制printf("学号: %d, 姓名: %s, 成绩: %.1f\n", 
       stu1.id, stu1.name, stu1.score);

对于结构体指针，我们可以使用箭头运算符(->)访问成员：

c复制struct Student *pStu = &stu1;
printf("姓名: %s\n", pStu->name);

2.3 结构体的内存对齐

结构体在内存中的布局遵循对齐原则，这会影响结构体的大小。考虑以下结构体：

c复制struct Example {
    char c;    // 1字节
    int i;     // 4字节
    double d;  // 8字节
};

在32位系统上，这个结构体的大小不是简单的1+4+8=13字节，而是16字节。这是因为编译器会在成员之间插入填充字节以满足对齐要求。我们可以使用sizeof运算符查看结构体大小：

c复制printf("结构体大小: %zu字节\n", sizeof(struct Example));

注意：结构体对齐可以提高内存访问效率，但也会造成内存浪费。在内存受限的嵌入式系统中，可以使用#pragma pack指令调整对齐方式。

3. 数组：同类型数据的集合

3.1 数组的定义与使用

数组是C语言中最简单的构造数据类型，它允许我们在一个变量名下存储多个同类型的值。数组的定义语法如下：

c复制数据类型 数组名[数组长度];

例如，定义一个包含5个整数的数组：

c复制int numbers[5] = {1, 2, 3, 4, 5};

数组元素通过下标访问，下标从0开始：

c复制numbers[0] = 10;    // 修改第一个元素
printf("%d", numbers[2]);  // 输出第三个元素

3.2 多维数组

C语言支持多维数组，最常见的二维数组可以看作是一个表格：

c复制int matrix[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

访问二维数组元素需要两个下标：

c复制matrix[1][2] = 10;  // 修改第二行第三列的元素

3.3 数组与指针的关系

数组名实际上是一个指向数组首元素的常量指针。以下两种方式是等价的：

c复制int arr[5] = {1, 2, 3, 4, 5};
int *p = arr;  // 等价于 int *p = &arr[0]

我们可以用指针算术来遍历数组：

c复制for (int i = 0; i < 5; i++) {
    printf("%d ", *(p + i));
}

4. 共用体：共享内存的多面手

4.1 共用体的定义与特点

共用体(union)是一种特殊的数据类型，它允许不同的数据类型共享同一块内存空间。共用体的定义语法与结构体类似：

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

共用体的大小等于其最大成员的大小。上面的Data共用体在32位系统上占20字节（因为char str[20]是最大的成员）。

4.2 共用体的使用场景

共用体常用于以下场景：

1. 节省内存空间，特别是当知道多个成员不会同时使用时
2. 实现数据的多解释方式
3. 与硬件寄存器交互时，寄存器可能包含不同类型的值

使用示例：

c复制union Data data;
data.i = 10;
printf("data.i: %d\n", data.i);

data.f = 3.14;
printf("data.f: %f\n", data.f);

警告：访问共用体成员时，只有最后一次赋值的成员是有定义的。访问其他成员会导致未定义行为。

4.3 共用体与结构体的结合

共用体常与结构体结合使用，形成更复杂的数据结构。例如，我们可以创建一个能够存储不同类型数据的变体类型：

c复制struct Variant {
    enum { INT, FLOAT, STRING } type;
    union {
        int i;
        float f;
        char str[20];
    } value;
};

这样使用时：

c复制struct Variant var;
var.type = INT;
var.value.i = 100;

if (var.type == INT) {
    printf("%d\n", var.value.i);
}

5. 枚举类型：提高代码可读性

虽然枚举不是严格意义上的构造数据类型，但它常与结构体一起使用，值得在这里介绍。

5.1 枚举的定义

枚举类型允许我们定义一组命名的整数常量：

c复制enum Weekday { SUN, MON, TUE, WED, THU, FRI, SAT };

默认情况下，第一个枚举常量值为0，后续依次加1。我们也可以显式指定值：

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

5.2 枚举的使用

枚举变量可以像其他变量一样使用：

c复制enum Weekday today = MON;

if (today == MON || today == FRI) {
    printf("今天有会议\n");
}

枚举提高了代码的可读性，比直接使用魔数(magic number)要好得多。

6. 构造数据类型的进阶应用

6.1 结构体中的结构体

结构体可以嵌套其他结构体，形成更复杂的数据结构：

c复制struct Date {
    int year;
    int month;
    int day;
};

struct Person {
    char name[20];
    struct Date birthday;
    float height;
};

访问嵌套结构体成员：

c复制struct Person p = {"张三", {1990, 5, 15}, 175.5};
printf("%s出生于%d年%d月%d日\n", 
       p.name, p.birthday.year, p.birthday.month, p.birthday.day);

6.2 结构体与动态内存分配

我们可以动态分配结构体内存：

c复制struct Student *pStu = malloc(sizeof(struct Student));
if (pStu == NULL) {
    // 处理内存分配失败
}
pStu->id = 1001;
// 使用完毕后记得释放内存
free(pStu);

6.3 结构体与函数

结构体可以作为函数参数和返回值：

c复制struct Point makePoint(int x, int y) {
    struct Point temp;
    temp.x = x;
    temp.y = y;
    return temp;
}

void printPoint(struct Point p) {
    printf("(%d, %d)\n", p.x, p.y);
}

为了提高效率，通常传递结构体指针而不是整个结构体：

c复制void scalePoint(struct Point *p, int factor) {
    p->x *= factor;
    p->y *= factor;
}

7. 构造数据类型的实际应用案例

7.1 链表实现

构造数据类型最常见的应用之一是实现链表。下面是一个简单的单向链表实现：

c复制struct Node {
    int data;
    struct Node *next;
};

// 在链表头部插入新节点
void insertAtHead(struct Node **head, int data) {
    struct Node *newNode = malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = *head;
    *head = newNode;
}

// 遍历链表
void printList(struct Node *node) {
    while (node != NULL) {
        printf("%d ", node->data);
        node = node->next;
    }
    printf("\n");
}

7.2 学生成绩管理系统

我们可以用结构体数组实现一个简单的学生成绩管理系统：

c复制#define MAX_STUDENTS 100

struct Student {
    int id;
    char name[20];
    float score;
};

struct Student students[MAX_STUDENTS];
int studentCount = 0;

void addStudent(int id, const char *name, float score) {
    if (studentCount < MAX_STUDENTS) {
        students[studentCount].id = id;
        strcpy(students[studentCount].name, name);
        students[studentCount].score = score;
        studentCount++;
    }
}

void printAllStudents() {
    for (int i = 0; i < studentCount; i++) {
        printf("学号: %d, 姓名: %s, 成绩: %.1f\n",
               students[i].id, students[i].name, students[i].score);
    }
}

7.3 位字段：节省空间的特殊结构体

对于需要精确控制位的场景，可以使用位字段：

c复制struct {
    unsigned int is_keyword : 1;  // 占1位
    unsigned int is_extern : 1;   // 占1位
    unsigned int is_static : 1;   // 占1位
    unsigned int : 5;             // 5位未使用
    unsigned int type : 3;        // 占3位
} flags;

位字段常用于硬件编程和协议处理中，可以精确控制数据的位级表示。

8. 构造数据类型的常见问题与调试技巧

8.1 结构体赋值问题

初学者常犯的错误是试图直接比较或赋值结构体：

c复制struct Point p1 = {1, 2};
struct Point p2;
p2 = p1;  // C语言允许这样赋值，但不建议依赖这个特性

if (p1 == p2) {  // 错误！不能直接比较结构体
    // ...
}

正确做法是逐个比较成员，或者使用memcmp函数（但有填充字节的问题）：

c复制if (p1.x == p2.x && p1.y == p2.y) {
    // ...
}

8.2 数组越界访问

数组越界是C语言中最常见的错误之一：

c复制int arr[5] = {1, 2, 3, 4, 5};
printf("%d", arr[5]);  // 越界访问！

越界访问可能导致程序崩溃或难以调试的行为。务必确保数组访问在有效范围内。

8.3 共用体的误用

共用体使用不当会导致数据解释错误：

c复制union Data data;
data.i = 10;
printf("%f", data.f);  // 错误！此时共用体存储的是int，不是float

确保在访问共用体成员时，它确实存储的是该类型的数据。

8.4 内存对齐问题

在跨平台开发时，结构体的内存对齐可能导致问题：

c复制struct Packet {
    char header;
    int length;  // 对齐可能导致header和length之间有填充字节
    char data[100];
};

如果需要在不同平台间传输这样的结构体，可能需要使用#pragma pack取消对齐：

c复制#pragma pack(push, 1)
struct Packet {
    char header;
    int length;
    char data[100];
};
#pragma pack(pop)

9. 构造数据类型的最佳实践

9.1 使用typedef简化类型名

频繁使用struct关键字可能使代码冗长。可以使用typedef简化：

c复制typedef struct {
    int x;
    int y;
} Point;

Point p1 = {1, 2};  // 不再需要写struct关键字

9.2 为结构体设计合理的操作函数

将结构体的操作封装成函数，提高代码的模块化：

c复制typedef struct {
    float real;
    float imag;
} Complex;

Complex addComplex(Complex a, Complex b) {
    Complex result;
    result.real = a.real + b.real;
    result.imag = a.imag + b.imag;
    return result;
}

9.3 文档化结构体的用途和成员

良好的注释可以帮助他人理解结构体的设计意图：

c复制/**
 * 表示二维空间中的点
 * x - 横坐标
 * y - 纵坐标
 */
typedef struct {
    int x;
    int y;
} Point;

9.4 避免过度复杂的嵌套

虽然C语言允许深度嵌套的结构，但过度嵌套会降低代码可读性：

c复制// 不推荐
struct A {
    struct B {
        struct C {
            // ...
        } c;
    } b;
};

// 推荐
struct C {
    // ...
};

struct B {
    struct C c;
    // ...
};

struct A {
    struct B b;
    // ...
};

10. 构造数据类型在现代C编程中的应用

10.1 面向对象风格的编程

虽然C语言不是面向对象的语言，但我们可以用结构体和函数指针模拟一些面向对象的特性：

c复制typedef struct {
    int x, y;
    
    void (*print)(const struct Shape*);
    float (*area)(const struct Shape*);
} Shape;

void printShape(const Shape *s) {
    printf("Shape at (%d, %d)\n", s->x, s->y);
}

typedef struct {
    Shape base;
    int width, height;
} Rectangle;

float rectangleArea(const Shape *s) {
    const Rectangle *r = (const Rectangle*)s;
    return r->width * r->height;
}

void printRectangle(const Shape *s) {
    const Rectangle *r = (const Rectangle*)s;
    printf("Rectangle at (%d, %d), size %dx%d\n", 
           r->base.x, r->base.y, r->width, r->height);
}

int main() {
    Rectangle r = {
        .base = {10, 20, printRectangle, rectangleArea},
        .width = 30,
        .height = 40
    };
    
    r.base.print((Shape*)&r);
    printf("Area: %.1f\n", r.base.area((Shape*)&r));
    return 0;
}

10.2 泛型编程技巧

C语言没有直接的泛型支持，但我们可以用void指针和构造数据类型模拟泛型：

c复制typedef struct {
    void *data;
    size_t size;
    int type;  // 0=int, 1=float, 2=string, etc.
} GenericValue;

void printGeneric(const GenericValue *g) {
    switch (g->type) {
        case 0: printf("%d", *(int*)g->data); break;
        case 1: printf("%f", *(float*)g->data); break;
        case 2: printf("%s", (char*)g->data); break;
        default: printf("Unknown type");
    }
}

10.3 嵌入式系统中的寄存器映射

在嵌入式开发中，结构体常用于映射硬件寄存器：

c复制typedef struct {
    volatile uint32_t CR;     // 控制寄存器
    volatile uint32_t SR;     // 状态寄存器
    volatile uint32_t DR;     // 数据寄存器
    volatile uint32_t BRR;    // 波特率寄存器
} USART_TypeDef;

#define USART1 ((USART_TypeDef *)0x40011000)

void USART_Init() {
    USART1->BRR = 0x341;   // 设置波特率
    USART1->CR = 0x200C;   // 启用发送和接收
}

这种技术使得硬件访问更加直观和安全。