C语言中的数据类型（二）--结构体

在之前我们已经探讨了C语言中的自定义数据类型和数组，链接如下：C语言中的数据类型（上）_c语言数据类型-CSDN博客

目录

一、结构体的声明

二、结构体变量的定义和初始化

三、结构体成员的访问

3.1 结构体成员的直接访问

3.2 结构体成员的间接访问

四、结构的特殊声明

五、结构体内存对齐

5.1 对齐规则

5.2 为什么存在内存对齐

5.3 修改默认对齐数

六、结构体传参

七、结构体实现位段

7.1 什么是位段

7.2 位段的内存分配

7.3 位段的跨平台问题

7.4 位段的应用

7.5 位段使用的注意事项

---

接下来我们来探讨C语言中的自定义数据类型结构体。

C语⾔已经提供了内置类型，如：char、short、int、long、float、double等，但是只有这些内置类型还是不够的，假设我想描述学⽣，描述⼀本书，这时单⼀的内置类型是不⾏的。描述⼀个学⽣需要名字、年龄、学号、⾝⾼、体重等；描述⼀本书需要作者、出版社、定价等。C语⾔为了解决这个问题，增加了结构体这种⾃定义的数据类型，让程序员可以⾃⼰创造适合的类型。

结构是⼀些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量，如：

标量、数组、指针，甚⾄是其他结构体。

一、结构体的声明

结构体的声明如下所示：

struct tag

{

        member- list1 ;

        member- list2 ;

         ......

}variable- list ;

例如，描述一个学生：

struct Stu

{

        char name[ 20 ]; // 名字

        int age; // 年龄

        char sex[ 5 ]; // 性别

        char id[ 20 ]; // 学号

}; // 分号不能丢

二、结构体变量的定义和初始化

结构体变量的定义有两种方式：

第一种方式是在声明结构体的时候创建变量，如下所示：

struct Point // 类型声明

{

        int x;

        int y;

}p1; // 声明类型的同时定义变量 p1

struct Stu // 类型声明

{

        char name[ 15 ]; // 名字

        int age; // 年龄

}s1;

第二种方式是使用结构体类型来创建，如下所示：

struct Point p2; //定义结构体变量p2

struct Stu s1；

结构体变量的初始化同样有两种方式：

第一种方式是创建变量的时候按照顺序初始化，如下所示：

struct Point p3 = { 10 , 20 };

struct Stu s1 = { "zhangsan" , 20 };

第二种方式是创建变量的时候用 “ . ” 这个符号来制定变量来初始化，如下所示：

struct Stu s2 = {.age= 20 , .name= "lisi" }; // 指定顺序初始化

 结构体是可以嵌套使用的，如下所示：

struct Node

{

        int data;

        struct Point p ;

        struct Node * next ;

}n1 = { 10 , { 4 , 5 }, NULL }; // 结构体嵌套初始化

struct Node n2 = { 20 , { 5 , 6 }, NULL }; // 结构体嵌套初始化

三、结构体成员的访问

3.1 结构体成员的直接访问

结构体成员的直接访问是通过点操作符（.）访问的。点操作符接受两个操作数。如下所⽰：

# include <stdio.h>

struct Point

{

        int x;

        int y;

}p = { 1 , 2 };

int main ()

{

        printf ( "x: %d y: %d\n" , p.x, p.y);

        return 0 ;

}

使用方式：结构体变量.成员名 

3.2 结构体成员的间接访问

有时候我们得到的不是⼀个结构体变量，⽽是得到了⼀个指向结构体的指针。如下所示：

# include <stdio.h>

struct Point

{

        int x;

        int y;

};

int main ()

{

        struct Point p = { 3 , 4 };

        struct Point *  ptr = &p;

        ptr->x = 10 ;

        ptr->y = 20 ;

        printf ( "x = %d y = %d\n" , ptr->x, ptr->y);

        return 0 ;

}

使用方式：结构体指针->成员名 

四、结构的特殊声明

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

