C语言结构体的定义与基本用法

C语言结构体的定义

在C语言中，结构体（struct）是一种用户自定义的数据类型，它允许将不同类型的数据组合在一起，形成一个新的复合数据类型。结构体的定义语法如下：

struct 结构体名 {
    数据类型1 成员变量1;
    数据类型2 成员变量2;
    // 可以有更多不同类型的成员变量
    数据类型n 成员变量n;
};

例如，我们要定义一个表示学生信息的结构体，包含学生的姓名（字符串类型，在C语言中通常用字符数组表示）、年龄（整数类型）和成绩（浮点数类型），可以这样定义：

struct Student {
    char name[50];
    int age;
    float score;
};

这里，struct是关键字，用于声明一个结构体类型。Student是结构体的名称，它是自定义的标识符，用于在后续代码中引用这个结构体类型。大括号内定义了结构体的成员变量，name是一个字符数组，用于存储学生姓名，长度为50，足以存储一般长度的姓名；age是一个整数，用于表示学生的年龄；score是一个浮点数，用于记录学生的成绩。

需要注意的是，结构体定义本身并不会分配内存空间，它只是定义了一种数据类型的布局和组成方式。就像我们定义了一个蓝图，描述了一个“学生”应该包含哪些信息，但并没有真正创建出具体的学生实例。

结构体变量的声明与初始化

1. 结构体变量的声明 在定义了结构体类型之后，我们可以声明该结构体类型的变量，就像声明基本数据类型（如int、float等）的变量一样。声明结构体变量有以下几种方式：

• 先定义结构体类型，再声明变量

struct Student {
    char name[50];
    int age;
    float score;
};
struct Student stu1, stu2;

这里，先定义了struct Student结构体类型，然后声明了两个struct Student类型的变量stu1和stu2。

• 定义结构体类型的同时声明变量

struct Student {
    char name[50];
    int age;
    float score;
} stu1, stu2;

这种方式在定义struct Student结构体类型的同时，声明了stu1和stu2两个变量。

• 省略结构体名声明变量（匿名结构体）

struct {
    char name[50];
    int age;
    float score;
} stu1, stu2;

这种方式没有给结构体命名，直接声明了stu1和stu2两个变量。不过，这种匿名结构体在后续代码中无法再用于声明新的变量，因为没有结构体名可以引用它，通常用于只需要使用一次的结构体实例场景。

2. 结构体变量的初始化 结构体变量在声明时可以进行初始化，初始化的方式是在变量名后面跟上一对花括号，里面按照结构体成员变量的顺序依次给出初始值。

struct Student {
    char name[50];
    int age;
    float score;
};
struct Student stu1 = {"Alice", 20, 85.5};

在这个例子中，stu1被初始化为姓名为“Alice”，年龄为20，成绩为85.5。

如果初始化的值的个数少于结构体成员变量的个数，对于剩余的成员变量，对于数值类型（如int、float）会被初始化为0，对于字符数组会被初始化为空字符串（即每个元素都是'\0'）。

struct Student stu2 = {"Bob"};

这里stu2的name被初始化为“Bob”，age会被初始化为0，score也会被初始化为0。

结构体成员的访问

当我们声明并初始化了结构体变量后，就可以访问结构体的成员变量来获取或修改其值。在C语言中，通过点运算符（.）来访问结构体变量的成员。

#include <stdio.h>

struct Student {
    char name[50];
    int age;
    float score;
};

int main() {
    struct Student stu = {"Charlie", 22, 90.0};
    // 访问并打印结构体成员
    printf("Name: %s\n", stu.name);
    printf("Age: %d\n", stu.age);
    printf("Score: %.2f\n", stu.score);

    // 修改结构体成员的值
    stu.age = 23;
    stu.score = 92.5;
    printf("Updated Age: %d\n", stu.age);
    printf("Updated Score: %.2f\n", stu.score);

    return 0;
}

在上述代码中，通过stu.name、stu.age和stu.score来访问stu这个结构体变量的成员。首先打印出初始的成员值，然后修改age和score的值并再次打印。

如果结构体成员本身又是一个结构体类型，就需要使用多个点运算符来层层访问。例如，我们定义一个表示日期的结构体Date，再定义一个包含日期成员的Person结构体：

#include <stdio.h>

struct Date {
    int year;
    int month;
    int day;
};

struct Person {
    char name[50];
    struct Date birthdate;
};

