C++ 结构体定义

1. 什么是结构体？

结构体就像是一个“收集箱”：

想象一下，如果你想把几个东西放进一个盒子里，比如一个人的名字、年龄和身高。你可以为每个东西写一个标签，然后把它们放到这个盒子里。这个盒子就像是结构体。

比如，你想记录一个学生的信息，里面可能有：

  • 学生的名字
  • 学生的年龄
  • 学生的身高

我们可以用结构体把这些信息装到一起，就像是一个学生的“资料卡”。

结构体是用来存放多种不同数据的工具：

在C++中，我们用struct来定义结构体。struct就是一个特别的盒子，可以放很多不同类型的数据。

举个例子：

  1. struct Student {
  2.     string name;  // 存放学生的名字
  3.     int age;      // 存放学生的年龄
  4.     float height; // 存放学生的身高
  5. };

上面的代码定义了一个结构体叫做Student，它可以存放学生的名字、年龄和身高。

2. 如何创建一个学生？

创建学生资料卡片：

你现在有了一个结构体Student，那么你就可以用它来创建学生了。

假设我们要创建一个学生，名字叫Tom，10岁，身高140.5cm。我们可以这样做：

  1. Student student1;  // 创建一个学生，叫做student1
  2. student1.name = "Tom";      // 给student1的名字写上"Tom"
  3. student1.age = 10;          // 给student1的年龄写上10
  4. student1.height = 140.5;    // 给student1的身高写上140.5

现在，student1就是我们创建的学生资料卡片，里面包含了Tom的名字、年龄和身高。

3. 如何查看学生的信息？

打开学生的资料卡片：

如果我们想知道Tom的名字、年龄和身高，我们可以直接查看student1这个学生的资料。

  1. cout << "Name: " << student1.name << endl;  // 输出学生名字
  2. cout << "Age: " << student1.age << endl;    // 输出学生年龄
  3. cout << "Height: " << student1.height << endl; // 输出学生身高

输出的结果会是：

  1. Name: Tom
  2. Age: 10
  3. Height: 140.5

这样，我们就成功地查看了Tom的资料。

4. 结构体指针（了解）

-> 的引用方式

什么是指针？

你可以把指针看作是一张“地址卡”。如果你有一张地址卡，它上面写着某个地方的地址，你可以去那个地方看看。而结构体指针就告诉我们“学生资料卡”的位置，我们可以通过它去查看资料。

比如，假设你有一个学生student1，你想通过“地址卡”来查看学生信息，你可以这样做：

  1. Student* ptr = &student1;  // ptr是一个指针，它指向student1

这里的ptr是一个指针，它记录了student1的位置。

使用指针查看信息：

通过指针，我们可以用“箭头”来查看学生的资料。这个箭头叫做->，它可以帮助我们快速访问结构体中的信息。

  1. cout << "Name: " << ptr->name << endl;  // 通过指针查看名字
  2. cout << "Age: " << ptr->age << endl;    // 通过指针查看年龄
  3. cout << "Height: " << ptr->height << endl; // 通过指针查看身高

为什么要用指针？

使用指针可以更灵活地操作和管理数据，特别是当你需要传递很多数据时，指针可以让你更高效地处理它们。

5. 结构体作为函数的参数

把学生传给函数：

有时候，我们需要把学生的信息传递给一个函数。函数就像一个小助手，接收学生的信息然后做一些工作。

假设我们有一个函数，它会打印出学生的信息。我们可以这样传递学生给这个函数：

  1. void printStudent(Student s) {
  2.     cout << "Name: " << s.name << endl;  // 打印名字
  3.     cout << "Age: " << s.age << endl;    // 打印年龄
  4.     cout << "Height: " << s.height << endl; // 打印身高
  5. }

这个函数printStudent会打印出学生的所有信息。

调用函数：

我们可以把学生student1传递给这个函数，让它打印出来：

  1. Student student2;
  2. student2.name = "Lucy";     // 给学生Lucy命名
  3. student2.age = 12;          // 设置学生年龄为12
  4. student2.height = 150.0;    // 设置学生身高为150.0
  6. printStudent(student2);  // 调用函数，传递student2

运行结果会打印出：

  1. Name: Lucy
  2. Age: 12
  3. Height: 150

6. 结构体的总结

  • 结构体是用来存放多个不同类型数据的工具，像是一个收集箱。
  • 你可以创建结构体变量来存放数据，就像创建一个学生资料卡。
  • 你可以通过访问结构体的各项数据来查看信息。
  • 使用结构体指针可以更方便地处理数据，像是通过“地址卡”来查看内容。
  • 结构体可以作为函数的参数传递，让我们更方便地使用和修改数据。

结构体排序

好的！下面是一个关于 C++ 中 结构体 和 sort 函数 排序的讲解及案例。通过这个讲解，你可以学习如何定义结构体，并使用 sort 函数对结构体进行排序。

C++ 结构体和 sort 排序

1. 使用 sort 排序结构体

在 C++ 中，sort 函数来自标准库 <algorithm>，它能够根据给定的规则对数据进行排序。我们可以对结构体数组中的元素进行排序。要实现排序，首先需要定义排序规则。

例子：

