8.C语言知识回顾-结构体

目录

一. 结构体类型的声明

二. 结构体的自引用

三. 结构体变量的定义和初始化

四. 结构体内存对齐

五. 结构体传参

---

参考：54.自定义数据类型-结构体（1）（C语言程序设计教程谭浩强 c语言谭浩强视频教程 c语言零基础入门教程 学习c语言 c语言视频教程 c语音 C语言教程 C语言_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1q54y1q79w?p=54&vd_source=7bf292964a807d18168b0c665fed431c

一. 结构体类型的声明

内置类型：C语言自己的数据类型，char，short，int，double...

对于复杂对象，复杂类型，我们可以采用自定义类型：结构体，枚举，联合体等。

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

结构体类型的声明格式如下：其中struct为结构体类型关键字，tag是标签。

struct tag
{
    member_list  //成员列表
}variable_list  //变量列表，可以为空

例如，声明一个学生结构体类型：

struct stu
{
    char name[20];  //名字
    char tel[12];  //电话
    int age;  //年龄
};

现在我们创建结构体变量，注意结构体类型定义的变量列表中创建的变量是全局变量：

# include <stdio.h>
struct stu
{
    char name[20];  //名字
    char tel[12];  //电话
    int age;  //年龄
}s4,s5; //s4,s5是全局变量

struct stu s3;  //s3是全局变量

int main()
{
    struct stu s1; //s1,s2是局部变量
    struct stu s2;
}

和匿名函数一样，我们也可以创建匿名结构体类型，匿名结构体类型的变量列表不能为空：

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

二. 结构体的自引用

在结构中包含一个类型为该结构本身的成员是否可以呢？

struct Node
{
    char name;  
    struct Node n;
};

设想我们去求这个结构体变量所占内存大小sizeof（）；会发现它无法求解，因为它是一种嵌套关系。因此上面这段代码是非法的。而写成指向这种类型的指针是可以的，因为指针的大小是可以确定的：

struct Node
{
    char name;  
    struct Node* next;
};

此外，我们可以用typedef为结构体变量取别名（不可以对匿名结构体使用typedef关键字）：

typedef struct Node
{
    char name;  
    struct Node* next;
}Node;  //把struct Node简化成Node

int main()
{
    struct Node n1;
    Node n2;
}

三. 结构体变量的定义和初始化

如题：

# include <stdio.h>
struct S
{
    char c;  
    int a;
    double d;
    char arr[20];  
};

int main()
{
    struct S s ={'c',100,3.2,"hello_world"};  //初始化
    //结构体类型的地址用箭头，结构体类型的话用点
    printf("%c %d %lf %s\n",s.c,s.a,s.d,s.arr);  //访问结构体变量的元素
    return 0;
}

虽然结构体变量中不能使用结构体本身，但可以使用别的已经定义好的结构体：

# include <stdio.h>
struct T
{
    int a;
    double b;
};
struct S
{
    char c;  
    int a;
    struct T t;
    double d;
    char arr[20];  
};

int main()
{
    struct S s ={'c',100,{6,55.6},3.2,"hello_world"};  
    printf("%d\n",s.t.a);  //访问结构体变量T中的整数元素
    return 0;
}

四. 结构体内存对齐

如何计算结构体的大小？首先分析以下代码：

# include <stdio.h>
struct s1
{
    char c1;
    int i;
    char c3;
};
struct s2
{
    char c1;  
    char c2;
    int a; 
};

int main()
{
    struct s1 a;
    struct s2 b;
    printf("%d\n",sizeof(a));  
    printf("%d\n",sizeof(b)); 
    return 0;
}

运行结果：12，8

为什么结构体类型s1和s2包含相同的类型，占用的内存不一样？这是因为结构体的对齐规则：

1.第一个成员变量在与结构体变量偏移量为0的地址处；

2.其他成员变量要对齐到对齐数的整数倍的地址处；