int main() {
    struct Person p = {"David", {1990, 5, 15}};
    // 访问并打印结构体成员
    printf("Name: %s\n", p.name);
    printf("Birthdate: %d-%d-%d\n", p.birthdate.year, p.birthdate.month, p.birthdate.day);

    return 0;
}

在这个例子中，通过p.birthdate.year、p.birthdate.month和p.birthdate.day来访问p结构体中birthdate成员（它本身是一个struct Date类型）的内部成员。

结构体数组

结构体数组是指数组中的每个元素都是一个结构体类型。结构体数组的声明和初始化与普通数组类似，只是数组元素的类型是结构体类型。

1. 结构体数组的声明

struct Student {
    char name[50];
    int age;
    float score;
};
struct Student students[3];

这里声明了一个struct Student类型的数组students，数组大小为3，可以存储3个学生的信息。

2. 结构体数组的初始化

struct Student students[3] = {
    {"Eve", 21, 88.0},
    {"Frank", 23, 90.5},
    {"Grace", 22, 86.5}
};

在初始化结构体数组时，每个元素都用一对花括号括起来，按照结构体成员的顺序给出初始值。

3. 访问结构体数组的元素和成员

#include <stdio.h>

struct Student {
    char name[50];
    int age;
    float score;
};

int main() {
    struct Student students[3] = {
        {"Eve", 21, 88.0},
        {"Frank", 23, 90.5},
        {"Grace", 22, 86.5}
    };

    // 遍历结构体数组并打印学生信息
    for (int i = 0; i < 3; i++) {
        printf("Student %d:\n", i + 1);
        printf("Name: %s\n", students[i].name);
        printf("Age: %d\n", students[i].age);
        printf("Score: %.2f\n", students[i].score);
    }

    return 0;
}

在上述代码中，通过students[i].name、students[i].age和students[i].score来访问students数组中第i个元素（即第i个学生）的成员变量，并通过循环遍历打印出每个学生的信息。

结构体指针

结构体指针是指向结构体变量的指针。与普通指针类似，结构体指针存储的是结构体变量在内存中的地址。

1. 结构体指针的声明与初始化

struct Student {
    char name[50];
    int age;
    float score;
};
struct Student stu = {"Hank", 24, 93.0};
struct Student *ptr = &stu;

这里，ptr是一个指向struct Student类型的指针，通过&运算符获取stu结构体变量的地址并赋值给ptr。

2. 通过结构体指针访问结构体成员 通过结构体指针访问结构体成员不能使用点运算符（.），而要使用箭头运算符（->）。

#include <stdio.h>

struct Student {
    char name[50];
    int age;
    float score;
};

int main() {
    struct Student stu = {"Hank", 24, 93.0};
    struct Student *ptr = &stu;

    // 通过指针访问并打印结构体成员
    printf("Name: %s\n", ptr->name);
    printf("Age: %d\n", ptr->age);
    printf("Score: %.2f\n", ptr->score);

    return 0;
}

在上述代码中，通过ptr->name、ptr->age和ptr->score来访问ptr所指向的结构体变量stu的成员。

箭头运算符（->）实际上是一种语法糖，它等价于先通过指针解引用（*）得到结构体变量，再使用点运算符（.）访问成员。即ptr->name等价于(*ptr).name。

结构体作为函数参数

在C语言中，可以将结构体作为函数参数传递，这样函数就可以对结构体的成员进行操作。

1. 传递结构体变量

#include <stdio.h>

struct Student {
    char name[50];
    int age;
    float score;
};

// 函数声明，参数为结构体变量
void printStudent(struct Student stu) {
    printf("Name: %s\n", stu.name);
    printf("Age: %d\n", stu.age);
    printf("Score: %.2f\n", stu.score);
}

int main() {
    struct Student stu = {"Ivy", 25, 95.0};
    printStudent(stu);
    return 0;
}

在这个例子中，printStudent函数的参数是一个struct Student类型的结构体变量stu。在函数内部，可以像访问普通结构体变量一样访问其成员并进行打印。

需要注意的是，这种方式传递结构体变量时，函数会复制整个结构体的内容，当结构体比较大时，这种复制操作可能会消耗较多的时间和内存空间。

2. 传递结构体指针 为了避免传递结构体变量时的复制开销，可以传递结构体指针。

#include <stdio.h>

