编辑“︁C 语言结构体初始化”︁（章节）

= C语言结构体初始化 =

== 介绍 ==
在C语言中，'''结构体'''（struct）是一种用户自定义的数据类型，允许将不同类型的数据组合成一个单一的复合类型。结构体初始化是指为结构体变量的成员赋予初始值的过程。正确的初始化可以确保程序开始时结构体成员具有预期的值，避免未定义行为。

结构体初始化可以通过多种方式完成，包括：
* 声明时初始化
* 使用初始化列表
* 指定初始化（C99标准引入）
* 运行时赋值初始化

== 基本初始化方法 ==

=== 声明时初始化 ===
最简单的初始化方式是在声明结构体变量时直接提供初始值。

<syntaxhighlight lang="c">
#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main() {
    // 声明时初始化
    struct Point p1 = {10, 20};
    
    printf("p1.x = %d, p1.y = %d\n", p1.x, p1.y);
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
p1.x = 10, p1.y = 20
</pre>

=== 使用初始化列表 ===
初始化列表可以在声明后使用，但通常更常见于数组初始化。

<syntaxhighlight lang="c">
struct Point p2;
// 错误示例：初始化列表不能用于声明后的赋值
// p2 = {30, 40}; // 编译错误

// 正确方式：声明时使用或使用复合字面量(C99)
p2 = (struct Point){30, 40}; // C99复合字面量
</syntaxhighlight>

== 指定初始化（C99特性） ==
C99标准引入了'''指定初始化器'''，允许通过成员名称初始化特定成员，其他成员自动初始化为0。

<syntaxhighlight lang="c">
struct Student {
    int id;
    char name[50];
    float gpa;
};

