结构体类型

原创于 2025-12-07 21:15:25 发布 · 789 阅读

CC 4.0 BY-SA版权

文章标签：

1.什么是结构体类型

在C语言中，变量类型主要分为内置类型（如int、char、float、double）和自定义类型。当需要存储复杂数据时，比如包含姓名、性别、年龄和成绩的学生信息，或者包含书名、作者和出版商的图书信息，仅靠内置类型就无法满足需求。这时就需要使用自定义类型来创建变量存储数据，而C语言的结构体（struct）正是实现这一需求的理想选择。

2.结构体类型的声明

结构体类型的声明

struct tag {
    member-list;
} variable-list;

参数说明：

tag：结构体标识符，用于定义结构体类型名称
member-list：结构体成员变量列表（字段声明）
variable-list：基于该结构体类型声明的变量列表（可省略，后续再声明变量）

举例：创建一个book结构体

struct book
{
	char title[50];
	char auther[30];
	float value;
};

注意：结构声明描述了一个结构的组织布局，例如以上声明，该声明描述了一个由两个字符数组和一个float类型变量组成的结构，该声明并未创建实际的数据对象，只描述了该对象由什么组成。（有时，我们把结构声明称为模板，因为它勾勒出结构是如何储存数据的）

结构体变量的创建和初始化

创建

	struct book b;

初始化

	struct book b = { "c primer plus","Stephen Prata",53.1 }; //按照顺序初始化
	struct book b1 = { .value = 53.1,.auther = "Stephen Prata" ,.title = "c primer plus" };//按照成员初始化

结构体特殊声明

在声明结构的时候，可以不完全的声明。

struct
{
 int a;
 char b;
 float c;
}x;

struct
{
 int a;
 char b;
 float c;
}a[20], *p;

上⾯的两个结构在声明的时候省略掉了结构体标签（tag）。那么问题来了？

//在上⾯代码的基础上，下⾯的代码合法吗？
p = &x;

警告：

编译器会把上⾯的两个声明当成完全不同的两个类型，所以是⾮法的。

匿名的结构体类型，如果没有对结构体类型重命名的话，基本上只能使⽤⼀次。

结构体自引用

如：创建一个链表

struct Node
{
	int data;  //数据域
	struct Node* next;  //指针域
};

结构体自引用时，如果用匿名结构体，也会造成问题，请看以下代码

typedef struct
{
 int data;
 Node* next;  //这里会出现问题
}Node;

Node是对前⾯的匿名结构体类型的重命名产⽣的，但是在匿名结构体内部提前使⽤Node类型来创建成员变量，这是不⾏的。

3.结构体成员的使用

结构体类似于一个"复合数组"，其中的元素可以是不同类型的数据（如char、float或int数组等），且每个成员都能通过下标方式单独访问。要访问结构体成员，需要使用结构成员运算符"."。

示例代码：

#include<stdio.h>

struct book {
    char title[50];
    char author[30];
    float value;
};

int main() {
    // 顺序初始化
    struct book b = {"C Primer Plus", "Stephen Prata", 53.1};
    
    // 指定成员初始化
    struct book b1 = {
        .value = 53.1,
        .author = "Stephen Prata",
        .title = "C Primer Plus"
    };
    
    printf("作者: %s\n", b.author);
    printf("书名: %s\n", b.title);
    printf("价格: %.1f\n", b.value);

    return 0;
}

也可以通过结构成员运算符手动输入值：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

struct book {
    char title[50];
    char author[30];
    float value;
};

int main() {
    struct book b = {0};
    
    printf("请输入书名: ");
    fgets(b.title, sizeof(b.title), stdin);
    b.title[strcspn(b.title, "\n")] = '\0';
    
    printf("请输入作者: ");
    fgets(b.author, sizeof(b.author), stdin);
    b.author[strcspn(b.author, "\n")] = '\0';
    
    printf("请输入价格: ");
    scanf("%f", &b.value);
    
    printf("\n图书信息:\n");
    printf("书名: %s\n", b.title);
    printf("作者: %s\n", b.author);
    printf("价格: %.2f\n", b.value);

    return 0;
}

本质上，结构体成员如.title、.author、.value相当于该结构体的"下标"。虽然book是结构体类型，但book.value就是一个普通的float变量，可以像使用其他float变量一样使用它。

3.结构体内存对齐

既然结构体中能包含各种类型的变量，那么编译器如何为其分配内存，如何计算结构体的大小？此时就有了内存对齐这一概念。

对齐规则

1. 成员对齐规则

每个成员的偏移地址必须是 其类型大小 和 当前对齐值 两者中较小者的整数倍
默认对齐值在x64下通常是8字节，x86下通常是4字节

2. 结构体整体对齐规则

结构体总大小必须是 最大成员大小 和 对齐值 两者中较小者的整数倍

例子

1.基本类型对齐

struct Example1 {
    char a;      // 1字节
    int b;       // 4字节，偏移必须是4的倍数
    double c;    // 8字节，偏移必须是8的倍数
};
// 大小：16字节（1 + 3填充 + 4 + 8）

2.嵌套结构对齐

