C/C++ 数组允许定义可存储相同类型数据项的变量，但是结构是 C++ 中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。 结构用于表示一条记录，假设您想要跟踪图书馆中书本的动态，您可能需要跟踪每本书的下列属性：

  • Title ：标题
  • Author ：作者
  • Subject ：类目
  • Book ID ：书的 ID

定义结构

为了定义结构，您必须使用struct语句。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下：

  1. struct type_name {
  2. member_type1 member_name1;
  3. member_type2 member_name2;
  4. member_type3 member_name3;
  5. .
  6. .
  7. } object_names;

type_name是结构体类型的名称
member_type1 member_name1是标准的变量定义，比如int i;或者float f;或者其他有效的变量定义。
在结构定义的末尾，最后一个分号之前，您可以指定一个或多个结构变量，这是可选的。
下面是声明一个结构体类型Books，变量为book：

  1. struct Books
  2. {
  3.    char  title[50];
  4.    char  author[50];
  5.    char  subject[100];
  6.    int   book_id;
  7. } book;
  1. struct Books book
  2. //或者
  3. Books book

结构体赋值

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  5. struct Books
  6. {
  7.    char  title[50];
  8.    char  author[50];
  9.    string  subject;
  10.    int   book_id = 123456; //默认值
  11. } book;
  14. int main(int argc, char const *argv[])
  15. {
  16.    Books book1; //可以省略 struct
  17.    strcpy( book1.title, "C++ 教程");
  18.    strcpy( book1.author, "一缕清风"); 
  19.    book1.subject = "编程语言";
  20.    book1.book_id = 123456;
  23.    struct Books book2  = {"C语言","kenguba","高级语言",123456};
  24. }

访问结构成员

为了访问结构的成员，我们使用成员访问运算符（.）。成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。
下面的实例演示了结构的用法：

  1. #include <iostream>
  2. #include <cstring>
  3. using namespace std;
  5. // 声明一个结构体类型 Books
  6. struct Books
  7. {
  8.   char title[50];
  9.   char author[50];
  10.   char subject[100];
  11.   int book_id;
  12. };
  14. int main()
  15. {
  16.   Books book1; // 定义结构体类型 Books 的变量 book1
  17.   Books book2; // 定义结构体类型 Books 的变量 book2
  19.   // book1 详述
  20.   strcpy(book1.title, "C++ 教程");
  21.   strcpy(book1.author, "一缕清风");
  22.   strcpy(book1.subject, "编程语言");
  23.   book1.book_id = 123456;
  25.   // book2 详述
  26.   strcpy(book2.title, "CSS 教程");
  27.   strcpy(book2.author, "一缕清风");
  28.   strcpy(book2.subject, "前端技术");
  29.   book2.book_id = 123457;
  31.   // 输出 book1 信息
  32.   cout << "第一本书标题 : " << book1.title << endl;
  33.   cout << "第一本书作者 : " << book1.author << endl;
  34.   cout << "第一本书类目 : " << book1.subject << endl;
  35.   cout << "第一本书 ID : " << book1.book_id << endl;
  37.   // 输出 book2 信息
  38.   cout << "第二本书标题 : " << book2.title << endl;
  39.   cout << "第二本书作者 : " << book2.author << endl;
  40.   cout << "第二本书类目 : " << book2.subject << endl;
  41.   cout << "第二本书 ID : " << book2.book_id << endl;
  43.   strcpy(book1.author, "Kebguba");
  44.   strcpy(book2.author, "Kebguba");
  45.   cout << "第一本书作者 : " << book1.author << endl; //Kebguba
  46.   cout << "第二本书作者 : " << book2.author << endl; //Kebguba
  48.   return 0;
  49. }
  51. /* 
  52. 第一本书标题 : C++ 教程
  53. 第一本书作者 : 一缕清风
  54. 第一本书类目 : 编程语言
  55. 第一本书 ID : 123456
  57. 第二本书标题 : CSS 教程
  58. 第二本书作者 : 一缕清风
  59. 第二本书类目 : 前端技术
  60. 第二本书 ID : 123457
  62. 第一本书作者 : Kebguba
  63. 第二本书作者 : Kebguba
  64. */

结构作为函数参数 (传值形式)

您可以把结构作为函数参数，传参方式与其他类型的变量或指针类似。您可以使用上面实例中的方式来访问结构变量：

  1. #include <iostream>
  2. #include <cstring>
  4. using namespace std;
  5. void printBook(struct Books book);
  7. // 声明一个结构体类型 Books
  8. struct Books
  9. {
  10.   char title[50];
  11.   char author[50];
  12.   char subject[100];
  13.   int book_id;
  14. };
  16. int main()
  17. {
  18.   Books book1; // 定义结构体类型 Books 的变量 book1
  19.   Books book2; // 定义结构体类型 Books 的变量 book2
  21.   // book1 详述
  22.   strcpy(book1.title, "C++ 教程");
  23.   strcpy(book1.author, "一缕清风");
  24.   strcpy(book1.subject, "编程语言");
  25.   book1.book_id = 123456;
  27.   // book2 详述
  28.   strcpy(book2.title, "CSS 教程");
  29.   strcpy(book2.author, "一缕清风");
  30.   strcpy(book2.subject, "前端技术");
  31.   book2.book_id = 123457;
  33.   printBook(book1); // 输出 book1 信息
  34.   printBook(book2); // 输出 book2 信息
  36.   cout << "书作者 : " << book1.author << endl; //一缕清风
  37.   cout << "书作者 : " << book2.author << endl; //一缕清风
  38.   return 0;
  39. }
  41. void printBook(struct Books book)
  42. {
  43.   cout << "书标题 : " << book.title << endl;
  44.   cout << "书作者 : " << book.author << endl;
  45.   cout << "书类目 : " << book.subject << endl;
  46.   cout << "书 ID : " << book.book_id << endl;
  47.   strcpy(book.author, "Kenguba");
  48.   cout << "书作者 : " << book.author << endl; //Kenguba
  49. }
  51. /* 
  52. 书标题 : C++ 教程
  53. 书作者 : 一缕清风
  54. 书类目 : 编程语言
  55. 书 ID : 123456
  56. 书作者 : Kenguba
  58. 书标题 : CSS 教程
  59. 书作者 : 一缕清风
  60. 书类目 : 前端技术
  61. 书 ID : 123457
  62. 书作者 : Kenguba
  64. 书作者 : 一缕清风
  65. 书作者 : 一缕清风
  66. */