假设我们有一个学生数组，想根据学生的分数对学生进行排序。我们可以使用 sort 和一个比较函数来实现。

  1. #include <iostream>
  2. #include <string>
  3. #include <algorithm>  // 引入 sort 函数
  4. using namespace std;
  6. // 定义 Student 结构体
  7. struct Student {
  8.     string name; // 学生名字
  9.     int age;     // 学生年龄
  10.     float score; // 学生分数
  11. };
  13. // 比较函数：按分数从高到低排序
  14. bool compareByScore(Student a, Student b) {
  15.     return a.score > b.score; // 返回 true 表示 a 排在 b 前面
  16. }
  18. int main() {
  19.     // 创建一个学生数组
  20.     Student students[3] = {
  21.         {"Tom", 18, 88.5},
  22.         {"Lucy", 20, 92.3},
  23.         {"John", 19, 85.0}
  24.     };
  26.     // 使用 sort 排序，按照分数从高到低排序
  27.     sort(students, students + 3, compareByScore);
  29.     // 输出排序后的学生信息
  30.     for (int i = 0; i < 3; i++) {
  31.         cout << "Name: " << students[i].name << ", Age: " << students[i].age << ", Score: " << students[i].score << endl;
  32.     }
  34.     return 0;
  35. }

运行结果：

  1. Name: Lucy, Age: 20, Score: 92.3
  2. Name: Tom, Age: 18, Score: 88.5
  3. Name: John, Age: 19, Score: 85

在这个例子中，我们根据学生的分数对学生进行排序，compareByScore 函数是比较函数，它告诉 sort 函数如何比较两个学生的分数。

2. 更加灵活的排序方式

你不仅可以根据一个字段来排序，还可以根据多个字段排序。例如，我们可以先按分数排序，再按年龄排序。

例子：

假设我们要按分数从高到低排序，如果分数相同，则按年龄从低到高排序。

  1. #include <iostream>
  2. #include <string>
  3. #include <algorithm>  // 引入 sort 函数
  4. using namespace std;
  6. // 定义 Student 结构体
  7. struct Student {
  8.     string name; // 学生名字
  9.     int age;     // 学生年龄
  10.     float score; // 学生分数
  11. };
  13. // 比较函数：按分数从高到低排序，分数相同则按年龄从低到高排序
  14. bool compareByScoreAndAge(Student a, Student b) {
  15.     if (a.score == b.score) {
  16.         return a.age < b.age; // 分数相同，按年龄排序
  17.     }
  18.     return a.score > b.score; // 否则按分数排序
  19. }
  21. int main() {
  22.     // 创建一个学生数组
  23.     Student students[4] = {
  24.         {"Tom", 18, 88.5},
  25.         {"Lucy", 20, 92.3},
  26.         {"John", 19, 92.3},
  27.         {"Alice", 18, 88.5}
  28.     };
  30.     // 使用 sort 排序，按照分数从高到低排序，分数相同按年龄从低到高排序
  31.     sort(students, students + 4, compareByScoreAndAge);
  33.     // 输出排序后的学生信息
  34.     for (int i = 0; i < 4; i++) {
  35.         cout << "Name: " << students[i].name << ", Age: " << students[i].age << ", Score: " << students[i].score << endl;
  36.     }
  38.     return 0;
  39. }

运行结果：

  1. Name: Lucy, Age: 20, Score: 92.3
  2. Name: John, Age: 19, Score: 92.3
  3. Name: Tom, Age: 18, Score: 88.5
  4. Name: Alice, Age: 18, Score: 88.5

在这个例子中，compareByScoreAndAge 函数首先按分数排序，如果分数相同，则按年龄排序。你可以看到，分数相同的学生（Tom 和 Alice）根据年龄从小到大排列。

3. 使用 Lambda 表达式简化排序

在 C++11 中，你还可以使用 lambda 表达式 来简化排序的代码，避免单独定义比较函数。

例子：

我们可以直接在 sort 函数中使用 lambda 表达式来进行排序：

  1. #include <iostream>
  2. #include <string>
  3. #include <algorithm>  // 引入 sort 函数
  4. using namespace std;
  6. // 定义 Student 结构体
  7. struct Student {
  8.     string name; // 学生名字
  9.     int age;     // 学生年龄
  10.     float score; // 学生分数
  11. };
  13. int main() {
  14.     // 创建一个学生数组
  15.     Student students[4] = {
  16.         {"Tom", 18, 88.5},
  17.         {"Lucy", 20, 92.3},
  18.         {"John", 19, 92.3},
  19.         {"Alice", 18, 88.5}
  20.     };
  22.     // 使用 lambda 表达式排序，按分数从高到低，分数相同按年龄从低到高
  23.     sort(students, students + 4, [](Student a, Student b) {
  24.         if (a.score == b.score) {
  25.             return a.age < b.age;
  26.         }
  27.         return a.score > b.score;
  28.     });
  30.     // 输出排序后的学生信息
  31.     for (int i = 0; i < 4; i++) {
  32.         cout << "Name: " << students[i].name << ", Age: " << students[i].age << ", Score: " << students[i].score << endl;
  33.     }
  35.     return 0;
  36. }

运行结果：

  1. Name: Lucy, Age: 20, Score: 92.3
  2. Name: John, Age: 19, Score: 92.3
  3. Name: Tom, Age: 18, Score: 88.5
  4. Name: Alice, Age: 18, Score: 88.5

在这个例子中，我们用 lambda 表达式直接在 sort 函数中定义了排序规则，代码更简洁，也更直观。

4. 总结

  • 结构体：用来存储不同类型的数据，可以组织成一个“对象”。
  • sort 函数：用于排序，可以根据自定义的比较规则排序。
  • 比较函数：可以是单独定义的函数，也可以是使用 lambda 表达式。
  • 排序方式：可以根据一个字段排序，也可以根据多个字段进行排序（例如先按分数，后按年龄）。