#include <stdio.h>


struct Inner {
    char a;      // 1字节
    int b;       // 4字节
}; // 大小：8字节


struct Outer {
    char x;                     // 1字节，偏移1
    struct Inner inner;         // 8字节，需要4字节对齐（int的最大对齐）
    double y;                   // 8字节
};

int main() {
    struct Outer o;
    printf("Size of struct Outer: %zu bytes\n", sizeof(o));
    printf("Size of struct Inner: %zu bytes\n", sizeof(struct Inner));

    return 0;
}

3.#pragma pack 指令

#pragma pack 指令可以修改编译器默认对齐数

#include <stdio.h>
#pragma pack(push, 1)  // 设置为1字节对齐

struct TightPacked {
    char a;    // 1字节
    int b;     // 4字节，现在可以直接跟在后面
    double c;  // 8字节
}; // 大小：13字节（1 + 4 + 8）
#pragma pack(pop)      // 恢复之前的对齐方式
int main()
{
    struct TightPacked to = { 0 };
    printf("%zu", sizeof(to));
    return 0;
}

为什么内存对齐

1. 平台原因 (移植原因)：

不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。

2. 性能原因：

数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于，为了访问未对⻬的内存，处理器需要作两次内存访问；⽽对⻬的内存访问仅需要⼀次访问。假设⼀个处理器总是从内存中取8个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对⻬成8的倍数，那么就可以⽤⼀个内存操作来读或者写值了。否则，我们可能需要执⾏两次内存访问，因为对象可能被分放在两个8字节内存块中。

总体来说：结构体的内存对⻬是拿空间来换取时间的做法。

4.结构体传参

结构体作为参数传递时，既可以直接传递结构体本身，也可以传递指向该结构体的指针。

#include <stdio.h>
struct S
{
    int arr[100];
    int num;
};
void print1(struct S s)  //传结构体
{
    printf("%d", s.num);
}
void print2(struct S* ps)  //传指针
{
    printf("%d", ps->num);
}
int main()
{
    struct S s = { {1,2,3,4,5},1000 };
    print1(s);
    print2(&s);

    return 0;
}

上⾯的 print1 和 print2 函数哪个好些？

答案是：⾸选print2函数。

原因：函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。如果传递⼀个结构体对象的时候，结构体过⼤，参数压栈的的系统开销⽐较⼤，所以会导致性能的下降。

结论：结构体传参的时候，要传结构体的地址。

5.结构体实现位段

基于结构体的功能，我们可以扩展出位段这个概念，那么，什么是位段？位段怎么声明？

位段的声明和结构是类似的，有两个不同：

1. 位段的成员必须是 int、unsigned int 或signed int ，在C99中位段成员的类型也可以

选择其他类型。

2. 位段的成员名后边有⼀个冒号和⼀个数字。

我们来声明一个位段：

struct A
{
    int a : 2;
    int b : 5;
    int c : 10;
    int d : 30;
};

那么，位段的大小怎么计算，编译器怎么为他分配内存空间？

位段的内存分配

1. 位段的成员可以是 int unsigned int signed int 或者是 char 等类型

2. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的⽅式来开辟的。

3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使⽤位段。

举一个例子：

struct S
{
 char a:3;
 char b:4;
 char c:5;
 char d:4;
};
struct S s = {0};
s.a = 10;
s.b = 12;
s.c = 3;
s.d = 4;
//空间是如何开辟的？

位段的跨平台问题

1. int 位段被当成有符号数还是⽆符号数是不确定的。

2. 位段中最⼤位的数⽬不能确定。（16位机器最⼤16，32位机器最⼤32，写成27，在16位机器会

出问题。

3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。

4. 当⼀个结构包含两个位段，第⼆个位段成员⽐较⼤，⽆法容纳于第⼀个位段剩余的位时，是舍弃

剩余的位还是利⽤，这是不确定的。

总结：

跟结构体相比，位段可以达到同样的效果，并且可以很好的节省空间，但是有跨平台的问题存在。

位段的应用

下图是⽹络协议中，IP数据报的格式，我们可以看到其中很多的属性只需要⼏个bit位就能描述，这⾥使⽤位段，能够实现想要的效果，也节省了空间，这样⽹络传输的数据报⼤⼩也会较⼩⼀些，对⽹络的畅通是有帮助的。

位段使用的注意事项

位段的⼏个成员共有同⼀个字节，这样有些成员的起始位置并不是某个字节的起始位置，那么这些位置处是没有地址的。内存中每个字节分配⼀个地址，⼀个字节内部的bit位是没有地址的。所以不能对位段的成员使⽤&操作符，这样就不能使⽤scanf直接给位段的成员输⼊值，只能是先输⼊放在⼀个变量中，然后赋值给位段的成员。

#include <stdio.h>
struct A
{
    int a : 2;
    int b : 5;
    int c : 10;
    int d : 30;
};
int main()
{
    struct A a = { 0 };
    //scanf("%d", &a.d);  这样是错误的，不允许采用位域的地址
    int n = 3;   //这样是正确的示范，可以先放在变量中
    a.d = n;
    return 0;
}