对齐数=编译器中默认的一个对齐数（VScode是8）与该成员大小的较小值；

3.结构体总大小需要是成员变量中的最大对齐数的整数倍；

4.如果结构体中嵌套的还有结构体，则嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

因此结构体变量a,b的内存分配情况如下图所示：

这时白色的内存都被浪费掉。 

练习1：

# include <stdio.h>
struct s3
{
    double d;
    char c;
    int i;
};

int main()
{
    struct s3 a;
    printf("%d\n",sizeof(a));
    return 0;
}

答案：16；内存分配情况如下所示：

练习2（嵌套结构体）：

# include <stdio.h>
struct s3
{
    double d;
    char c;
    int i;
};

struct s4
{
    char c1;
    struct s3 s;
    double d;
};

int main()
{
    struct s4 a;
    printf("%d\n",sizeof(a));
    return 0;
}

答案：32，内存分配如下所示：

为什么存在内存对齐?

1.平台原因(移植原因):不是所有的硬件平台都能访问任意地址上的任意数据的;某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。

2.性能原因:数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问;而对齐的内存访问仅需要一次访问。

总的来说，结构体的内存对齐是拿空间来换取时间的做法。在设计结构体变量的时候，为了尽量缩小内存，可以让占用空间较小的成员变量尽可能集中在一起。

也可以通过修改默认对齐数的方法缩小内存：使用#pragma back（num）指令，num为空时表示恢复默认设置。如下，设置默认对齐数为4：

# include <stdio.h>
# pragma pack(4)
struct s3
{
    char c1;
    double i;
};

int main()
{
    struct s3 a;
    printf("%d\n",sizeof(a));
    return 0;
}

这里运行的结果就为12，如果保持原默认设置，运行结果为16；

此外，我们还可以通过offsetof（）获得成员变量存储位置的偏移量；此函数需要<stddef.h>头文件：

# include <stdio.h>
# include <stddef.h>
struct s3
{
    char c1;
    int b;
    double i;
};

int main()
{
    printf("%d\n",offsetof(struct s3,c1));
    printf("%d\n",offsetof(struct s3,b));
    printf("%d\n",offsetof(struct s3,i));
    return 0;
}

输出结果：0，4，8；

五. 结构体传参

（1）传值方式

# include <stdio.h>
struct s
{
    int a;
    char c;
    double d;
};

void Init(struct s tmp) //传值方式
{
    tmp.a = 100;
    tmp.c = 'w';
    tmp.d = 3.14; //这时tmp里面只是s的拷贝，改变tmp的值不改变s
}

int main()
{
    struct s s1 = {0}; //初始化
    printf("%d\n",s1.a); //Init前
    Init(s1);
    printf("%d\n",s1.a); //Init后，输出结果为0，0，s的值不发生变化
    return 0;
}

（2）传地址方式

# include <stdio.h>
struct s
{
    int a;
    char c;
    double d;
};

void Init(struct s* tmp) //传地址方式
{
    tmp->a = 100;
    tmp->c = 'w';
    tmp->d = 3.14; //这时tmp指向s的地址，改变tmp的值同时改变s
}

int main()
{
    struct s s1 = {0};
    printf("%d\n",s1.a); //Init前
    Init(&s1);  //这里参数是指针，存放s1的地址
    printf("%d\n",s1.a); //Init后，输出结果为0，100，s的值发生变化
    return 0;
}

一般来说通常采用传地址方式（节省内存），当不想误操作导致改变指针指向的内容时，可以使用常指针const struct s* tmp：

# include <stdio.h>
struct s
{
    int a;
    char c;
    double d;
};

void Print(const struct s* tmp) //传地址方式，采用常指针
{
    printf("%d %c %lf\n",tmp->a,tmp->c,tmp->d);
}

int main()
{
    struct s s1 = {1,'w',3.4};
    Print(&s1);  //&取地址运算符
    return 0;
}

这时如果再试图修改，就会报错。