C 数组允许定义可存储相同类型数据项的变量，结构体是 C 编程中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。
结构体中的数据成员可以是基本数据类型（如 int、float、char 等），也可以是其他结构体类型、指针类型等。
结构用于表示一条记录，假设您想要跟踪图书馆中书本的动态，您可能需要跟踪每本书的下列属性：
Title
Author
Subject
Book ID
1.定义结构
结构体定义由关键字 struct 和结构体名组成，结构体名可以根据需要自行定义。
truct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
} book;
Books：是结构体标签。
book：是结构变量，定义在结构的末尾，最后一个分号之前，您可以指定一个或多个结构变量
在一般情况下，Books、标准的变量定义体、book 这 3 部分至少要出现 2 个。以下为实例：
//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//同时又声明了结构体变量s1
//这个结构体并没有标明其标签
struct
{
int a;
char b;
double c;
} s1;
//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//结构体的标签被命名为SIMPLE,没有声明变量
struct SIMPLE
{
int a;
char b;
double c;
};
//用SIMPLE标签的结构体，另外声明了变量t1、t2、t3
struct SIMPLE t1, t2[20], *t3;
//也可以用typedef创建新类型
typedef struct
{
int a;
char b;
double c;
} Simple2;
//现在可以用Simple2作为类型声明新的结构体变量
Simple2 u1, u2[20], *u3;
在上面的声明中，第一个和第二声明被编译器当作两个完全不同的类型，即使他们的成员列表是一样的，如果令 t3=&s1，则是非法的。
结构体的成员可以包含其他结构体，也可以包含指向自己结构体类型的指针，而通常这种指针的应用是为了实现一些更高级的数据结构如链表和树等。
//此结构体的声明包含了其他的结构体
struct COMPLEX
{
char string[100];
struct SIMPLE a;
};
//此结构体的声明包含了指向自己类型的指针
struct NODE
{
char string[100];
struct NODE *next_node;
};
如果两个结构体互相包含，则需要对其中一个结构体进行不完整声明，如下所示：
struct B; //对结构体B进行不完整声明
//结构体A中包含指向结构体B的指针
struct A
{
struct B *partner;
//other members;
};
//结构体B中包含指向结构体A的指针，在A声明完后，B也随之进行声明
struct B
{
struct A *partner;
//other members;
};
2.结构体变量的初始化
和其它类型变量一样，对结构体变量可以在定义时指定初始值。
#include
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
} book = {"C语言", "RUNOOB", "编程语言", "1234"};
int main()
{
printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
}
//执行输出结果为：
title : C 语言
author: RUNOOB
subject: 编程语言
book_id: 1234
3.访问结构体成员
为了访问结构的成员，我们使用成员访问运算符（.）
#include
#include
//定义结构体类型
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};
int main()
{
struct Books Book1; /* 声明 Book1，类型为 Books */
struct Books Book2; /* 声明 Book2，类型为 Books */
//给结构体变量赋值
//这里使用strcpy()函数来赋值字符串
strcpy(Book1.title, "C Programming");
strcpy( Book1.author, "Nuha Ali");
strcpy( Book1.subject, "C Programming Tutorial");
Book1.book_id = 67583;
/* Book2 详述 */
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Zara Ali");
strcpy( Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;
/* 输出 Book1 信息 */
printf( "Book 1 title : %s\n", Book1.title);
printf( "Book 1 author : %s\n", Book1.author);
printf( "Book 1 subject : %s\n", Book1.subject);
printf( "Book 1 book_id : %d\n", Book1.book_id);
/* 输出 Book2 信息 */
printf( "Book 2 title : %s\n", Book2.title);
printf( "Book 2 author : %s\n", Book2.author);
printf( "Book 2 subject : %s\n", Book2.subject);
printf( "Book 2 book_id : %d\n", Book2.book_id);
return 0;
}
4.结构体作为函数参数
#include
#include
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};
/* 函数声明 */
void printBook( struct Books book );
int main( )
{
struct Books Book1; /* 声明 Book1，类型为 Books */
struct Books Book2; /* 声明 Book2，类型为 Books */
/* Book1 详述 */
strcpy( Book1.title, "C Programming");
strcpy( Book1.author, "Nuha Ali");
strcpy( Book1.subject, "C Programming Tutorial");
Book1.book_id = 6495407;
/* Book2 详述 */
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Zara Ali");
strcpy( Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;
/* 调用printBook函数，传入结构体 输出 Book1 信息 */
printBook( Book1 );
/* 输出 Book2 信息 */
printBook( Book2 );
return 0;
}
void printBook( struct Books book )
{
printf( "Book title : %s\n", book.title);
printf( "Book author : %s\n", book.author);
printf( "Book subject : %s\n", book.subject);
printf( "Book book_id : %d\n", book.book_id);
}
5.指向结构体的指针
定义指向结构的指针，方式与定义指向其他类型变量的指针相似，如下所示
struct Books *struct_pointer;
现在，您可以在上述定义的指针变量中存储结构变量的地址。为了查找结构变量的地址，请把 & 运算符放在结构名称的前面，如下所示：
struct_pointer = &Book1;
为了使用指向该结构的指针访问结构的成员，您必须使用 -> 运算符，如下所示：
struct_pointer->title;
案例
#include
#include
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};
/* 函数声明 */
void printBook( struct Books *book );
int main( )
{
struct Books Book1; /* 声明 Book1，类型为 Books */
struct Books Book2; /* 声明 Book2，类型为 Books */
/* Book1 详述 */
strcpy( Book1.title, "C Programming");
strcpy( Book1.author, "Nuha Ali");
strcpy( Book1.subject, "C Programming Tutorial");
Book1.book_id = 6495407;
/* Book2 详述 */
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Zara Ali");
strcpy( Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;
/* 通过传 Book1 的地址 来输出 Book1 信息 */
printBook( &Book1 ); //只需传递地址
/* 通过传 Book2 的地址来输出 Book2 信息 */
printBook( &Book2 );
return 0;
}
void printBook( struct Books *book )
{
printf( "Book title : %s\n", book->title);
printf( "Book author : %s\n", book->author);
printf( "Book subject : %s\n", book->subject);
printf( "Book book_id : %d\n", book->book_id);
}
理解
void func(struct HugeData *data)
void func(struct HugeData data)
// 传指针
void func(struct HugeData *data); // 参数是指针
struct HugeData hd;
func(&hd); // 调用时 ,只需传递地址
实际发生的过程：
1.系统仅需要复制hd的内存地址（如0x1000）
2.将这个地址值（通常4/8字节）存入新栈帧
3.函数通过这个地址直接访问原数据
------------------------------------
[调用前内存]
原结构体 hd (地址0x1000-0x2000)
[4KB数据...]
[调用时内存]
参数 data (地址0x3000)
[存储的值是 0x1000] ← 只复制了这个地址值
↑
└─── 指向原结构体中的值
--------------------------------------
//传值
当直接传递结构体时：
void func(struct HugeData data); // 参数是结构体本身
struct HugeData hd;
func(hd); // 调用时，直接传递整个结构体的值，相当于重新开辟了一个新的内存地址，且完整的复制了整个结构体的值，消耗大
实际发生的过程：
1.系统在新的栈帧中开辟一块4KB的空间
2.将原结构体hd的每一个字节逐位复制到新位置
3.函数内部操作的是一份完全独立的副本
---------------------------------------
[调用前内存]
原结构体 hd (地址0x1000-0x2000)
[4KB数据...]
[调用时内存]
原结构体 hd (地址0x1000-0x2000)
[4KB数据...]
↓ 完整复制
新结构体 data (地址0x3000-0x4000)
[完全相同的4KB数据...]
----------------------------------------
类比解释为什么传指针比传值更好
场景：你要给别人一本书的内容
方式
操作
对应编程概念
直接传值
把整本书复印一份给对方
复制整个结构体（4KB）
传指针
告诉对方"书在我家第三层书架"
只传递地址（4字节）
传值：需要消耗大量纸张和时间（内存和CPU周期）
传指针：只需要写一张小纸条（传递地址）
计算机底层视角
函数调用时的参数传递规则
所有参数都会被压入栈（stack）或存入寄存器
传值：需要把整个对象放入栈/寄存器
传指针：只需放入一个地址值
典型系统的限制
系统类型 寄存器大小 典型地址长度
32位系统 32位(4字节) 4字节
64位系统 64位(8字节) 8字节
因此：
传4KB结构体 → 需要移动4096字节数据
传指针 → 只需移动4/8字节地址
极端情况验证
假设结构体有100万个int（约4MB）：
struct GiantData {
int data[1000000]; // 4MB
};
// 传值（灾难性）
void process1(struct GiantData d); // 调用时复制4MB
// 传指针（高效）
void process2(struct GiantData *d); // 调用时复制8字节
process1()：每次调用产生4MB内存拷贝，可能导致：
栈溢出（stack overflow）
严重性能下降
process2()：无论结构体多大，永远只复制指针大小
关键结论
传值是复制数据 → 数据多大就复制多少
传指针是复制地址 → 永远只复制4/8字节
指针的本质：是一种"轻量级引用"，通过存储目标位置来避免数据搬运
这种设计使得C语言可以：
高效操作任意大小的数据
实现复杂数据结构（如链表、树）
直接与硬件交互（通过内存地址）
结构体大小的计算
C 语言中，我们可以使用 sizeof 运算符来计算结构体的大小，sizeof 返回的是给定类型或变量的字节大小。
对于结构体，sizeof 将返回结构体的总字节数，包括所有成员变量的大小以及可能的填充字节。
以下实例演示了如何计算结构体的大小：
#include
struct Person {
char name[20];
int age;
float height;
};
int main() {
struct Person person;
printf("结构体 Person 大小为: %zu 字节\n", sizeof(person));
return 0;
}
//输出
结构体 Person 大小为: 28 字节
以上实例中，我们定义了一个名为 Person 的结构体，它包含了一个字符数组 name、一个整数 age 和一个浮点数 height。
在 main 函数中，我们声明了一个 Person 类型的变量 person，然后使用 sizeof 运算符来获取 person 结构体的大小