⽐如：

// 匿名结构体类型

struct

{

        int a;

        char b;

        float c;

}x;

struct

{

        int a;

        char b;

        float c;

}a[ 20 ], *p;

上⾯的两个结构在声明的时候省略掉了结构体标签（tag）。

那么问题来了？

// 在上⾯代码的基础上，下⾯的代码合法吗？

p = &x;

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

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

五、结构体内存对齐

我们已经掌握了结构体的基本使⽤了。

现在我们深⼊讨论⼀个问题：计算结构体的⼤⼩。

这也是⼀个特别热⻔的考点： 结构体内存对⻬

5.1 对齐规则

1. 结构体的第⼀个成员对⻬到和结构体变量起始位置偏移量为0的地址处

2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

         对齐数 = 编译器默认的⼀个对齐数 与 该成员变量大小的较小值。

                - VS 中默认的值为 8

                - Linux中 gcc 没有默认对⻬数，对齐数就是成员⾃⾝的大小

3. 结构体总大小为最⼤对齐数（结构体中每个成员变量都有⼀个对其数，所有对齐数中最⼤的）的 整数倍。

4. 如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处，结构 体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍。

让我们来看以下练习：

#include<stdio.h>

//练习1

struct S1
{
    char c1;
    int i;
    char c2;
};
int main() {
    printf("%zd\n", sizeof(struct S1));
    return 0;
}

首先，我们将c1放在偏移量为0的位置。

接下来我们就要考虑变量i放哪里了？由对齐规则2： 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的⼀个对齐数 与 该成员变量大小的较小值。编译器默认的⼀个对齐数为8，int类型变量大小为4字节，取较小值为4.所以i就需要放到偏移量为4的倍数的地方，int类型大小占4个字节，所以4到7这几个空间就被分配给i。1到3这个空间就被浪费掉了

最后我们就需要考虑c2放在哪里。由对齐规则2： 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的⼀个对齐数 与 该成员变量大小的较小值。编译器默认的⼀个对齐数为8，char类型变量大小为1字节，取较小值为1。所以c2就需要放到偏移量为1的倍数的地方，char类型大小占1个字节，所以8这个空间就被分配给c2。

那么这个结构体就占0到8这几个空间吗？接下来我们就需要看对齐规则3： 结构体总大小为最大对齐数（结构体中每个成员变量都有⼀个对其数，所有对齐数中最⼤的）的 整数倍。c1的对齐数为1，i的对齐数为4,c2的对齐数为1.所以最大对齐数为4.故结构体的总大小需要占4的整数倍个字节。9到11这几个自己也需要被分配给这个结构体。

综上所述：这个结构体S1总大小为12个字节。

运行结果如下：正如我们分析的这样

//练习2
struct S2
{
    char c1;
    char c2;
    int i;
};
int main() {
    printf("%zd\n", sizeof(struct S2));
    return 0;
}

首先，我们将c1放在偏移量为0的位置。

接下来我们就要考虑变量c2放哪里了？由对齐规则2： 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的⼀个对齐数 与 该成员变量大小的较小值。编译器默认的⼀个对齐数为8，char类型变量大小为1字节，取较小值为1.所以i就需要放到偏移量为1的倍数的地方，char类型大小占4个字节，所以1这个空间就被分配给c2。

最后我们就需要考虑i放在哪里。由对齐规则2： 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的⼀个对齐数 与 该成员变量大小的较小值。编译器默认的⼀个对齐数为8，int类型变量大小为4字节，取较小值为4。所以i就需要放到偏移量为4的倍数的地方，int类型大小占4个字节，所以4到7这几个空间就被分配给i。2到3这个空间就被浪费掉了。

那么这个结构体就占0到7这几个空间吗？接下来我们就需要看对齐规则3： 结构体总大小为最大对齐数（结构体中每个成员变量都有⼀个对其数，所有对齐数中最⼤的）的 整数倍。c1的对齐数为1，c2的对齐数为1，i的对齐数为,.所以最大对齐数为4.故结构体的总大小需要占4的整数倍个字节。所以这个结构体就占0到7这几个空间。