struct Student {
    char name[50];
    int age;
    float score;
};

// 函数声明，参数为结构体指针
void printStudent(struct Student *stu) {
    printf("Name: %s\n", stu->name);
    printf("Age: %d\n", stu->age);
    printf("Score: %.2f\n", stu->score);
}

int main() {
    struct Student stu = {"Ivy", 25, 95.0};
    printStudent(&stu);
    return 0;
}

在这个例子中，printStudent函数的参数是一个指向struct Student类型的指针stu。在函数内部，通过箭头运算符（->）来访问结构体成员。传递结构体指针时，只传递了结构体变量的地址，而不是整个结构体的内容，因此效率更高。

3. 函数返回结构体 函数也可以返回一个结构体类型的值。

#include <stdio.h>

struct Point {
    int x;
    int y;
};

// 函数声明，返回结构体
struct Point getPoint() {
    struct Point p;
    p.x = 10;
    p.y = 20;
    return p;
}

int main() {
    struct Point result = getPoint();
    printf("x: %d, y: %d\n", result.x, result.y);
    return 0;
}

在这个例子中，getPoint函数返回一个struct Point类型的结构体。在main函数中，接收返回的结构体并打印其成员的值。

结构体的嵌套

结构体可以嵌套，即一个结构体的成员可以是另一个结构体类型。

#include <stdio.h>

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

struct Employee {
    char name[50];
    int age;
    struct Address empAddress;
};

int main() {
    struct Employee emp = {
        "Jack",
        30,
        {"123 Main St", "Anytown", 12345}
    };

    printf("Employee Name: %s\n", emp.name);
    printf("Age: %d\n", emp.age);
    printf("Address: %s, %s, %d\n", emp.empAddress.street, emp.empAddress.city, emp.empAddress.zip);

    return 0;
}

在这个例子中，struct Employee结构体包含一个struct Address类型的成员empAddress。初始化emp结构体时，对于嵌套的empAddress结构体成员，同样按照其成员顺序给出初始值。访问嵌套结构体成员时，需要使用多个点运算符，如emp.empAddress.street。

结构体与内存对齐

在C语言中，结构体变量在内存中的存储并不是简单地按照成员变量的声明顺序依次排列，而是会涉及到内存对齐的问题。内存对齐的目的是为了提高CPU访问内存的效率。

1. 内存对齐的基本原则

• 结构体的第一个成员的偏移量（相对于结构体变量的起始地址）为0。
• 其他成员变量的偏移量必须是该成员类型大小的整数倍。如果不满足，编译器会在成员之间填充一些字节，称为“空洞”（padding）。
• 结构体的总大小必须是其最大成员类型大小的整数倍。如果不满足，编译器会在结构体的末尾填充一些字节。

例如，考虑以下结构体：

struct Example1 {
    char a;
    int b;
    short c;
};

假设char类型占1个字节，int类型占4个字节，short类型占2个字节。a的偏移量为0，占用1个字节。b是int类型，其偏移量必须是4的整数倍，因此编译器会在a后面填充3个字节，使得b的偏移量为4，b占用4个字节。c是short类型，其偏移量必须是2的整数倍，此时偏移量为8，满足条件，c占用2个字节。结构体Example1的总大小为1 + 3 + 4 + 2 = 10字节，由于10不是4（最大成员int的大小）的整数倍，编译器会在末尾填充2个字节，最终结构体的大小为12字节。

2. 修改内存对齐方式 在一些情况下，我们可能希望改变默认的内存对齐方式，比如为了节省内存空间。在GCC编译器中，可以使用__attribute__((packed))来指定结构体采用紧凑的内存布局，不进行填充。

struct __attribute__((packed)) Example2 {
    char a;
    int b;
    short c;
};

在这个Example2结构体中，a占用1个字节，b紧跟在a后面，偏移量为1，不进行填充，b占用4个字节，c紧跟在b后面，偏移量为5，占用2个字节，整个结构体的大小为1 + 4 + 2 = 7字节。

不过，使用紧凑内存布局可能会导致一些性能问题，因为CPU访问非对齐内存地址时可能需要更多的指令周期。因此，在选择是否使用紧凑内存布局时，需要综合考虑内存使用和性能要求。

结构体与联合体的区别

联合体（union）也是C语言中的一种用户自定义数据类型，它与结构体有一些相似之处，但也有重要的区别。

1. 内存占用

