结构体

# 1.0 什么是结构体

C 数组允许定义可存储相同类型数据项的变量，结构是 C 编程中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。

例如：你可以将一本书的书名、作者名字、页数、ISBN号码存储进一个结构体变量内。

# 2.0 定义一个结构

struct tag {
    member-list1;
    member-list2;
    ... ...
    member-listx;
} variable-list;

1
2
3
4
5
6

名称	是什么
tag	结构体标签，它相当于整个结构体的名称
member-list	结构体内存储的内容，可以是标准的变量定义(`int`、`float`等) 或其他有效的变量定义
variable-list	结构体变量列表，比如开头举的例子：我们创造这个结构体不是为了只存储一本书，而是为相当于创造出了一个模板去存储书籍的信息，所以一个结构体模板下可以有多个变量

注意

对于定义的结构体：

结构体的tag不同就相当于在定义变量时的类型不同（int != double）
因此当结构体变量涉及指针的时候，需要谨慎操作

# 2.1 定义的三种方法

一步到位型

struct (NAME) {
    int a;
    double b;
    char c[10];
} variable, *pointer;

1
2
3
4
5

带括号的tag是可选内容；

分开定义型

struct NAME {
    int a;
    double b;
    char c[10];
};

struct NAME variable, *pointer;

1
2
3
4
5
6
7

使用 typedef型

typedef struct {
    int a;
    double b;
    char c[10];
} NAME2;

NAME2 variable, *pointer;

1
2
3
4
5
6
7

# 2.2 结构体的包含

当你想要结构体的内容包含另一个结构体或者其本身的时候，可以这么做：

//此结构体的声明包含了其他的结构体
struct COMPLEX
{
    char string[100];
    struct SIMPLE a;
};
 
//此结构体的声明包含了指向自己类型的指针
struct NODE
{
    char string[100];
    struct NODE *next_node;
};

1
2
3
4
5
6
7
8
9
10
11
12
13

希望你不要在包含自身的时候在结构体中写入一个自身普通类型的member，你可以想一下将会发生什么？没错，禁止套娃。

当两个结构体想要相互包含的时候，需要对其中一个进行不完整声明：

struct B;    //对结构体B进行不完整声明
 
//结构体A中包含指向结构体B的指针
struct A
{
    struct B *partner;
    //other members;
};
 
//结构体B中包含指向结构体A的指针，在A声明完后，B也随之进行声明
struct B
{
    struct A *partner;
    //other members;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 3.0 结构体变量

# 3.1 向结构体变量中写入数据

依然以图书信息为例，构建一个结构体：

struct BOOKS {
    char name[50];
    char author[40];
    int pages;
    int book_id;
} book1 = {"Fake news", "Donald Trump", 1000, 15698};

1
2
3
4
5
6

方法就是使用花括号将结构内的项目按照顺序依次给出信息

如此一来，我们就知道了这本书的信息：

名称	内容
书名	Fake news
作者	Donald Trump
页数	1000
ID	15698

# 3.2 访问结构成员

方法是使用.(成员访问运算符)：

struct BOOKS {
    char name[50];
    char author[40];
    int pages;
    int book_id;
} book1 = {"Fake news", "Donald Trump", 1000, 15698};

strcpy(book1.name, "C Programming");
strcpy(book1.author, "Nuha Ali");
book1.pages = 2000;
book1.book_id = 25642;

1
2
3
4
5
6
7
8
9
10
11

# 3.3 当作函数参数

幸运的是结构体变量可以像普通变量一样当作一个参数在函数之间传递，并不需要多虑什么：

void print_info(struct BOOKS book2);
int main()
{
    struct BOOKS {
        char name[50];
        char author[40];
        int pages;
        int book_id;
    } book1 = {"Fake news", "Donald Trump", 1000, 15698};
    print_info(book1);
}
void print_info(struct BOOKS book2)
{
    printf( "Book name : %s\n", book2.name);
    printf( "Book author : %s\n", book2.author);
    printf( "Book pages : %d\n", book2.pages);
    printf( "Book book_id : %d\n", book2.book_id);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 3.3 指向结构的指针

继续我们的图书信息储存结构：当使用 struct BOOKS *pointer = &book1 定义了一个指向了 book1 的指针，我们就可以使用指针来访问这个结构体变量，但不同点是需要使用 -> 运算符：

void print_info(struct BOOKS book2);
int main()
{
    struct BOOKS {
        char name[50];
        char author[40];
        int pages;
        int book_id;
    } book1 = {"Fake news", "Donald Trump", 1000, 15698};
    struct BOOKS *pointer;
    print_info(book1);
}
void print_info(struct BOOKS book2)
{
    printf( "Book name : %s\n", pointer -> name);
    printf( "Book author : %s\n", pointer -> author);
    printf( "Book pages : %d\n", pointer -> pages);
    printf( "Book book_id : %d\n", pointer -> book_id);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

参考：

C 结构体 | 菜鸟教程: https://www.runoob.com/cprogramming/c-structures.html (opens new window)

编辑

上次更新: 2020/08/16, 12:08:00

← 枚举位域→