综上所述：这个结构体S2总大小为8个字节。

运行结果如下：

//练习3
struct S3
{
    double d;
    char c;
    int i;
};
int main() {
    printf("%d\n", sizeof(struct S3));
    return 0;
}

首先，我们将d放在偏移量为0的位置。

接下来我们就要考虑变量c放哪里了？由对齐规则2： 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的⼀个对齐数 与 该成员变量大小的较小值。编译器默认的⼀个对齐数为8，char类型变量大小为1字节，取较小值为1.所以c就需要放到偏移量为1的倍数的地方，char类型大小占1个字节，所以8这个空间就被分配给c。

最后我们就需要考虑i放在哪里。由对齐规则2： 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的⼀个对齐数 与 该成员变量大小的较小值。编译器默认的⼀个对齐数为8，int类型变量大小为4字节，取较小值为4。所以i就需要放到偏移量为4的倍数的地方，int类型大小占4个字节，所以12到15这几个空间就被分配给i。9到11这几个空间就被浪费掉了。

那么这个结构体就占0到15这几个空间吗？接下来我们就需要看对齐规则3： 结构体总大小为最大对齐数（结构体中每个成员变量都有⼀个对其数，所有对齐数中最⼤的）的 整数倍。d的对齐数为8，c的对齐数为1,i的对齐数为4.所以最大对齐数为4.故结构体的总大小需要占8的整数倍个字节。所以这个结构体就占0到15这几个空间 。

综上所述：这个结构体S3总大小为16个字节。

运行结果如下：正如我们分析的这样

//练习4-结构体嵌套问题
struct S3
{
    double d;
    char c;
    int i;
};
struct S4
{
    char c1;
    struct S3 s3;
    double d;
};
int main() {
    printf("%zd\n", sizeof(struct S4));
    return 0;
}

首先，我们将c1放在偏移量为0的位置。

接下来我们就需要考虑结构体S3放哪里了？是放在偏移量为1的位置处吗？我们由对齐规则4的前半部分： 如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对齐数的整数倍处。d的对齐数为8，c的对齐数为1，i的对齐数为4，最大对齐数为8，所以S3就需要放到偏移量为8的整数倍处。

我们将d放在偏移量为8的位置。

我们就要考虑变量c放哪里了？由对齐规则2： 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的⼀个对齐数 与 该成员变量大小的较小值。编译器默认的⼀个对齐数为8，char类型变量大小为1字节，取较小值为1.所以c就需要放到偏移量为1的倍数的地方，char类型大小占1个字节，所以16这个空间就被分配给c。

然后我们就需要考虑i放在哪里。由对齐规则2： 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的⼀个对齐数 与 该成员变量大小的较小值。编译器默认的⼀个对齐数为8，int类型变量大小为4字节，取较小值为4。所以i就需要放到偏移量为4的倍数的地方，int类型大小占4个字节，所以20到23这几个空间就被分配给i。17到19这几个空间就被浪费掉了。

最后我们就需要考虑d放在哪里。由对齐规则2： 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的⼀个对齐数 与 该成员变量大小的较小值。编译器默认的⼀个对齐数为8，double类型变量大小为8字节，取较小值为8。所以d就需要放到偏移量为8的倍数的地方，double类型大小占8个字节，所以24到31这几个空间就被分配给d。

那么这个结构体就占0到31这几个空间吗？接下来我们就需要看对齐规则3： 结构体总大小为最大对齐数（结构体中每个成员变量都有⼀个对其数，所有对齐数中最⼤的）的 整数倍。以及对齐规则4的后半部分：结构体的整体大小就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍。c1的对齐数为1，S3中的最大对齐数为8，d的对齐数为8，所以最大对齐数为8，故结构体的总大小需要占8的整数倍个字节.所以这个结构体就占0到31的空间。