int main() {
    // 指定初始化
    struct Student s1 = {
        .gpa = 3.8,
        .name = "Alice",
        .id = 1001
    };
    
    // 未指定的成员初始化为0
    struct Student s2 = {
        .id = 1002
    };
    
    printf("s1: ID=%d, Name=%s, GPA=%.1f\n", s1.id, s1.name, s1.gpa);
    printf("s2: ID=%d, Name=%s, GPA=%.1f\n", s2.id, s2.name, s2.gpa);
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
s1: ID=1001, Name=Alice, GPA=3.8
s2: ID=1002, Name=, GPA=0.0
</pre>

== 嵌套结构体初始化 ==
当结构体包含其他结构体作为成员时，初始化可以通过嵌套初始化列表完成。

<syntaxhighlight lang="c">
struct Address {
    char street[50];
    char city[30];
};

struct Person {
    char name[50];
    int age;
    struct Address addr;
};

int main() {
    // 嵌套初始化
    struct Person p = {
        "Bob Smith",
        30,
        {"123 Main St", "Springfield"}
    };
    
    printf("Name: %s\nAge: %d\nAddress: %s, %s\n", 
           p.name, p.age, p.addr.street, p.addr.city);
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
Name: Bob Smith
Age: 30
Address: 123 Main St, Springfield
</pre>

== 数组结构体初始化 ==
结构体数组可以通过嵌套初始化列表进行初始化。

<syntaxhighlight lang="c">
struct Book {
    char title[100];
    char author[50];
    int year;
};

int main() {
    // 结构体数组初始化
    struct Book library[3] = {
        {"The C Programming Language", "K&R", 1978},
        {"Effective C", "Robert Seacord", 2020},
        {"C Primer Plus", "Stephen Prata", 2013}
    };
    
    for(int i = 0; i < 3; i++) {
        printf("Book %d: %s by %s (%d)\n", 
               i+1, library[i].title, library[i].author, library[i].year);
    }
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
Book 1: The C Programming Language by K&R (1978)
Book 2: Effective C by Robert Seacord (2020)
Book 3: C Primer Plus by Stephen Prata (2013)
</pre>

== 运行时初始化 ==
结构体也可以在运行时通过逐个成员赋值来初始化。

<syntaxhighlight lang="c">
#include <string.h>

struct Product {
    int id;
    char name[50];
    float price;
};

int main() {
    struct Product item;
    
    // 运行时初始化
    item.id = 101;
    strcpy(item.name, "Laptop");
    item.price = 999.99;
    
    printf("Product: %d - %s ($%.2f)\n", item.id, item.name, item.price);
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
Product: 101 - Laptop ($999.99)
</pre>

== 零初始化 ==
可以通过以下方式将结构体所有成员初始化为0：

<syntaxhighlight lang="c">
struct Data {
    int a;
    double b;
    char c[10];
};

int main() {
    // 方法1：使用空初始化列表
    struct Data d1 = {0};
    
    // 方法2：使用memset (需要#include <string.h>)
    struct Data d2;
    memset(&d2, 0, sizeof(d2));
    
    printf("d1: %d, %f, %s\n", d1.a, d1.b, d1.c);
    printf("d2: %d, %f, %s\n", d2.a, d2.b, d2.c);
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
d1: 0, 0.000000, 
d2: 0, 0.000000, 
</pre>

== 实际应用案例 ==
考虑一个学生成绩管理系统，使用结构体存储学生信息：

<syntaxhighlight lang="c">
#include <stdio.h>
#include <string.h>

#define MAX_STUDENTS 50

struct Student {
    int id;
    char name[50];
    float scores[5]; // 5门课程成绩
    float average;
};

void calculateAverage(struct Student *s) {
    float sum = 0;
    for(int i = 0; i < 5; i++) {
        sum += s->scores[i];
    }
    s->average = sum / 5;
}

int main() {
    struct Student class[MAX_STUDENTS] = {
        {1001, "Alice", {85, 90, 78, 92, 88}},
        {1002, "Bob", {76, 82, 90, 85, 79}},
        {1003, "Charlie", {92, 88, 76, 95, 83}}
    };
    
    // 计算平均分
    for(int i = 0; i < 3; i++) {
        calculateAverage(&class[i]);
    }
    
    // 打印学生信息
    for(int i = 0; i < 3; i++) {
        printf("ID: %d\nName: %s\nScores: ", class[i].id, class[i].name);
        for(int j = 0; j < 5; j++) {
            printf("%.1f ", class[i].scores[j]);
        }
        printf("\nAverage: %.2f\n\n", class[i].average);
    }
    
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
ID: 1001
Name: Alice
Scores: 85.0 90.0 78.0 92.0 88.0 
Average: 86.60

ID: 1002
Name: Bob
Scores: 76.0 82.0 90.0 85.0 79.0 
Average: 82.40

ID: 1003
Name: Charlie
Scores: 92.0 88.0 76.0 95.0 83.0 
Average: 86.80
</pre>

== 初始化顺序与注意事项 ==
1. '''初始化顺序'''：在传统初始化列表中，成员初始化的顺序必须与结构体定义中的声明顺序一致。指定初始化器则不受此限制。
2. '''部分初始化'''：如果初始化列表中的值少于成员数量，剩余成员将被初始化为0。
3. '''数组和字符串'''：字符数组可以使用字符串字面量初始化，但需要注意数组大小要足够容纳字符串加上终止符'\0'。
4. '''兼容性'''：指定初始化器是C99特性，在旧编译器上可能不支持。

== 高级话题：复合字面量 ==
C99引入了复合字面量，允许创建匿名结构体并初始化：

<syntaxhighlight lang="c">
struct Rectangle {
    int width;
    int height;
};

void printArea(struct Rectangle r) {
    printf("Area: %d\n", r.width * r.height);
}

int main() {
    // 使用复合字面量
    printArea((struct Rectangle){10, 20});
    
    // 也可以用于赋值
    struct Rectangle r = (struct Rectangle){5, 8};
    printArea(r);
    
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
Area: 200
Area: 40
</pre>

== 总结 ==
C语言提供了多种结构体初始化方法，从简单的初始化列表到C99的指定初始化器和复合字面量。选择哪种方法取决于：
* 代码需要支持的C标准版本
* 初始化数据的复杂程度
* 是否需要部分初始化或指定特定成员
* 代码可读性要求

正确初始化结构体可以避免许多常见的编程错误，特别是在处理复杂数据结构时。

[[Category:编程语言]]
[[Category:C]]
[[Category:C 语言结构体与联合]]