C/C++结构体详解：从基础概念到高级应用-代码聚汇网

C/C++结构体详解：从基础概念到高级应用

陈易铭·2026-08-10·阅读 23 GEO检测（免费）

结构体C语言C++

|难度：普通|阅读约 16 分钟

1. 结构体基础概念解析

结构体（struct）是C/C++等编程语言中用于组织相关数据的复合数据类型。它允许我们将不同类型的数据项组合成一个逻辑单元，这在处理复杂数据时尤为有用。举个例子，如果我们想表示一个学生的信息，可以这样定义：

c复制struct Student {
    char name[50];
    int age;
    float gpa;
};

这个结构体包含了学生的姓名、年龄和GPA三个字段。与数组不同，结构体的成员可以是不同类型的数据，这为数据组织提供了极大的灵活性。

结构体在内存中的存储方式通常是连续的，但可能会因为内存对齐（alignment）而存在填充字节。例如，在32位系统上，编译器可能会在char数组后插入3个字节的填充，以保证后续的int类型成员在4字节边界对齐。理解这一点对优化内存使用和避免跨平台兼容性问题很重要。

注意：结构体定义本身不分配内存，只有在声明结构体变量时才会实际占用内存空间。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 结构体的声明与初始化方法

2.1 基本声明方式

结构体有多种声明方式，每种适用于不同场景。最基础的是先定义结构体类型，再声明变量：

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

struct Point p1;  // 声明一个Point结构体变量

也可以定义结构体类型的同时声明变量：

c复制struct Point {
    int x;
    int y;
} p1, p2;  // 同时声明两个变量

对于频繁使用的结构体，常用typedef创建类型别名：

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

Point p1;  // 现在可以像基本类型一样使用

2.2 初始化技巧

结构体初始化有多种方式，现代C标准（C99及以上）支持更灵活的初始化：

c复制// 传统顺序初始化
Point p1 = {10, 20};

// C99指定的成员初始化（顺序无关）
Point p2 = {.y = 20, .x = 10};

// 部分初始化，未指定的成员自动初始化为0
Point p3 = {.x = 5};

对于包含数组成员的结构体，初始化时可以这样：

c复制struct Student {
    char name[20];
    int age;
};

struct Student s1 = {"张三", 20};

提示：使用指定的成员初始化（.member = value）可以提高代码可读性，特别是在结构体有很多成员时。

3. 结构体的高级用法

3.1 结构体嵌套

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

c复制typedef struct {
    int hour;
    int minute;
    int second;
} Time;

typedef struct {
    int year;
    int month;
    int day;
    Time time;
} DateTime;

访问嵌套结构体成员使用多个点操作符：

c复制DateTime dt = {2023, 7, 15, {14, 30, 0}};
printf("Hour: %d\n", dt.time.hour);

3.2 结构体与指针

结构体指针是访问结构体的强大工具，特别是在动态内存分配和函数参数传递时：

c复制Point p = {10, 20};
Point *ptr = &p;

// 通过指针访问成员
printf("%d\n", (*ptr).x);  // 传统方式
printf("%d\n", ptr->x);    // 更简洁的箭头表示法

动态分配结构体内存：

c复制Point *p = malloc(sizeof(Point));
if (p != NULL) {
    p->x = 10;
    p->y = 20;
    // 使用...
    free(p);  // 记得释放
}

3.3 结构体与函数

结构体可以作为函数参数和返回值。传值方式会复制整个结构体，对于大型结构体可能影响性能：

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

更高效的方式是传递指针：

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

C语言中结构体可以作为函数返回值（C++中更常用）：

c复制Point createPoint(int x, int y) {
    Point p = {x, y};
    return p;
}

4. 结构体的实际应用案例

4.1 链表实现

结构体非常适合实现链表等数据结构：

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

// 创建链表
Node *head = NULL;

// 添加节点
void addNode(Node **head, int value) {
    Node *newNode = malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = *head;
    *head = newNode;
}

4.2 文件记录处理

结构体可以方便地处理二进制文件记录：

c复制struct Record {
    int id;
    char name[50];
    float balance;
};

// 写入记录
struct Record r = {1, "Alice", 100.50};
FILE *fp = fopen("data.bin", "wb");
fwrite(&r, sizeof(struct Record), 1, fp);
fclose(fp);

// 读取记录
struct Record r2;
fp = fopen("data.bin", "rb");
fread(&r2, sizeof(struct Record), 1, fp);
fclose(fp);

4.3 图形编程中的应用

在图形编程中，结构体常用于表示几何图形：

c复制typedef struct {
    float x, y;
} Vector2;

typedef struct {
    Vector2 position;
    Vector2 size;
    Color color;
} Rectangle;

void drawRectangle(Rectangle rect) {
    // 绘制逻辑...
}

5. 结构体使用中的常见问题与解决方案

5.1 内存对齐问题

结构体成员的内存对齐可能导致意外的大小：