综上所述：这个结构体S1总大小为31个字节。

运行结果如下：

5.2 为什么存在内存对齐

大部分的参考资料都是这样说的：

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

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

2. 性能原因：

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

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

那在设计结构体的时候，我们既要满⾜对⻬，⼜要节省空间，如何做到：

让占⽤空间⼩的成员尽量集中在⼀起，如下所示：

// 例如：

struct S1

{

char c1; 5 int i;

char c2;

};

struct S2

{

char c1;

char c2;

int i;

};

S1 和 S2 类型的成员⼀模⼀样，但是 S1 和 S2 所占空间的⼤⼩有了⼀些区别。

5.3 修改默认对齐数

#pragma 这个预处理指令，可以改变编译器的默认对齐数。如下所示：

# include <stdio.h>

# pragma pack(1) // 设置默认对齐数为 1

struct S

{

        char c1;

        int i;

        char c2;

};

int main ()

{

        //输出的结果是什么？

        printf ( "%d\n" , sizeof ( struct S));

        return 0 ;

}

结构体在对齐方式不合适的时候，我们可以⾃⼰更改默认对齐数。

六、结构体传参

让我们来看以下代码：

struct S

{

        int data[ 1000 ];

        int num;

};

struct S s = {{ 1 , 2 , 3 , 4 }, 1000 };

// 结构体传参

void print1 ( struct S s)

{

        printf ( "%d\n" , s.num);

}

// 结构体地址传参

void print2 ( struct S* ps)

{

        printf ( "%d\n" , ps->num);

}

int main ()

{

        print1(s); // 传结构体

        print2(&s); // 传地址

        return 0 ;

}

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

答案是：⾸选print2函数。

为什么呢？

原因：

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

结论：

结构体传参的时候，传结构体的地址要更好。

七、结构体实现位段

结构体讲完就得讲讲结构体实现位段的能力。

7.1 什么是位段

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

• 位段的成员必须是 int、unsigned int 或signed int ，在C99中位段成员的类型也可以选择其他类型。
• 位段的成员名后边有⼀个冒号和⼀个数字。

后面的数字表示的是这个变量占几个比特位。

如下所示：

struct A

{

        int _a: 2 ;

        int _b: 5 ;

        int _c: 10 ;

        int _d: 30 ;

};

A就是⼀个位段类型。_a这个变量占2个比特位，_b个变量占5个比特位,_c个变量占10个比特位,__d个变量占30个比特位。位段是专门用来节省内存的。

那位段A所占内存的⼤⼩是多少？我们来看下面位段的内存分配。

7.2 位段的内存分配

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 ;

// 空间是如何开辟的？

7.3 位段的跨平台问题

1.  int 位段被当成有符号数还是⽆符号数是不确定的。
2.  位段中最⼤位的数⽬不能确定。（16位机器最⼤16，32位机器最⼤32，写成27，在16位机器会出问题）。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当⼀个结构包含两个位段，第⼆个位段成员⽐较⼤，⽆法容纳于第⼀个位段剩余的位时，是舍弃剩余的位还是利⽤，这是不确定的。

总结：

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

7.4 位段的应用

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

7.5 位段使用的注意事项

位段的⼏个成员共有同⼀个字节，这样有些成员的起始位置并不是某个字节的起始位置，那么这些位置处是没有地址的。内存中每个字节分配⼀个地址，⼀个字节内部的bit位是没有地址的。

所以不能对位段的成员使⽤&操作符，这样就不能使⽤scanf直接给位段的成员输⼊值，只能是先输⼊放在⼀个变量中，然后赋值给位段的成员。如下所示：

struct A

{

        int _a : 2 ;

        int _b : 5 ;

        int _c : 10 ;

        int _d : 30 ;

};

int main ()

{

        struct A sa = { 0 };

        scanf ( "%d" , &sa._b); // 这是错误的

        //正确的⽰范

        int b = 0 ;

        scanf ( "%d" , &b);

        sa._b = b;

        return 0 ;

}