c语言结构体进阶学习——程序小白的c语言学习

原创已于 2025-08-11 12:59:16 修改 · 1.1k 阅读

58 ·

CC 4.0 BY-SA版权

文章标签：

#c语言 #学习 #开发语言

于 2025-08-11 08:00:00 首次发布

自勉专栏收录该内容

4 篇文章

订阅专栏

前几天复习了下c语言结构体的知识，以此文章作为复习资料，愿与诸君共勉。

2.2 使用typedef时结构体的自引用

一：什么是结构体

1. 结构体

1.1 结构体的需求

c语言给了我们许多种内置的类型，如：char、short、int、long、float、double等，但是只有这些内置类型还是不够的，假设我想描述学⽣，描述⼀本书，这时单⼀的内置类型是不⾏的。

描述⼀个学⽣需要名字、年龄、学号、⾝⾼、体重等；

描述⼀本书需要作者、出版社、定价等。C语⾔为了解决这个问题，增加了结构体这种⾃定义的数据类型，让程序员可以⾃⼰创造适合的类型。

结构是⼀些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量，如：标量、数组、指针，甚⾄是其他结构体。

1.2 结构体的声明

原型代码如下

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

首先要先声明是结构体 struct，

Tag 是你创建的类型的总名字，就像 int，float 等

memberlist 写入你想要的各种类型，可以是别的结构体，可以是c语言给的类型，后面还有位段的概念，等到后面我再予以解释

variable-list 顾名思义，是你用你自己创建的类型所创建的类型的名字，可以省略，这里方便你直接给名字，关于这一项，后面一些特殊结构体有运用

描述⼀个学⽣：

struct Stu
 {
 char name[20];//名字
 
int age;//年龄
 
char sex[5];//性别
 
char id[20];//学号
 
}; //分号不能丢

再给一些嵌套初始化的例子

 struct Node
 {
 int data;
 struct Point p;
 struct Node* next;  
}n1 = {10, {4,5}, NULL};            //结构体嵌套初始化
 
struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

这里注意最后一行，嵌套结构体的初始化方法

2.结构成员访问操作符

2.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;
 }

如图，最终代码分别显示了结构体的两个变量，而不是直接全部表示出来

使⽤⽅式：结构体变量.成员名（注意 . ）

2.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;
 }

遇到结构体的地址时，想要直接从其地址访问数据，就需要 “ -> " 这一操作符

比如图中的 ptr -> x 就相当于

ptr -> x = 10  ==  (*ptr).x = 10

使⽤⽅式：结构体指针->成员名

2.3 综合运用 = v =

#include <stdio.h>
#include <string.h>
struct Stu
 {
     char name[15];//名字
     int age;     //年龄  
};
void print_stu(struct Stu s)
 {
     printf("%s %d\n", s.name, s.age);
 }
void set_stu(struct Stu* ps)
 {
     strcpy(ps->name, "李四");
     ps->age = 28;
 }
int main()
 {
     struct Stu s = { "张三", 20 };
     print_stu(s);
     set_stu(&s);
     print_stu(s);
     return 0;
 }

3.结构体变量初始化

结构体的初始化有两种顺序，

1.按照结构体成员的顺序初始化

2.按照指定的顺序初始化

下面将用代码说明

struct Stu
 {
    char name[20];//名字
 
    int age;//年龄
 
    char sex[5];//性别
 
    char id[20];//学号
 
};
 int main()
 {
 //按照结构体成员的顺序初始化
 
     struct Stu s = { "张三", 20, "男", "20230818001" };
     printf("name: %s\n", s.name);
     printf("age : %d\n", s.age);
     printf("sex : %s\n", s.sex);
     printf("id  : %s\n", s.id);

 //按照指定的顺序初始化

     struct Stu s2 = { .age = 18, .name = "lisi", .id = "20230818002", .sex =  "⼥" };
     printf("name: %s\n", s2.name);
     printf("age : %d\n", s2.age);
     printf("sex : %s\n", s2.sex);
     printf("id  : %s\n", s2.id);
     return 0;
 }

二: 结构体的进阶运用

1.结构体的特殊声明

前面我们说到结构体中的tag，自己设置的名字，实际上有时候可以不写

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

 //匿名结构体类型
 
struct
 {
     int a;
     char b; 
    float c;
 }x;

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

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

那它与一般正常的结构体有什么不同呢？

那么问题来了，因为这两个结构体中的变量类型都一样，它们可以说是一个结构体

那么如果我将上面的结构体 “ x ” 的地址放到下面的结构体中呢？

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

警告：

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

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

2.结构的⾃引⽤

讲到自引用，在结构中包含⼀个类型为该结构本⾝的成员是否可以呢？

下面我将用链表来作例子，

在此之前，由于我还没有学数据结构，因而理解十分浅显