指向结构的指针 (地址传递)

您可以定义指向结构的指针，方式与定义指向其他类型变量的指针相似，如下所示：

  1. struct Books *struct_pointer;

现在，您可以在上述定义的指针变量中存储结构变量的地址。为了查找结构变量的地址，请把 & 运算符放在结构名称的前面，如下所示：

  1. struct_pointer = &Book1;

为了使用指向该结构的指针访问结构的成员，您必须使用 -> 运算符，如下所示：

  1. struct_pointer->title;

让我们使用结构指针来重写上面的实例，这将有助于您理解结构指针的概念：

  1. #include <iostream>
  2. #include <cstring>
  3. using namespace std;
  5. void printBook(struct Books *book);
  7. struct Books
  8. {
  9.   char title[50];
  10.   char author[50];
  11.   string subject;
  12.   int book_id;
  13. };
  15. int main()
  16. {
  17.   struct Books book1 = {"C++ 教程", "Runoob", "编程语言", 12345};
  19.   Books book2;
  20.   strcpy(book2.title, "CSS 教程");
  21.   strcpy(book2.author, "Runoob");
  22.   book2.subject = "前端技术";
  23.   book2.book_id = 12346;
  25.   printBook(&book1); // 通过传 book1 的地址来输出 book1 信息
  26.   printBook(&book2); // 通过传 book2 的地址来输出 book2 信息
  28.   cout << "书作者 : " << book1.author << endl; //Kenguba
  29.   cout << "书作者 : " << book2.author << endl; //Kenguba
  31.   return 0;
  32. }
  34. // 该函数以结构指针作为参数
  35. void printBook(struct Books *book)
  36. {
  37.   cout << "书标题  : " << book->title << endl;
  38.   cout << "书作者 : " << book->author << endl;
  39.   cout << "书类目 : " << book->subject << endl;
  40.   cout << "书 ID : " << book->book_id << endl;
  41.   strcpy(book->author, "Kenguba");
  42.   cout << "书作者 : " << book->author << endl; //Kenguba
  43. }
  45. /* 
  46. 书标题  : C++ 教程
  47. 书作者 : Runoob
  48. 书类目 : 编程语言
  49. 书 ID : 12345
  50. 书作者 : Kenguba
  52. 书标题  : CSS 教程
  53. 书作者 : Runoob
  54. 书类目 : 前端技术
  55. 书 ID : 12346
  56. 书作者 : Kenguba
  58. 书作者 : Kenguba
  59. 书作者 : Kenguba
  60. */

结构体数组

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  5. struct Student
  6. {
  7.   string name; //姓名
  8.   int age;     //年龄
  9.   int score;   //分数
  10. };
  12. typedef struct Stu
  13. {
  14.   string name; //姓名
  15.   int age;     //年龄
  16.   int score;   //分数
  17. } S;
  19. int main(int argc, char const *argv[])
  20. {
  21.   Student s1; //可以省略struct
  22.   s1.name = "一缕清风";
  23.   s1.age = 18;
  24.   s1.score = 99;
  25.   cout << s1.age << "岁的" << s1.name << "的分数是" << s1.score << endl;
  27.   S arr[3] = {
  28.       {"张三", 18, 80},
  29.       {"李四", 32, 92},
  30.       {"王五", 14, 100},
  31.   };
  33.   arr[0].name = "一缕清风"; //修改结构体数组的某项名字的值
  35.   for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
  36.   {
  37.     cout << arr[i].name + "\t" << arr[i].age << "\t" << arr[i].score << endl;
  38.   }
  39. }
  41. /* 
  42. 一缕清风        18       80
  43. 李四           32       92
  44. 王五           14       100 
  45. */

typedef 关键字

下面是一种更简单的定义结构的方式，您可以为创建的类型取一个”别名”。例如：

  1. typedef struct Books
  2. {
  3.    char  title[50];
  4.    char  author[50];
  5.    char  subject[100];
  6.    int   book_id;
  7. } Books;

现在，您可以直接使用Books来定义Books类型的变量，而不需要使用 struct 关键字。下面是实例：

  1. Books Book1, Book2;

您可以使用typedef关键字来定义非结构类型，如下所示：

  1. typedef long int *pint32;
  2. pint32 x, y, z;

x, y 和 z 都是指向长整型 long int 的指针。