＜C++＞ 结构体 的全角度解答

从六月一号放暑假到现在已经摆烂一阵子了，今天起呢小鸣人就开始学习C++了，会持续输出有关C++的文章，有什么学习C++的建议呢可以评论或者私信，小鸣人感谢诸佬的帮助！

本文收录于专栏：【大战C++】
专栏目的是对于C++的讲解，重点的逐个击破，会持续输出，欢迎免费订阅！！

✨你本该闪亮✨

---

结构体

一、概述

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型

定义

语法：
struct 结构体名 { 结构体成员列表 }；

创建结构体变量有三种方式：
1.struct 结构体名 变量名
2.struct 结构体名 变量名 = { 成员值1 ， 成员值2…}
3.定义结构体时创建变量

代码如下：

    //定义
    struct student
    {
    	//成员列表
    	string name;  //姓名
    	int age;      //年龄
    	int score;    //分数
    }stu3; //结构体变量创建方式3 
    
    int main() {
    
    	//结构体变量创建方式1
    	struct student stu1; //struct 关键字可以省略
    
    	stu1.name = "张三";
    	stu1.age = 18;
    	stu1.score = 100;
    	
    	cout << "姓名：" << stu1.name << " 年龄：" << stu1.age  << " 分数：" << stu1.score << endl;
    
    	//结构体变量创建方式2
    	struct student stu2 = { "李四",19,60 };
    
    	cout << "姓名：" << stu2.name << " 年龄：" << stu2.age  << " 分数：" << stu2.score << endl;
    	stu3.name = "王五";
    	stu3.age = 18;
    	stu3.score = 80;
    	
    	cout << "姓名：" << stu3.name << " 年龄：" << stu3.age  << " 分数：" << stu3.score << endl;
    	system("pause");
    	return 0;
    }

补充：

1. 结构体变量创建方式3 定义之后不能再定义其他变量
2. 定义结构体时的关键字是struct，不可省略
3. 创建结构体变量时，关键字struct可以省略，
   变量用" . "小数点访问成员
4. 如果某个结构成员未被初始化，则所有跟在它后面的成员都需要保留为未初始化。使用初始化列表时，C++ 不提供跳过成员的方法

动态创建结构体变量(new)

使用new动态创建结构体变量时，必须是结构体指针类型

访问时普通结构体变量使用使用成员变量访问符"."
指针类型的结构体变量使用的成员变量访问符为"->"

案例如下：

#include 
using namespace std;

struct Student
{
    int Code;
    char Name[20];
    char Sex;
    int Age;
}Stu,StuArray[10],*pStu;

int main(){

    Student *stu = new Student();  
    // 或者Student *stu = new Student;
    
    stu->Code = 1;
    cout<<stu->Code;

    delete stu;
    return 0;
}

动态创建结构体变量使用后一定要delete

---

二、结构体数组

把我们自定义的结构体放入到数组中 方便维护

语法：struct 结构体名 数组名[元素个数] = { {} , {} , ... {} }

代码如下：

   //结构体定义
    struct student
    {
    	//成员列表
    	string name;  //姓名
    	int age;      //年龄
    	int score;    //分数
    }
    
    int main() {
    	//结构体数组
    	struct student arr[3]=
    	{
    		{"张三",18,80 },
    		{"李四",19,60 },
    		{"王五",20,70 }
    	};
    
    	for (int i = 0; i < 3; i++)
    	{
    		cout << "姓名：" << arr[i].name << " 年龄：" << arr[i].age << " 分数：" << arr[i].score << endl;
    	}
    
    	system("pause");
    
    	return 0;
    }

---

三、结构体指针

通过指针访问结构体中的成员

利用操作符 ->可以通过结构体指针访问结构体属性

代码如下：

//结构体定义
    struct student
    {
    	//成员列表
    	string name;  //姓名
    	int age;      //年龄
    	int score;    //分数
    };
    
    int main() {
    	
    	struct student stu = { "张三",18,100, };
    	
    	struct student * p = &stu;
    	
    	p->score = 80; //指针通过 -> 操作符可以访问成员
    
    	cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
    	
    	system("pause");
    
    	return 0;
    }

---

四、结构体嵌套

结构体中的成员是另一个结构体
就像：一个类的对象可以嵌套在另一个类中一样

例如：每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体

