c语言之结构体

不想学编程.

已于 2023-10-03 18:07:45 修改

阅读量51

点赞数

分类专栏： c语言语法知识文章标签： c语言开发语言

于 2023-08-11 16:51:20 首次发布

本文链接：https://blog.csdn.net/qwerrtzx/article/details/132233794

版权

c语言语法知识专栏收录该内容

12 篇文章 0 订阅

订阅专栏

文章目录

1、结构体的声明
2、结构体的成员访问
3、结构体传参
4、在函数里修改结构体的变量和上述内容的总结
5、结构体的自引用
6、特殊的声明
7、结构体的内存对齐
8、修改对齐数
9、结构体的位段

1、结构体的声明

1.1结构体的基础知识

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

1.2结构体的声明

struct tag  //struct为关键字，类似int类型。tag为变量名，这个是可以随便起的
{
  member-list;//成员列表
}variable-list;//变量列表（这个也可以没有，就直接加分号就行）

例：定义一个学生的属性（两种使用方法）

struct Stu
{
	//学生的相关属性
	char name[20];
	int age;
	char sex[5];
	char tele[12];
} s3,s4;//分号必须加
//s3，s4也是结构体类型的变量
//s3，s4是全局的
typedef struct Stu
{
	char name[20];
	int age;
	char sex[5];
	char tele[12];
}Stu;(这样就不需要加struct了)
//结构体在主函数的使用方法：
int main()
{
	法1 ：    struct Stu s1;
	          struct Stu s2;
	        //s1,s2为局部变量
	法2：Stu s5;
	//要想省略struct就可以在定义结构体struct加一个typedef
};

1.3 结构成员的类型

结构的成员可以是标量、数组、指针，甚至是其他结构体。

struct B
{
	char c;
	int i;
};
struct S
{
	char c;
	int num;
	int arr[10];
	double* pd;
	struct B sb;
	struct B* pb;
}s1;//s1是全局变量

1.4 结构体的定义和初始化

struct B
{
	char c;
	int i;
};
struct S
{
	char c;
	int num;
	int arr[10];
	double* pd;
	struct B sb;
	struct B* pb;
}s1;
int main()
{
	double d = 3.14;
	//按照顺序初始化
	struct S s3 = { 'q', 100, {1,2,3}, &d, {'a', 99}, NULL };//局部变量
	//指定成员来初始化
	struct S s4 = { .num = 1000, .arr = {1,2,3,4,5} };//局部变量
	return 0;
}

struct Point
{
 int x;
 int y;
}p1; //声明类型的同时定义变量p1
struct Point p2; //定义结构体变量p2
//初始化：定义变量的同时赋初值。
struct Point p3 = {x, y};
struct Stu        //类型声明
{
 char name[15];//名字
 int age;      //年龄
};
struct Stu s = {"zhangsan", 20};//初始化
struct Node
{
 int data;
 struct Point p;
 struct Node* next; 
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

2、结构体的成员访问

（1）结构体变量访问成员
结构变量的成员是通过点操作符（.）访问的。点操作符接受两个操作数
例如：

struct S
{
	char name[20];
	int age;
};

我们可以看到 s 有成员 name 和 age ；那我们如何访问s的成员？

struct S s;
strcpy(s.name, "zhangsan");//使用.访问name成员
//因为name是数组，若直接用.name的话访问的是首元素地址，不能将内容放入，所以需要strcpy函数来实现。
s.age = 20;//使用.访问age成员

（2）结构体指针访问指向变量的成员
有时候我们得到的不是一个结构体变量，而是指向一个结构体的指针。那该如何访问成员？
如下：

struct Stu 
{
char name[15];
int age; 
};
void print(struct Stu* ps)
{
printf("name = %s age = %d\n", (*ps).name, (*ps).age);
//使用结构体指针访问指向对象的成员
printf("name = %s age = %d\n", ps->name, ps->age);
}
int main()
{
struct Stu s = {"zhangsan", 20};
print(&s);//结构体地址传参
return 0;
}

3、结构体传参

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函数。
原因：
函数传参的时候，参数是需要压栈的。
如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。
结论：
结构体传参的时候，要传结构体的地址。

4、在函数里修改结构体的变量和上述内容的总结

#include <string.h>
#include <stdio.h>
struct S
{
	char name[20];
	int age;
};

//void set_s(struct S t)
//{
//	t.age = 18;
//	//t.name = "zhangsan";//err, 因为name是数组名，数组名是常量的地址
//	strcpy(t.name, "zhangsan");//字符串拷贝
//}
//因为形参是实参的一份临时拷贝，改变形参并不会影响实参的值，这里可以类比数组那里。

void set_s1(struct S* ps)
{
 (*ps).age = 18;
	//t.name = "zhangsan";//err, 因为name是数组名，数组名是常量的地址
	strcpy((*ps).name, "zhangsan");//字符串拷贝
}
void set_s2(struct S* ps)
{
	ps->age = 18;
	t.name = "zhangsan";//err, 因为name是数组名，数组名是常量的地址
	strcpy(ps->name, "zhangsan");//字符串拷贝
}
//1和2这两个函数是一样的，只不过为了更加美观，方便，于是改为了箭头，即(*p).name=p->name。
void print_s(struct S* ps)
{
	printf("%s %d\n", ps->name, ps->age);
}
int main()
{
	struct S s = {0};
//	//写一个函数给s中存放数据
	set_s2(&s);
//写一个函数打印s中的数据
	print_s(&s);
	return 0;
}

5、结构体的自引用

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

在这里插入图片描述
上面是一个很明显的错误案例，那么正确的使用应该下面这段代码

struct Node
{
 int data;//数据域
 struct Node* next;//指针域（存放下一个节点指针的位置）
};

改为指针就可以解决了，因为指针的大小是确定的，要么是4个字节，要么是8个字节。这就相当于我们数据结构的链表的结构定义。
注意：

typedef struct
{
 int data;
 Node* next;
}Node;
//这样写代码，可行否？
//解决方案：
typedef struct Node
{
 int data;
 struct Node* next;
}Node;

6、特殊的声明

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

//匿名结构体类型
struct
{
 int a;
 char b;
 float c;
}x;
struct
{
 int a;
 char b;
 float c;
}a[20], *p;

这样的结构体只能使用一次，因为把名字隐藏掉了，所以下次使用的时候就找不到了。这是一种特殊的情况，一般不去使用。

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

这样显然不是合法的，编译器会将两者看成两个不同的类型。

7、结构体的内存对齐

1、计算规则：
在这里插入图片描述
2：练习实例：

3、为什么要内存对齐？

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

让占用空间小的成员尽量集中在一起。

8、修改对齐数

在这里插入图片描述

9、结构体的位段

我们都知道结构体比较占用空间，而位段的出现就是为了减少使用内存空间。

位段的声明和结构是类似的，有两个不同：
1.位段的成员必须是 int、unsigned int 或signed int 。
2.位段的成员名后边有一个冒号和一个数字。

比如：

struct A
{
 int _a:2;//2表示两个比特位，证明_a类型的数据需要2个比特位就够了
 int _b:5;
 int _c:10;
 int _d:30;
};

A就是一个位段类型。
那位段A的大小是多少？

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

在这里插入图片描述
如果不使用位段的话，四个整型需要16个字节，而这样只需要8个，大大减少了内存空间。