• 结构体：结构体的所有成员变量都同时存在于内存中，结构体的大小是其所有成员变量大小之和（考虑内存对齐）。例如，前面定义的struct Student结构体，假设char类型占1个字节，int类型占4个字节，float类型占4个字节，考虑内存对齐后，其大小为50 + 4 + 4 = 58字节（假设name数组长度为50）。
• 联合体：联合体的所有成员变量共享同一块内存空间，联合体的大小是其最大成员变量的大小。例如：

union Data {
    int num;
    float f;
    char str[10];
};

假设int类型占4个字节，float类型占4个字节，char类型占1个字节，str数组长度为10，那么union Data的大小为10字节，因为str数组是最大的成员变量。

2. 数据访问

• 结构体：可以同时访问结构体的多个成员变量，每个成员变量都有自己独立的存储空间。
• 联合体：在同一时刻只能访问联合体的一个成员变量，因为所有成员共享内存空间，对一个成员变量的修改会覆盖其他成员变量的值。

#include <stdio.h>

union Data {
    int num;
    float f;
    char str[10];
};

int main() {
    union Data u;
    u.num = 10;
    printf("num: %d\n", u.num);
    // 此时u.f和u.str的值是未定义的，因为它们的内存被u.num覆盖了
    u.f = 3.14f;
    printf("f: %f\n", u.f);
    // 此时u.num和u.str的值是未定义的，因为它们的内存被u.f覆盖了
    return 0;
}

在这个例子中，先给u.num赋值并打印，然后给u.f赋值并打印，每次赋值都会覆盖之前成员变量在内存中的值。

联合体通常用于需要在不同时刻使用不同类型数据的场景，以节省内存空间。但在使用时需要特别注意当前正在使用的是哪个成员变量，避免数据错误。

结构体在实际编程中的应用

1. 表示复杂数据结构 结构体常用于表示现实世界中的复杂对象或数据结构。例如，在一个图形绘制程序中，可以定义一个结构体来表示一个点：

struct Point {
    int x;
    int y;
};

然后可以定义一个结构体来表示一个矩形，矩形可以由两个点（左上角和右下角）来确定：

struct Rectangle {
    struct Point topLeft;
    struct Point bottomRight;
};

这样就可以方便地对矩形进行操作，如计算面积、判断点是否在矩形内等。

2. 链表实现 链表是一种常用的数据结构，在C语言中通常通过结构体和指针来实现。链表的每个节点都是一个结构体，包含数据部分和指向下一个节点的指针。

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

通过这种方式，可以动态地创建、插入、删除链表节点，实现灵活的数据存储和操作。

3. 文件操作中的应用 在文件操作中，结构体可以用于表示文件中的记录。例如，一个学生信息管理系统中，可以将学生信息定义为结构体，然后将结构体数据写入文件或从文件中读取。

#include <stdio.h>

struct Student {
    char name[50];
    int age;
    float score;
};

int main() {
    struct Student stu = {"Tom", 20, 80.0};
    FILE *file = fopen("students.txt", "wb");
    if (file != NULL) {
        fwrite(&stu, sizeof(struct Student), 1, file);
        fclose(file);
    }

    struct Student readStu;
    file = fopen("students.txt", "rb");
    if (file != NULL) {
        fread(&readStu, sizeof(struct Student), 1, file);
        printf("Name: %s, Age: %d, Score: %.2f\n", readStu.name, readStu.age, readStu.score);
        fclose(file);
    }

    return 0;
}

在这个例子中，通过fwrite和fread函数将结构体数据写入文件和从文件中读取，方便地实现了数据的持久化存储。

综上所述，结构体是C语言中非常重要的数据类型，通过合理使用结构体，可以有效地组织和管理复杂的数据，提高程序的可读性和可维护性，在各种应用场景中发挥关键作用。无论是简单的程序还是大型的系统开发，结构体都是不可或缺的一部分。熟练掌握结构体的定义、用法、内存管理以及与其他数据类型和语言特性的结合，对于成为一名优秀的C语言开发者至关重要。在实际编程中，要根据具体的需求和场景，灵活运用结构体，充分发挥其强大的功能。同时，要注意结构体与内存对齐、联合体等相关概念的区别和联系，避免因错误使用而导致程序出现难以调试的问题。通过不断实践和深入理解，能够更好地驾驭结构体，编写出高效、健壮的C语言程序。