先大概说一下数据结构的分类

2.1 结构体在链表中使用

假如我们想要存储1，2，3，4，5这几个数据，同时希望能够通过这几个数据中的一个数据找到另外几个数据时，用的就是链表

那么这就意味着，我们要能在一个结构体中找到另外一个结构体

那么直接在创建结构体的时候放入另外一个结构体的内容以此来作为循迹的方式可以吗？

比如下面的代码

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

仔细分析，其实是不⾏的，因为⼀个结构体中再包含⼀个同类型的结构体变量，这样结构体变量的⼤⼩就会⽆穷的⼤，是不合理的

因而就需要一个大小有限的方式，c语言中指针的运用很为重要，那试试看指针

正确的⾃引⽤⽅式：

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

2.2 使用typedef时结构体的自引用

在使用结构体中，夹杂了typedef对匿名结构体类型重命名，也容易引⼊问题，比如下面的代码

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

错在typedef 是在创建完结构体类型后才能对这个结构体重命名，

但是代码中的 Node* 意味着已经你正在创建的结构体已经创建完成，这是矛盾的，因而错误。

解决⽅案如下：定义结构体不要使⽤匿名结构体了

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

3. 结构体内存对⻬

3.1 引入

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

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

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

对于结构体内存的对齐，我们要使用一个宏

offsetof

它可以计算出结构体的成员相较于结构体起始位置的偏移量

需要头文件#include <stddef.h>

大概使用方法

offsetof(struct S2, i)

下面让我们看一下这两段代码在内存中所占大小

struct S1
{
    char c1;
    int i;
    char c2;
};


struct S2
{
	char c1;
	char c2;
	int i;
};

按照我们前面的知识来说，这两个结构体类型的大小应当都是相同的 6 个字节

然而代码出来却是大相径庭的结果

这是为什么呢？

使用offsetof宏

我们可以得知它们相对于起始位置的偏移量竟然是不同的，这是怎么回事呢？

实际上，结构体中的元素都有其对应的对齐规则

3.2 对⻬规则

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

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

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

V S 中默认的值为 8

Linux中gcc没有默认对⻬数，对⻬数就是成员⾃⾝的⼤⼩

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

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

下面是一些练习以及我的一些笔记的解答

首先第一条规则：第一个成员总是在0偏移处位置，很好理解

第二条规则：意味着你的类型会影响你所偏移的位置，比如int 类型，它有4个字节，需要在偏移量为4的倍的位置。但如果你的大小比编译器的默认对齐数大的话，用的是编译器的默认对齐数，（当然默认对齐数后期可以改）这就是影响结构体大小的原因之一。

第三条规则：意味着你结构体的最终大小与成员中的最大对齐数有关，是它的倍数。

第四条规则：与第三条类似，把嵌套结构体中的结构体看作一种类型去看它大小去算对齐数就行

struct S1
{
    char c1;
    int i;
    char c2;
};

struct S2
{
	char c1;
	char c2;
	int i;
};

struct S3
{
	double d;
	char c;
	int i;
};

struct S4
{
	char c1;
	struct S3 s3;
	double d;
};

4.为什么存在内存对⻬?

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

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

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

2. 性能原因：

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

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

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

让占⽤空间⼩的成员尽量集中在⼀起

比如下面这样，空间的运用上有了变化

struct S1
{
 char c1;
 int i;
 char c2;
};
 struct S2
{
 char c1;
 char c2;
 int i;
};

5.修改默认对⻬数

#pragma 这个预处理指令，可以改变编译器的默认对⻬数。

int main()
{
	struct s1;
	struct s2;
	printf("%d\n", sizeof(struct S4));

	return 0;
}


#pragma pack(1)//设置默认对⻬数为1
struct S
{
	char c1;
	int i;
	char c2;
};
#pragma pack()//取消设置的对⻬数，还原为默认

int main()
{
	//输出的结果是什么？


	printf("%zd\n", sizeof(struct S));
	return 0;

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

当然设置默认对齐数时一般都是2的次方

6.结构体传参

写函数的过程中，有时需要用到结构体传参，传参有两种

1.传值传参

2.传址传参

那么那种对于结构体传参来说更好呢？先说答案，传址传参

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); //(*ps).data[i]
}

原因： 函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。

如果传递⼀个结构体对象的时候，结构体过⼤，参数压栈的的系统开销⽐较⼤，所以会导致性能的下降。

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

7.结构体实现位段

7.1 什么是位段

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

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

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

即多了个冒号和数字，下面将从我的笔记出发，说说它们的作用

正如上面所写，位段能够限制类型使用的bit位数，使用得当，可以减少性能开销。

7.2 位段的内存分配

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

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

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

位段的开辟是一段一段开辟的，用到哪开到哪，但是有些问题

7.3 位段的跨平台问题

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

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

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

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