举例：Costs 结构体有两个 double 类型成员，wholesale 和 retail。Item 结构体有 3 个成员，前 2 个是 partNum 和 description，它们都是 string 对象。第 3 个是 pricing，它是一个嵌套的 Costs 结构体。如果定义了一个名为 widge t的 Item 结构体：下图就是结构图

定义代码：

struct Costs
{
    double wholesale;
    double retail;
};

struct Item
{
    string partNum;
    string description;
    Costs pricing;
};

访问顺序可以是：

widget.partnum = "123A";
widget.description = "iron widget";
widget.pricing.wholesale = 100.0;
widget.pricing.retail = 150.0;

这里wholesale 和 retail 不是 widget 的成员，pricing 才是。要访问 wholesale 和 retail，必须首先访问 widget 的定价 pricing

---

五、结构体函数参数

将结构体作为参数向函数中传递

三种结构体初始化方法：
1. 利用结构体自带的默认构造函数
2. 利用带参数的构造函数
3. 利用默认无参的构造函数

struct node{
    int data;
    string str;
    char x;
    //注意构造函数最后这里没有分号的
  node() :x(), str(), data(){} 
  //无参数的构造函数数组初始化时调用，使用的是结构体自带的默认构造函数
  node(int a, string b, char c) :data(a), str(b), x(c){}//有参构造
};

传递方式

有两种：
●值传递
●地址传递

举例：

    //学生结构体定义
    struct student
    {
    	//成员列表
    	string name;  //姓名
    	int age;      //年龄
    	int score;    //分数
    };
    
    //值传递
    void printStudent(student stu )
    {
    	stu.age = 28;
    	cout << "子函数中 姓名：" << stu.name << " 年龄： " << stu.age  << " 分数：" << stu.score << endl;
    }
    
    //地址传递
    void printStudent2(student *stu)
    {
    	stu->age = 28;
    	cout << "子函数中 姓名：" << stu->name << " 年龄： " << stu->age  << " 分数：" << stu->score << endl;
    }
    
    int main() {
    
    	student stu = { "张三",18,100};
    	//值传递
    	printStudent(stu);
    	cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age << " 分数：" << stu.score << endl;
    
    	cout << endl;
    
    	//地址传递
    	printStudent2(&stu);
    	cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age  << " 分数：" << stu.score << endl;
    
    	system("pause");
    
    	return 0;
    }

总结：如果不想修改主函数中的数据，用值传递，反之用地址传递
 
默认情况下，它们通过值传递，这意味着需要生成整个原始结构的副本并传递给函数。因为不希望浪费时间来复制整个结构体，所以，除非结构很小，否则一般会通过引用将结构体传递给函数。但是，这样意味着函数可以访问原始结构的成员变量，从而可能更改它们。如果不想让函数更改任何成员变量值，那么可以考虑将结构体变量作为一个常量引用传递给函数

六、结构体案例

案例描述：

设计一个英雄的结构体，包括成员姓名，年龄，性别;创建结构体数组，数组中存放5名英雄
通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果

五名英雄信息如下：

		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"},

代码如下：

    //英雄结构体
    struct hero
    {
    	string name;
    	int age;
    	string sex;
    };
    //冒泡排序
    void bubbleSort(hero arr[] , int len)
    {
    	for (int i = 0; i < len - 1; i++)
    	{
    		for (int j = 0; j < len - 1 - i; j++)
    		{
    			if (arr[j].age > arr[j + 1].age)
    			{
    				hero temp = arr[j];
    				arr[j] = arr[j + 1];
    				arr[j + 1] = temp;
    			}
    		}
    	}
    }
    //打印数组
    void printHeros(hero arr[], int len)
    {
    	for (int i = 0; i < len; i++)
    	{
    		cout << "姓名： " << arr[i].name << " 性别： " << arr[i].sex << " 年龄： " << arr[i].age << endl;
    	}
    }
    
    int main() {
    
    	struct hero arr[5] =
    	{
    		{"刘备",23,"男"},
    		{"关羽",22,"男"},
    		{"张飞",20,"男"},
    		{"赵云",21,"男"},
    		{"貂蝉",19,"女"},
    	};
    
    	int len = sizeof(arr) / sizeof(hero); //获取数组元素个数
    
    	bubbleSort(arr, len); //排序
    
    	printHeros(arr, len); //打印
    
    	system("pause");
    
    	return 0;
    }

---

看完康师傅来看黑马，冲冲冲！