c复制struct Example1 {
    char a;    // 1字节
    int b;     // 4字节
    char c;    // 1字节
};  // 可能占用12字节（因为有填充）

struct Example2 {
    char a;
    char c;
    int b;
};  // 可能占用8字节

解决方案：

手动重排成员（将相同类型或小类型放在一起）
使用编译器指令控制对齐（如#pragma pack）
明确使用alignas说明符（C11）

5.2 深浅拷贝问题

结构体赋值是浅拷贝，可能引发指针成员的问题：

c复制struct String {
    char *data;
    int length;
};

struct String s1;
s1.data = malloc(100);
strcpy(s1.data, "Hello");
s1.length = 5;

struct String s2 = s1;  // 浅拷贝，s2.data指向同一内存

// 正确的深拷贝方式
struct String deepCopy(const struct String *src) {
    struct String dest;
    dest.length = src->length;
    dest.data = malloc(src->length + 1);
    strcpy(dest.data, src->data);
    return dest;
}

5.3 柔性数组成员

C99引入的柔性数组成员（flexible array member）技巧：

c复制struct DynamicArray {
    size_t length;
    int data[];  // 柔性数组成员，必须是最后一个成员
};

// 使用方式
size_t length = 10;
struct DynamicArray *arr = malloc(sizeof(struct DynamicArray) + length * sizeof(int));
arr->length = length;
for (size_t i = 0; i < length; i++) {
    arr->data[i] = i * 2;
}

6. 结构体在不同语言中的变体

6.1 C++中的结构体

C++中结构体和类几乎相同，主要区别是默认访问权限：

cpp复制struct Point {  // 默认public
    int x, y;
    void print() { cout << x << ", " << y << endl; }
};

class Point2 {  // 默认private
    int x, y;
public:
    void print() { cout << x << ", " << y << endl; }
};

6.2 Go语言中的结构体

Go语言的结构体更接近C，但有方法支持：

go复制type Point struct {
    X, Y int
}

func (p Point) Distance() float64 {
    return math.Sqrt(float64(p.X*p.X + p.Y*p.Y))
}

6.3 Rust中的结构体

Rust的结构体更强大，支持关联函数和模式匹配：

rust复制struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn new(x: i32, y: i32) -> Self {
        Point { x, y }
    }
    
    fn distance(&self) -> f64 {
        ((self.x.pow(2) + self.y.pow(2)) as f64).sqrt()
    }
}

7. 结构体设计的最佳实践

7.1 保持结构体小巧

理想情况下，结构体应该：

只包含逻辑上相关的数据
大小适中（通常不超过几百字节）
避免过度嵌套

7.2 良好的命名规范

使用描述性名称（如CustomerOrder而非Data）
遵循项目命名约定（如PascalCase或snake_case）
成员名应明确表示用途

7.3 文档化结构体

为重要结构体添加注释：

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

7.4 考虑内存布局

对于性能关键代码：

将常用成员放在前面
将经常一起访问的成员放在相邻位置
考虑缓存行大小（通常64字节）

8. 结构体与其他数据结构的比较

8.1 结构体 vs 类

结构体通常用于被动数据聚合
类更适合有复杂行为的对象
许多语言中结构体是值类型，类是引用类型

8.2 结构体 vs 联合体(union)

结构体：所有成员同时存在
联合体：所有成员共享内存，同一时间只有一个有效

c复制union Variant {
    int i;
    float f;
    char str[20];
};  // 大小由最大成员决定

8.3 结构体 vs 数组

数组：同类型元素的集合，通过索引访问
结构体：不同类型元素的组合，通过名称访问

9. 现代C/C++中的结构体增强

9.1 C++20中的结构化绑定

cpp复制struct Point { int x; int y; };

Point p{1, 2};
auto [x, y] = p;  // x=1, y=2

9.2 C++17中的内联成员初始化

cpp复制struct Point {
    int x = 0;
    int y = 0;
};

9.3 C11中的匿名结构体

c复制struct {
    int x;
    int y;
} point;  // 直接创建实例

10. 性能优化技巧

10.1 按值 vs 按引用传递

小型结构体（<= 2-3个指针大小）：按值传递可能更高效
大型结构体：始终使用const引用（C++）或指针（C）

10.2 热/冷数据分离

将频繁访问的"热"数据和不常访问的"冷"数据分开：

c复制struct Player {
    // 热数据
    Vec2 position;
    float health;
    
    // 冷数据
    char biography[500];
    int achievementCount;
};

10.3 结构体打包

在内存受限环境中，可以手动优化结构体：

c复制#pragma pack(push, 1)
struct PackedData {
    uint8_t flag;
    uint32_t value;
    uint16_t id;
};  // 确保紧密打包
#pragma pack(pop)

在实际项目中，我发现结构体的设计往往反映了领域模型的质量。好的结构体设计应该让数据关系一目了然，同时兼顾性能需求。对于复杂系统，建议先设计关键结构体，再围绕它们构建其他组件。