C++学习笔记（五）函数、指针、指针和数组、指针和函数、结构体、结构体数组、结构体指针、结构体嵌套、结构体做函数参数、结构体与const

一、函数

1.函数的定义

语法：

返回值类型 函数名 （参数1，参数2，...）
{
	函数体语句；
	return表达式；
}

#注意
（1）如果没有返回值类型，用void代表无类型
（2）如果没有返回值，return；即可
代码：

int add(int num1, int num2)//函数定义时候，num1和num2并没有真实数据，只是一个形式上的参数，简称形参
{
	int sum = num1 + num2;
	return sum;
}

2.函数的调用

语法:

函数名称（实参）；

（1）函数定义里小括号内称为形参
（2）函数调用时传入的参数为实参
代码：

void swap(int num1, int num2)
{
	cout << "交换前：" << endl;
	cout << "num1=" << num1 << endl;
	cout << "num2=" << num2 << endl;

	//数据交换
	int temp = num1;
	num1 = num2;
	num2 = temp;

	cout << "交换后：" << endl;
	cout << "num1=" << num1 << endl;
	cout << "num2=" << num2 << endl;

	return ;//或者不写，因为void无类型，不需要返回值
}

	//函数调用
	int a_dy = 10;
	int b_dy = 20;
	
	swap(a_dy, b_dy);
	
	cout << "a_dy=" << a_dy << endl;
	cout << "b_dy=" << b_dy << endl;//值传递不影响实参的数值

3.值传递

（1）值传递就是函数调用时实参将数值传入给形参
（2）值传递时，如果形参发生变化，并不会影响实参

4.函数的常见形式

（1）无参无返
语法：

返回值类型 函数名（）
{
	函数体语句；//无类型无参数不可以创建变量，因为无法分配内存
	return；
}

#注意：无类型无参数不可以创建变量，因为无法分配内存
代码：

//1.无参无返
void test01()
{
	cout << "this is test01" << endl;
	return;
}

main函数：

//无参无返
test01();

（2）有参无返
语法：

返回值类型 函数名（参数1，参数2，...）
{
	函数体语句；
	return；
}

代码：

//2.有参无返
void test02(int a)
{
	cout << "this is test02 a=" << a << endl;
	return;
}

main函数：

//有参无返
test02(100);

（3）无参有返
语法：

返回值类型 函数名称（）
{
	函数体语句；
	return表达式；
}

代码：

//3.无参有返
int test03()
{
	cout << "this is test03" << endl;
	return 1000;
}

main函数：

	//无参有返
	int num_wcyf=test03();
	cout << "无参有返输出=" << num_wcyf << endl;

（4）有参有返
语法：

返回值类型 函数名称（参数1，参数2，...）
{
	函数体语句；
	return语句；
}

代码：

//4.有参有返
int test04(int a)
{
	cout << "this is test04 a=" << a << endl;
	return a;
}

main函数：

	//有参有返
	int num_ycyf = test04(10000);
	cout << "有参有返输出=" << num_ycyf << endl;

5.函数的声明

#注意：
（1）函数的声明可以有多次，但是函数的定义只能有一次
（2）可以利用函数的声明提前告诉编译器函数的存在，声明后可以将函数的定义放在main函数后
代码：

//提前告诉编译器函数的存在，可以利用函数的声明
int max(int a, int b);//此时可以将max定义放在main函数后
//函数声明可以有多次，但是定义只有一次
int max(int a, int b);

//定义
int max(int a, int b)
{
	return a > b ? a : b;
}

6.函数的分文件编写

步骤：

1.创建.h后缀名的头文件
2.创建.cpp后缀名的源文件
3.在头文件中写函数的声明,记得加框架#include <iostream>和using namespace std；
4.在源文件中写函数的定义，记得#include "步骤1创建的头文件"

num_jh.cpp

#include "num_jh.h" //""表示自定义的文件

//函数的定义
void num_jh(int a, int b)
{
	int temp = a;
	b = a;
	a = temp;

	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
}

num_jh.h

#include 
using namespace std;

//函数的声明
void num_jh(int a, int b);

在main的.cpp中加入相应的头文件#include num_jh.h即可调用相应函数
main函数：

	#include num_jh.h
	
	//函数的分文件编写
	int a_fwj = 10;
	int b_fwj = 20;
	num_jh(a_fwj, b_fwj);//调用了头文件num_jh.h

二、指针

1.指针变量的定义和使用

语法：

数据类型 * 指针变量名称；

#注意
（1）指针就是一个地址，可以通过指针间接访问内存
（2）内存编号从0开始记录，一般用16进制表示
（3）普通变量存放的是数据，指针变量存放的是地址
（4）指针变量名称=&变量名称；指向变量的地址
通过&来获取变量的地址
（5）* 指针变量名称指向变量的内存
通过*来解引用
代码：

//1.定义一个指针
int a_zz = 10;

//指针定义的语法：数据类型 * 指针变量名称；
int * p;

//让指针记录变量a的地址
p = &a_zz;//&取址符号  或者直接int * p = &a_zz;
cout << "a的地址为：" << &a << endl;
cout << "指针p为：" << p << endl;

//2.使用指针
//可以通过解引用的方式来找到指针指向的内存
//指针前加 * 代表解引用，找到指针指向的内存  比如：*p
cout << "a_zz=" << a_zz << endl;
cout << "*p=" << *p << endl;

*p = 1000;//指针变量p指向储存在内存中a_zz的数值，并将a_zz赋值1000
cout << "a_zz=" << a_zz << endl;//输出1000
cout << "*p=" << *p << endl;//输出1000

2.指针所占内存空间

语法：

sizeof(int/float/double/char *或者指针变量名）

#注意：
所有指针在32位操作系统下都是4个字节，64位下占8个字节
代码：

//指针所占的内存空间 sizeof(int/float/double/char *或者指针变量名）
//所有指针在32位操作系统下都是4个字节，64位下占8个字节
cout << "sizeof(int *)=" << sizeof(int *) << endl;
cout << "sizeof(p)=" << sizeof(p) << endl;
cout << "sizeof(float *)=" << sizeof(float *) << endl;
cout << "sizeof(double *)=" << sizeof(double*) << endl;
cout << "sizeof(char *)=" << sizeof(char *) << endl;

3.空指针

空指针：指针变量指向内存中编号为0的空间
语法：

变量类型 * 指针变量名称 = NULL；

#注意
内存编号0~255为系统占用内存，不允许用户访问
代码：

//空指针：指针变量指向内存中编号为0的空间
//语法：数据类型 * 指针变量名=NULL；
//用途：初始化指针变量
//空指针指向的内存是不可以访问的，切记！
int * p_k = NULL;

//0-255之间的内存编号是系统占用的，因此不可以访问
//*p_k = 100;//错误，空指针指向的内存是不可以访问的

4.野指针

野指针：指针变量指向非法的内存空间
#注意
要访问某个内存空间要事先预定
代码：

//野指针
//野指针指向非法的内存空间
//int * p_y = (int *)0x1100;//错误，没有权限访问。要访问某个内存空间要事先预定
//空指针和野指针都不是我们申请的空间，因此不要访问。

5.const修饰指针

//把const翻译成常量，*翻译成指针
//const后面跟了啥，啥就不能改
（1）const修饰的是指针，指针指向可以改，指针指向的值不可以更改
（2）const修饰的是常量，指针指向不可以改，指针指向的值可以更改
代码：

//const修饰指针
//把const翻译成常量，*翻译成指针
//const后面跟了啥，啥就不能改

//1.const修饰指针--常量指针
int a_xs = 10;
int b_xs = 20;

const int * p_xs = &a_xs; //*p操作不能进行
//指针指向的值不可以改，指针的指向可以改
//*p_xs = 20;//错误
p_xs = &b_xs;
cout << *p_xs << endl;//输出20

//2.const修饰常量--指针常量
int *  const p_xs2 = &a_xs;//p=&a不能进行
//指针的指向不可以改，指针指向的值可以改
*p_xs2 = 100;
//p_xs2 = &b_xs;//错误，指针的指向不可以改

//3.const既修饰指针又修饰常量
const int * const p_xs3 = &a_xs;//都不可以改
//指针的指向和指针指向的值都不可以改
//*p_xs3 = 100;//错误，指针指向的值不可以改
//p_xs3 = &b_xs;//错误，指针的指向不可以改

6.指针和数组

语法：

数据类型 * 指针变量名=数组名称；

#注意：
数组名就是数组的首地址
代码：

//指针和数组
//访问数组首地址语法： 数据类型 * 指针变量名 = 数组名；
//利用指针访问数组中的元素
int arr_zz[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "第一个元素为：" << arr_zz[0] << endl;

int *p_sz = arr_zz;//数组名arr_zz就是数组的首地址
cout << "利用指针来访问第一个元素：" << *p_sz << endl;

p_sz++;//让指针向后偏移四个字节，因为p定义的是int型，int型占四个字节
cout << "利用指针来访问第二个元素：" << *p_sz << endl;

cout << "利用指针来遍历数组" << endl;
int * p_sz2 = arr_zz;
for (int i = 0; i < 10; i++)
{
	cout << *p_sz2 << endl;
	p_sz2++;
}

7.指针和函数

使用地址传递会改变实参！
代码：

void swap02(int *p1, int *p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
	return;
}

main函数：

	//指针和函数
	int a_zzhs = 10;
	int b_zzhs = 20;

	//如果是地址传递，可以改变实参
	swap02(&a_zzhs, &b_zzhs);

	cout << "a=" << a_zzhs << endl;
	cout << "b=" << b_zzhs << endl;

8.指针、数组、函数实例
代码：

//冒泡排序函数(数组的首地址，数组长度）
void bubbleSort(int * arr,int len)//int * arr也可以写成int arr[]
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

//打印数组
void printArray(int * arr, int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << endl;
	}
}

main函数：

	//案例
	//封装一个函数，利用冒泡排序，实现对整型数组的升序排序
	//1.创建数组
	int arr_al[10] = { 4,3,6,9,1,2,10,8,7,5 };
	//数组长度
	int len = sizeof(arr_al) / sizeof(arr_al[0]);

	//2.创建函数，实现冒泡排序
	bubbleSort(arr_al, len);

	//3.打印排序后的数组
	printArray(arr_al, len);

三、结构体

1.结构体定义和使用

语法：

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

通过结构体创建变量的方式有三种：

struct 结构体名 变量名 ；
struct 结构体名 变量名 = { 成员1值 ， 成员2值...} ；
定义结构体时顺便创建变

总结1：定义结构体时的关键字是struct，不可省略
总结2：创建结构体变量时，关键字struct可以省略
总结3：结构体变量利用操作符 ‘’.’’ 访问成员
代码：

//结构体
//结构体是用户自定义的数据类型，允许用户存储不同的数据类型
//语法：struct 结构体名称 {结构体成员列表}；
//1.创建学生数据类型：学生包括（姓名，年龄，分数）
//自定义数据类型，一些类型组合而成的一个类型
struct student
{
	//成员列表

	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
};

//2.通过学生类型创建具体学生
//2.1 struct student s1 //struct 结构体名称 变量名称;
//2.2 struct student s2={...}  //struct 结构体名称 变量名称={成员1值，成员2值，...};
//2.3在定义结构体时顺便创建结构体变量
//struct student
//{
//	//成员列表
//
//	//姓名
//	string name;
//	//年龄
//	int age;
//	//分数
//	int score;
//}s3;//在后面加上s3就是在定义结构体时顺便创建结构体变量

main函数：

//2.通过学生类型创建具体学生
	//2.1 struct student s1 //struct 结构体名称 变量名称;
	//struct关键字可以省略
	struct student s1;
	//给s1属性赋值，通过.来访问结构体变量中的属性
	s1.name = "张三";
	s1.age = 18;
	s1.score = 100;

	cout << "姓名：" << s1.name << "\t年龄：" << s1.age << "\t分数：" << s1.score << endl;

	//2.2 struct student s2={...}  //struct 结构体名称 变量名称={成员1值，成员2值，...};
	//struct关键字可以省略
	struct student s2 = { "李四",19,80 };//按照struct中定义的属性顺序进行赋值

	cout << "姓名：" << s2.name << "\t年龄：" << s2.age << "\t分数：" << s2.score << endl;

	//2.3在定义结构体时顺便创建结构体变量
	s3.name = "王五";
	s3.age = 20;
	s3.score = 60;

	cout << "姓名：" << s3.name << "\t年龄：" << s3.age << "\t分数：" << s3.score << endl;
	//总结1：定义结构体时的关键字是struct，不可省略
	//总结2：创建结构体变量时，关键字struct可以省略

2.结构体数组

语法：

struct 结构体名称 数组名[元素个数]=
{
	{}，
	{}，
	...
}

代码：

	//结构体数组
	struct student arr_jgsz[3]=
	{
		{"张三",18,100 },
		{"李四",60,80},
		{"王五",21,60}
	};
	
	//给结构体数组中的元素赋值
	arr_jgsz[2].name = "赵六";
	arr_jgsz[2].age =  80;
	arr_jgsz[2].score = 0;

	//遍历结构体数组
	for (int i = 0; i < 3; i++)
	{
		cout << "姓名：" << arr_jgsz[i].name << "\t年龄：" 
		<< arr_jgsz[i].age << "\t分数：" << arr_jgsz[i].score << endl;

	}

3.结构体指针

语法：

struct 结构体名称 * 指针变量名称=&结构体变量名称；
利用->访问结构体属性

代码：

main函数：

//结构体指针
	//1.创建学生结构体变量
	struct student s_jz = {"王",12,110};//struct可省略

	//2.通过指针指向结构体变量
	struct student * p_jz = &s_jz;//struct可省略

	//3.通过指针访问结构体变量中的数据
	//通过结构体指针访问结构体中的属性，需要利用->
	cout << "姓名：" << p_jz->name << "\t年龄：" << p_jz->age << "\t分数：" << p_jz->score << endl;

4.结构体嵌套结构体

//作用：结构体中的成员可以是另一个结构体
代码：

//定义老师结构体
struct teacher
{
	int id; //教师编号
	string name; //教师姓名
	int age; //教师年龄
	struct student stu;//带的学生，学生结构体
};

main函数：

	//结构体嵌套结构
	//创建老师
	struct teacher t;
	t.id = 10000;
	t.name = "老王";
	t.age = 50;
	t.stu.name = "小王"; //赋值教师结构体中的学生结构体
	t.stu.age = 20;
	t.stu.score = 110;

	cout << "老师的姓名：" << t.name << "\t老师的编号：" << t.id << "\t老师的年龄："
		<< t.age << "\n老师辅导的学生名字：" << t.stu.name << "\t学生年龄："
		<< t.stu.age << "\t学生分数：" << t.stu.score << endl;

5.结构体做函数参数

//将结构体作为参数向函数中传递
//传递方式有两种：值传递和地址传递
代码：

//将学生传入到一个参数中，打印学生身上的所有信息
//打印学生信息函数
//1.值传递
void printStudent(struct student s)
{
	cout << "子函数中 姓名：" << s.name << "\t年龄：" 
		<< s.age << "\t分数：" << s.score << endl;
	return;
}

//2.地址传递
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudent2(struct student * p)
{
	cout << "子函数2中 姓名：" << p->age << "\t年龄：" 
		<< p->age << "\t分数：" << p->score << endl;
	return;
}
//总结：如果不想修改主函数中的数据，用值传递，反之用地址传递

main函数：

	//将学生传入到一个参数中，打印学生身上的所有信息
	//创建结构体变量
	struct student s_hs;
	s_hs.name = "函数";
	s_hs.age = 22;
	s_hs.score = 410;

	printStudent(s_hs);
	printStudent2(&s_hs);
	cout << "main函数中打印 姓名：" << s_hs.name << "\t年龄：" 
	<< s_hs.age << "\t分数：" << s_hs.score << endl;

6.结构体中的const

用const来防止误操作
代码：

//const的使用场景
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudent2(const struct student * p)
{
	//p->age = 1000;//加入const以后，一旦有修改的操作就会报错，可以防止我们的误操作
	cout << "子函数2中 姓名：" << p->age << "\t年龄："
		<< p->age << "\t分数：" << p->score << endl;
	return;
}

main函数：

	//const的使用场景
	struct student s_cst = { "张三",15,70 };

	//通过函数打印结构体变量信息
	printStudent2(&s_cst);

7.结构体案例1

代码：

//实例1
//学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下
//设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员
//学生的成员有姓名、考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值
//最终打印出老师数据以及老师所带的学生数据。

//学生的结构体
struct Student
{
	//姓名
	string sName;
	//分数
	int score;
};

//老师的结构体
struct Teacher
{
	//姓名
	string tName;
	//学生数组
	struct Student sArray[5];
};

//给老师和学生赋值的函数
void allocateSpace(struct Teacher tArray[],int len) //传入数组和长度
{
	string nameSeed = "ABCDE";
	//给老师开始赋值
	for(int i = 0; i < len; i++)
	{
		tArray[i].tName = "Teacher_";
		tArray[i].tName += nameSeed[i];

		//通过循环给每名老师所带的学生赋值
		for (int j = 0; j < 5; j++)
		{
			tArray[i].sArray[j].sName = "Student_";
			tArray[i].sArray[j].sName += nameSeed[j];

			int random = rand() % 61+40;//0~60分+40分=40~100分
			tArray[i].sArray[j].score = random;
		}
	}
}

//打印所有信息的函数
void printInfo(struct Teacher tArray[],int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << "老师的姓名：" << tArray[i].tName << endl;
		
		for (int j = 0; j < 5; j++)
		{
			cout << "\t学生的姓名：" << tArray[i].sArray[j].sName 
				<< "\t学生的分数：" << tArray[i].sArray[j].score << endl;
		}
	}
}

main函数：

//实例1
	
	//随机数种子
	srand((unsigned int)time (NULL));

	//1.创建三名老师的数组
	struct Teacher tArray[3];

	//2.通过函数给三名老师的信息赋值，并给老师带的学生信息赋值
	int len_t = sizeof(tArray) / sizeof(tArray[0]);
	allocateSpace(tArray, len_t); //数组名和长度

	//3.打印所有老师及所带学生的信息
	printInfo(tArray, len_t);

8.结构体案例2

代码：

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

//1.设计英雄的结构体
struct hero
{
	string name;
	int age;
	string sex;
};

//冒泡排序实现年龄升序排列
void bubbleSort_hero(struct hero heroArray[], int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			//如果j下标的元素年龄大于j+1下标的元素年龄，交换两个元素
			if (heroArray[j].age > heroArray[j + 1].age)
			{
				struct hero temp = heroArray[j];
				heroArray[j] = heroArray[j + 1];
				heroArray[j + 1] = temp;
			}
		}
	}
	return;
}

//打印排序后数组中的信息
void printhero(struct hero heroArray[], int len)
{
	cout << "排序后的：" << endl;

	for (int i = 0; i < len; i++)
	{
		cout << "姓名：" << heroArray[i].name
			<< "\t年龄：" << heroArray[i].age
			<< "\t性别：" << heroArray[i].sex << endl;
	}
}

main函数：

	//实例2

	//2.创建数组存放五名英雄
	struct hero heroArray[5] =
	{
		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"}
	};

	int len_hero = sizeof(heroArray) / sizeof(heroArray[0]);
	for (int i = 0; i < len_hero; i++)
	{
		cout << "姓名：" << heroArray[i].name
			<< "\t年龄：" << heroArray[i].age
			<< "\t性别：" << heroArray[i].sex << endl;
	}

	//3.对数组进行排序，按照年龄进行升序排列
	bubbleSort_hero(heroArray, len_hero);

	//4.将排序后的结果打印输出
	printhero(heroArray, len_hero);

9.代码

#include 
#include  //用c++风格字符串时候，要包含这个头文件
#include  //time系统时间头文件包含
#include "num_jh.h"//这是自己创建的头文件


using namespace std;

//常量的定义方式
//1.#define 宏常量   #define 常量名 常量值    比如：#define Day 7
//2.const 数据类型 常量名 = 常量值;

//标识符的命名规则
//1.标识符不可以是关键字
//2.标识符由字母、数字、下划线构成
//3.标识符开头不能是数字，只能字母或下划线
//4.标识符中区分大小写

#define Day 7

//函数
/*语法：
返回值类型 函数名 （参数列表）
{
	函数体语句；
	return表达式；
}
*/
//加法函数，实现两个整型相加，并将相加的结果返回
int add(int num1, int num2)//函数定义时候，num1和num2并没有真实数据，只是一个形式上的参数，简称形参
{
	int sum = num1 + num2;
	return sum;
}


//值传递
//值传递就是函数调用时实参将数值传入给形参
//值传递时，如果形参发生任何改变，并不会影响实参

//如果函数不需要返回值，声明的时候可以写void，代表无类型
void swap(int num1, int num2)
{
	cout << "交换前：" << endl;
	cout << "num1=" << num1 << endl;
	cout << "num2=" << num2 << endl;

	//数据交换
	int temp = num1;
	num1 = num2;
	num2 = temp;

	cout << "交换后：" << endl;
	cout << "num1=" << num1 << endl;
	cout << "num2=" << num2 << endl;

	return ;//或者不写，因为void无类型，不需要返回值
}

void swap02(int *p1, int *p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
	return;
}



//函数的常见样式
//1.无参无返
void test01()
{
	cout << "this is test01" << endl;
	return;
}


//2.有参无返
void test02(int a)
{
	cout << "this is test02 a=" << a << endl;
	return;
}

//3.无参有返
int test03()
{
	cout << "this is test03" << endl;
	return 1000;
}

//4.有参有返
int test04(int a)
{
	cout << "this is test04 a=" << a << endl;
	return a;
}


//函数的声明
//作用：告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义
//比较函数，实现两个整型数字进行比较，返回较大的值

//提前告诉编译器函数的存在，可以利用函数的声明
int max(int a, int b);//此时可以将max定义放在main函数后
//函数声明可以有多次，但是定义只有一次
int max(int a, int b);

//定义
int max(int a, int b)
{
	return a > b ? a : b;
}


//函数的分文件编写
//实现两个数字进行交换的函数
//函数的声明
//void num_jh(int a, int b);
////函数的定义
//void num_jh(int a, int b)
//{
//	int temp = a;
//	b = a;
//	a = temp;
//
//	cout << "a=" << a << endl;
//	cout << "b=" << b << endl;
//}
//1.创建.h后缀名的头文件
//2.创建.cpp后缀名的源文件
//3.在头文件中写函数的声明,记得加框架#include 和using namespace std；
//4.在源文件中写函数的定义，记得#include "步骤1创建的头文件"


//冒泡排序函数(数组的首地址，数组长度）
void bubbleSort(int * arr,int len)//int * arr也可以写成int arr[]
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

//打印数组
void printArray(int * arr, int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << endl;
	}
}


//结构体
//结构体是用户自定义的数据类型，允许用户存储不同的数据类型
//语法：struct 结构体名称 {结构体成员列表}；
//1.创建学生数据类型：学生包括（姓名，年龄，分数）
//自定义数据类型，一些类型组合而成的一个类型
struct student
{
	//成员列表

	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
};

//2.通过学生类型创建具体学生
//2.1 struct student s1 //struct 结构体名称 变量名称;
//2.2 struct student s2={...}  //struct 结构体名称 变量名称={成员1值，成员2值，...};
//2.3在定义结构体时顺便创建结构体变量
//struct student
//{
//	//成员列表
//
//	//姓名
//	string name;
//	//年龄
//	int age;
//	//分数
//	int score;
//}s3;//在后面加上s3就是在定义结构体时顺便创建结构体变量


//结构体数组
//作用：将自定义的结构体放入到数组中方便维护
//语法：struct 结构体名 数组名[元素个数]={ {},{},... };


//结构体指针
//语法：struct 结构体名称 * 指针变量名称=&结构体变量名称；
//通过指针访问结构体中的成员
//利用操作符-> 可以通过结构体指针访问结构体属性


//结构体嵌套结构体
//作用：结构体中的成员可以是另一个结构体
//比如：每个老师辅导一个学生，一个老师的结构体中，记录一个学生的结构体

//定义老师结构体
struct teacher
{
	int id; //教师编号
	string name; //教师姓名
	int age; //教师年龄
	struct student stu;//带的学生，学生结构体
};



//结构体做函数参数
//将结构体作为参数向函数中传递
//传递方式有两种：值传递和地址传递
//将学生传入到一个参数中，打印学生身上的所有信息
//打印学生信息函数
//1.值传递
void printStudent(struct student s)
{
	cout << "子函数中 姓名：" << s.name << "\t年龄：" 
		<< s.age << "\t分数：" << s.score << endl;
	return;
}

/*
//2.地址传递
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudent2(struct student * p)
{
	cout << "子函数2中 姓名：" << p->age << "\t年龄：" 
		<< p->age << "\t分数：" << p->score << endl;
	return;
}
//总结：如果不想修改主函数中的数据，用值传递，反之用地址传递
*/


//const的使用场景
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudent2(const struct student * p)
{
	//p->age = 1000;//加入const以后，一旦有修改的操作就会报错，可以防止我们的误操作
	cout << "子函数2中 姓名：" << p->age << "\t年龄："
		<< p->age << "\t分数：" << p->score << endl;
	return;
}


//实例1
//学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下
//设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员
//学生的成员有姓名、考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值
//最终打印出老师数据以及老师所带的学生数据。

//学生的结构体
struct Student
{
	//姓名
	string sName;
	//分数
	int score;
};

//老师的结构体
struct Teacher
{
	//姓名
	string tName;
	//学生数组
	struct Student sArray[5];
};

//给老师和学生赋值的函数
void allocateSpace(struct Teacher tArray[],int len) //传入数组和长度
{
	string nameSeed = "ABCDE";
	//给老师开始赋值
	for(int i = 0; i < len; i++)
	{
		tArray[i].tName = "Teacher_";
		tArray[i].tName += nameSeed[i];

		//通过循环给每名老师所带的学生赋值
		for (int j = 0; j < 5; j++)
		{
			tArray[i].sArray[j].sName = "Student_";
			tArray[i].sArray[j].sName += nameSeed[j];

			int random = rand() % 61+40;//0~60分+40分=40~100分
			tArray[i].sArray[j].score = random;
		}
	}
}

//打印所有信息的函数
void printInfo(struct Teacher tArray[],int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << "老师的姓名：" << tArray[i].tName << endl;
		
		for (int j = 0; j < 5; j++)
		{
			cout << "\t学生的姓名：" << tArray[i].sArray[j].sName 
				<< "\t学生的分数：" << tArray[i].sArray[j].score << endl;
		}
	}
}



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

//1.设计英雄的结构体
struct hero
{
	string name;
	int age;
	string sex;
};

//冒泡排序实现年龄升序排列
void bubbleSort_hero(struct hero heroArray[], int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			//如果j下标的元素年龄大于j+1下标的元素年龄，交换两个元素
			if (heroArray[j].age > heroArray[j + 1].age)
			{
				struct hero temp = heroArray[j];
				heroArray[j] = heroArray[j + 1];
				heroArray[j + 1] = temp;
			}
		}
	}
	return;
}

//打印排序后数组中的信息
void printhero(struct hero heroArray[], int len)
{
	cout << "排序后的：" << endl;

	for (int i = 0; i < len; i++)
	{
		cout << "姓名：" << heroArray[i].name
			<< "\t年龄：" << heroArray[i].age
			<< "\t性别：" << heroArray[i].sex << endl;
	}
}


int main()
{	
	//实例2

	//2.创建数组存放五名英雄
	struct hero heroArray[5] =
	{
		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"}
	};

	int len_hero = sizeof(heroArray) / sizeof(heroArray[0]);
	for (int i = 0; i < len_hero; i++)
	{
		cout << "姓名：" << heroArray[i].name
			<< "\t年龄：" << heroArray[i].age
			<< "\t性别：" << heroArray[i].sex << endl;
	}

	//3.对数组进行排序，按照年龄进行升序排列
	bubbleSort_hero(heroArray, len_hero);

	//4.将排序后的结果打印输出
	printhero(heroArray, len_hero);
	
	
	
	//实例1
	
	//随机数种子
	srand((unsigned int)time (NULL));

	//1.创建三名老师的数组
	struct Teacher tArray[3];

	//2.通过函数给三名老师的信息赋值，并给老师带的学生信息赋值
	int len_t = sizeof(tArray) / sizeof(tArray[0]);
	allocateSpace(tArray, len_t); //数组名和长度

	//3.打印所有老师及所带学生的信息
	printInfo(tArray, len_t);


	//const的使用场景
	struct student s_cst = { "张三",15,70 };

	//通过函数打印结构体变量信息
	printStudent2(&s_cst);
	
	
	//将学生传入到一个参数中，打印学生身上的所有信息
	//创建结构体变量
	struct student s_hs;
	s_hs.name = "函数";
	s_hs.age = 22;
	s_hs.score = 410;

	printStudent(s_hs);
	printStudent2(&s_hs);
	//cout << "main函数中打印 姓名：" << s_hs.name << "\t年龄：" 
	//	<< s_hs.age << "\t分数：" << s_hs.score << endl;

	
	
	//结构体嵌套结构
	//创建老师
	struct teacher t;
	t.id = 10000;
	t.name = "老王";
	t.age = 50;
	t.stu.name = "小王"; //赋值教师结构体中的学生结构体
	t.stu.age = 20;
	t.stu.score = 110;

	cout << "老师的姓名：" << t.name << "\t老师的编号：" << t.id << "\t老师的年龄："
		<< t.age << "\n老师辅导的学生名字：" << t.stu.name << "\t学生年龄："
		<< t.stu.age << "\t学生分数：" << t.stu.score << endl;
		
	
	//结构体指针
	//1.创建学生结构体变量
	struct student s_jz = {"王",12,110};//struct可省略

	//2.通过指针指向结构体变量
	struct student * p_jz = &s_jz;//struct可省略

	//3.通过指针访问结构体变量中的数据
	//通过结构体指针访问结构体中的属性，需要利用->
	cout << "姓名：" << p_jz->name << "\t年龄：" << p_jz->age << "\t分数：" << p_jz->score << endl;

	
	//结构体数组
	struct student arr_jgsz[3]=
	{
		{"张三",18,100 },
		{"李四",60,80},
		{"王五",21,60}
	};
	
	//给结构体数组中的元素赋值
	arr_jgsz[2].name = "赵六";
	arr_jgsz[2].age =  80;
	arr_jgsz[2].score = 0;

	//遍历结构体数组
	for (int i = 0; i < 3; i++)
	{
		cout << "姓名：" << arr_jgsz[i].name << "\t年龄：" 
		<< arr_jgsz[i].age << "\t分数：" << arr_jgsz[i].score << endl;

	}
	
	
	
	/*
	//2.通过学生类型创建具体学生
	//2.1 struct student s1 //struct 结构体名称 变量名称;
	//struct关键字可以省略
	struct student s1;
	//给s1属性赋值，通过.来访问结构体变量中的属性
	s1.name = "张三";
	s1.age = 18;
	s1.score = 100;

	cout << "姓名：" << s1.name << "\t年龄：" << s1.age << "\t分数：" << s1.score << endl;

	//2.2 struct student s2={...}  //struct 结构体名称 变量名称={成员1值，成员2值，...};
	//struct关键字可以省略
	struct student s2 = { "李四",19,80 };//按照struct中定义的属性顺序进行赋值

	cout << "姓名：" << s2.name << "\t年龄：" << s2.age << "\t分数：" << s2.score << endl;

	//2.3在定义结构体时顺便创建结构体变量
	//s3.name = "王五";
	//s3.age = 20;
	//s3.score = 60;

	//cout << "姓名：" << s3.name << "\t年龄：" << s3.age << "\t分数：" << s3.score << endl;
	//总结1：定义结构体时的关键字是struct，不可省略
	//总结2：创建结构体变量时，关键字struct可以省略
	*/
	
	
	
	//案例
	//封装一个函数，利用冒泡排序，实现对整型数组的升序排序
	//1.创建数组
	int arr_al[10] = { 4,3,6,9,1,2,10,8,7,5 };
	//数组长度
	int len = sizeof(arr_al) / sizeof(arr_al[0]);

	//2.创建函数，实现冒泡排序
	bubbleSort(arr_al, len);

	//3.打印排序后的数组
	printArray(arr_al, len);
	

	//函数的分文件编写
	int a_fwj = 10;
	int b_fwj = 20;
	num_jh(a_fwj, b_fwj);//调用了头文件num_jh.h
	
	//函数的声明
	int a_sm = 10;
	int b_sm = 20;
	cout << max(a_sm, b_sm) << endl;

	//函数常见的样式
	//无参无返
	test01();
	//有参无返
	test02(100);
	//无参有返
	int num_wcyf=test03();
	cout << "无参有返输出=" << num_wcyf << endl;
	//有参有返
	int num_ycyf = test04(10000);
	cout << "有参有返输出=" << num_ycyf << endl;

	//函数调用
	int a_dy = 10;
	int b_dy = 20;
	
	swap(a_dy, b_dy);
	
	cout << "a_dy=" << a_dy << endl;
	cout << "b_dy=" << b_dy << endl;//值传递不影响实参的数值
	
	
	//指针和函数
	int a_zzhs = 10;
	int b_zzhs = 20;

	//如果是地址传递，可以改变实参
	swap02(&a_zzhs, &b_zzhs);

	cout << "a=" << a_zzhs << endl;
	cout << "b=" << b_zzhs << endl;

	
	//整型
	//1.短整型 -32768~32767
	short num1 = 10;
	//short num1 = 32769;//错误，超出最大范围，运行出来的数字有问题！
	//2.整型
	int num2 = 20;
	//3.长整型
	long num3 = 30;
	//4.长长整型
	long long num4 = 40;
	cout << "Number1=" << num1 << endl;
	cout << "Number2=" << num2 << endl;
	cout << "Number3=" << num3 << endl;
	cout << "Number4=" << num4 << endl;
	//用sizeof来求出数据类型占用内存大小
	//语法：  sizeof(数据类型或者变量名）  
	//short占2个字节，int占4个字节
	//long在windows系统占4个字节，long在linux（32位）占4个字节，在linux（64）占8个字节
	//long long占8个字节
	//整型所占字节数大小比较：short <= int <= long <= long long
	cout << "short占用内存空间为" << sizeof(short) << endl;
	cout << "定义为short类型的num1占用内存空间为" << sizeof(num1) << endl;
	cout << "int占用内存空间为" << sizeof(int) << endl;
	cout << "定义为int类型的num2占用内存空间为" << sizeof(num2) << endl;
	cout << "long占用内存空间为" << sizeof(long) << endl;
	cout << "定义为long类型的num3占用内存空间为" << sizeof(num3) << endl;
	cout << "long long占用内存空间为" << sizeof(long long) << endl;
	cout << "定义为long long类型的num4占用内存空间为" << sizeof(num4) << endl;



	//实型（浮点型）  有效数字个数不光是指小数点后，小数点前也算。比如3.14是三位有效数字
	//1.单精度 float 占用4个字节，有效数字7位
	//2.双精度 double 占用8个字节，有效数字15-16位
	float f1 = 3.14;//正确，如果直接是3.14的话，编译器会将所有小数默认是double双精度的，这里编译器认为将双精度转换为单精度并赋值给f1
	float f2 = 3.15f;//正确，这样是直接告诉编译器3.15是个单精度的，然后把单精度3.15赋给单精度f2
	cout << f1 << " " << f2 << endl;
	double f3 = 3.1415926;
	cout << f3 << endl; //输出3.14159   默认情况下，输出一个小数只显示6位有效数字
	//统计 float、double占用内存空间
	cout << "float占用内存空间为" << sizeof(float) << endl;
	cout << "double占用内存空间为" << sizeof(double) << endl;
	//科学计数法
	float f4 = 3e2;//3*10^2
	cout << f4 << endl;
	float f5 = 3e-2; //3*10^(-2)
	cout << f5 << endl;


	//int int=10; //错误，标识符不可以是关键字
	int abc = 10; //标识符由字母、数字、下划线组成
	int _abc = 20;
	int _123 = 30;
	//int 123_abc = 40; //错误，标识符开头不能是数字
	int aaa = 10;
	cout << aaa << endl;
	//cout << AAA << endl; //错误，标识符区分大小写
	//建议：给变量起名的时候，最好能够做到见名知意
	int sum_abc__abc = abc + _abc;
	cout << sum_abc__abc << endl;


	//变量创建的语法：数据类型 变量名 = 变量初始值;
	//不要用关键字给变量或者常量起名称

	//int int = 10;//错误，第二个int是关键字，不可以作为变量的名称

	int a = 10;

	const int month = 12;

	//month = 24; //错误，const定义的是常量，一旦修改就会报错！



	//1.字符型变量创建方式： char 字符型变量名称 = '单个字符';
	//注意用单引号！单引号！单引号！单引号内只能是一个字符！
	char ch = 'a';
	//char ch = 100;//正确，此时cout输出100，其实=‘a’将对应字符的ASCII码赋给变量，直接用ASCII码赋值是一样的。
	//ch = 100; //正确，此时cout输出100，可以直接用ASCII码给字符型变量赋值
	//char ch = "b"; //错误，不能使用双引号，一定要用单引号！
	//char ch = 'abc'; //错误，会溢出，运行结果是c
	cout << ch << endl;
	//2.字符型变量所占内存大小  sizeof（char或者字符变量名称）
	cout << "char所占内存大小为" << sizeof(char) << endl;
	cout << "定义为char字符型的变量ch所占内存大小为" << sizeof(ch) << endl;
	//3.字符型变量对应ASCII码
	cout << (int)ch << endl;//通过将字符型变量强制转换成整型，用十进制表示出来
	//字符型变量并不是将字符本身存储到内存中，而是将字符对应的ASCII码存储到内存中
	//a对应ASCII码97.A对应ASCII码65


	//转义字符:换行符\n   反斜杠符\\   水平制表符\t
	cout << "Hello world\n";// cout << "Hello world\n";等价于cout << "Hello world" << endl;
	cout << "\\" << endl;//要输出\，得需要\\才能输出，第一个\告诉编辑器我要输出一个特殊符号。
	//cout << "\" << endl;//错误，必须得是\\才能输出\。
	cout << "hello\tworld" << endl;//hello跟\t一共占八个位置，输出hello+三个空格+world
	//水平制表符\t可以整齐输出数据


	//字符串类型
	//1.C风格：char 变量名[] = "字符串值"; //变量名后跟[]，字符串值用双引号！字符型变量用单引号！
	char str1[] = "Hello world!";//如果str1后面不跟[]的话会认为创建字符型变量，后面跟双引号是不对的
	//cout << str1[] << endl;//错误
	cout << str1 << endl;
	//2.C++风格：string 变量名 = "字符串值";//C++风格需要加入头文件#include
	string str2 = "Hello world!!";
	cout << str2 << endl;


	//布尔类型bool true对应1，false对应0
	//1.创建bool数据类型 bool 变量名 = true或者false；
	bool flag = true;//true代表1
	cout << flag << endl;
	flag = false;//false代表0
	cout << flag << endl;
	//2.查看bool类型所占内存空间 sizeof（bool或者布尔变量名）


	//数据的输入，用于从键盘获取数据
	//语法：  cin >> 变量名；
	/*
	//1.整型
	int a_1 = 0;
	cout << "请给整型变量a_1赋值" << endl;
	cin >> a_1;
	cout << a_1 << endl;
	//2.浮点型
	float f_1 = 0;
	cout << "请给浮点型变量f_1赋值" << endl;
	cin >> f_1;
	cout << f_1 << endl;
	//3.字符型
	char ch_1 = 'a';
	cout << "请给字符型变量ch_1赋值" << endl;
	cin >> ch_1;
	cout << ch_1 << endl;
	//4.字符串型
	string str_1 = "";
	cout << "请给字符串型变量str_1赋值" << endl;
	cin >> str_1;
	cout << str_1 << endl;
	//5.布尔类型  只要是非0值都代表真！！！(-1,1)都为假，因为读的整数位，把小数位去掉了！
	bool flag_1 = true;
	cout << "请给布尔类型flag_1赋值" << endl;
	cin >> flag_1;
	cout << flag_1 << endl;
	*/


	//加减乘除运算
	int a_1 = 10;
	int b_1 = 3;
	cout << a_1 + b_1 << endl;
	cout << a_1 - b_1 << endl;
	cout << a_1 * b_1 << endl;
	cout << a_1 / b_1 << endl;//a_1是int型，b_1是int型，一除以后结果还是int型，故结果是3
	//两个整数相除，结果依然是整数，将小数部分去除
	//两个数相除，除数不能为0
	double d1 = 0.5;
	double d2 = 0.22;
	cout << d1 / d2 << endl;
	//取模=求余数，%两端必须是整数
	cout << a_1 % b_1 << endl;//10%3=1,10÷3=3。。。1，余数为1
	int a3 = 10;
	int a4 = 20;
	cout << a3 % a4 << endl;//10%20=10
	int a5 = 0;
	//cout << a3 % a5 << endl;//错误，除数不可以为0，不可求余数，程序会闪退。
	//两个小数是不可以做取模运算的
	//cout << d1 % d2 << endl;//错误，%左右两端不能是小数
	//递增递减
	//前置递增
	int a6 = 10;
	++a6;//让变量+1
	cout << a6 << endl;
	//后置递增
	int a7 = 20;
	a7++;//让变量+1
	cout << a7 << endl;
	//前置和后置的区别
	//前置递增：先让变量+1，再进行表达式运算
	//后置递增：先进行表达式计算，再让变量+1
	int a8 = 10;
	int a9 = 10;
	int b1 = ++a8 * 10;//先算10+1=11，再算11*10=110
	int b2 = a9++ * 10;//先算10*10=100，再算10+1=11
	cout << b1 << endl;
	cout << b2 << endl;


	//赋值运算符
	//=
	int a10 = 10;
	a10 = 100;
	cout << "a10=" << a10 << endl;
	//+=
	a10 = 10;
	a10 += 2;//a=a+2
	cout << "a10=" << a10 << endl;
	//-=
	a10 = 10;
	a10 -= 2;//a=a-2
	cout << "a10=" << a10 << endl;
	//*=
	a10 = 10;
	a10 *= 2;//a=a*2
	cout << "a10=" << a10 << endl;
	// /=
	a10 = 10;
	a10 /= 2;//a=a/2
	cout << "a10=" << a10 << endl;
	// %=
	a10 = 10;
	a10 %= 2;//a=a%2
	cout << "a10=" << a10 << endl;


	//比较运算符
	// ==
	int a11 = 10;
	int a12 = 20;
	cout << (a11 == a12) << endl;//加个括号，让比较运算优先级大于endl换行
	//!=
	cout << (a11 != a12) << endl;
	//>
	cout << (a11 > a12) << endl;
	//<
	cout << (a11 < a12) << endl;
	//>=
	cout << (a11 >= a12) << endl;
	//<=
	cout << (a11 <= a12) << endl;


	//逻辑运算符
	//非 ！
	int a13 = 10;//在c++中除了0都为真
	cout << !a << endl;
	cout << !!a << endl;
	//与&&   同真为真，其余为假
	int a14 = 10;
	cout << (a13 && a14) << endl;
	cout << (a13 && 0) << endl;
	//或 || 同假为假，其余为真
	cout << (a13 || a14) << endl;
	cout << (a13 || 0) << endl;
	cout << (0 || 0) << endl;


	//程序流程结构
	//选择结构
	//单行if 语句
	//语法：  if（条件）{满足条件执行的语句}
	//用户输入分数，如果分数大于600，视为考上一本大学，在屏幕上输出
	/*
	//1.用户输入分数
	int score = 0;
	cout << "请输入一个分数：" << endl;
	cin >> score;

	//2.打印用户输入的分数
	cout << "您输入的分数为：" << socre << endl;

	//3.判断分数是否大于600，如果大于就输出
	if (score > 600) //if条件后面不要加分号，如果加了分号，不管满不满足条件都会输出恭喜您。。。。
	{
		cout << "恭喜您考上了一本大学！" << endl;
	}

	*/

	//多行if语句
	//语法：  if（条件）{满足条件执行的语句}  else {不满足条件执行的语句}
	//输入考试分数，如果分数大于600，视为考上一本大学，在屏幕上输出；否则打印未考上
	/*
	//1.输入考试分数
	int score = 0;
	cout << "请输入您的分数" << endl;
	cin >> score;	

	//2.提示用户输入的分数
	cout << "您输入的分数为：" << score << endl;

	//3.判断  如果大于600，打印考上一本，否则打印未考上一本
	if (score > 600)
	{
		cout << "恭喜您考上一本大学！" << endl;
	}
	else
	{
		cout << "未考上一本大学！" << endl;
	}
	*/

	//多条件的if语句
	//语句： if（条件1）{条件1满足执行的语句} else if（条件2） {条件2满足执行的语句} else{都不满足执行的语句}
	//输入一个考试分数，如果大于600，为一本；大于500，为二本，大于400，为三本，其余为未考上
	/*
	//1.输入考试分数
	int score = 0;
	cout << "请输入您的分数" << endl;
	cin >> score;

	//2.提示用户输入的分数
	cout << "您输入的分数为：" << score << endl;

	//3.判断  如果大于600，一本；如果大于500，二本；如果大于400，三本；其余为未考上本科
	if (score > 600)
	{
		cout << "一本" << endl;
	}
	else if (score > 500) //第二个条件判断
	{
		cout << "二本" << endl;
	}
	else if (score > 400) //第三个条件判断
	{
		cout << "三本" << endl;
	}
	else //都不满足时候执行
	{
		cout << "未考上" << endl;
	}
	*/

	//嵌套if语句
	//如果大于600，一本；如果大于500，二本；如果大于400，三本；其余为未考上本科
	//在一本分数中，大于700，北大；大于650，清华；大于600，人大
	/*
	//1.输入考试分数
	int score = 0;
	cout << "请输入您的分数" << endl;
	cin >> score;

	//2.提示用户输入的分数
	cout << "您输入的分数为：" << score << endl;

	//3.判断  如果大于600，一本；如果大于500，二本；如果大于400，三本；其余为未考上本科
	if (score > 600)
	{
		cout << "一本" << endl;
		if (score > 700)
		{
			cout << "北大" << endl;
		}
		else if (score > 650)
		{
			cout << "清华" << endl;
		}
		else
		{
			cout << "人大" << endl;
		}
	}
	else if (score > 500) //第二个条件判断
	{
		cout << "二本" << endl;
	}
	else if (score > 400) //第三个条件判断
	{
		cout << "三本" << endl;
	}
	else //都不满足时候执行
	{
		cout << "未考上" << endl;
	}
	*/

//三只小猪称体重
/*
//1.创建三只小猪的体重变量
int pigA = 0;
int pigB = 0;
int pigC = 0;

//2.输入三只猪的体重
cout << "请输入小猪A的体重" << endl;
cin >> pigA;

cout << "请输入小猪B的体重" << endl;
cin >> pigB;

cout << "请输入小猪C的体重" << endl;
cin >> pigC;

cout << "小猪A的体重为：" << pigA << endl;
cout << "小猪B的体重为：" << pigB << endl;
cout << "小猪C的体重为：" << pigC << endl;

//3.判断哪只最重
//先判断A和B谁更重
if (pigA > pigB) // A比B重
{
	if (pigA > pigC) //A比C重
	{
		cout << "A最重" << endl;
	}
	else //C比A重
	{
		cout << "C最重" << endl;
	}
}
else //B比A重
{
	if (pigB > pigC) //B比C重
	{
		cout << "B最重" << endl;
	}
	else //C比B重
	{
		cout << "C最重" << endl;
	}
}
*/


//三目运算符
//语法：表达式1 ? 表达式2 : 表达式3;
//如果表达式1为真，执行表达式2，并返回表达式2的结果
//如果表达式1为假，执行表达式3，并返回表达式3的结果

//创建三个变量a b c
//将a和b作比较，将变量大的值赋值给变量c

int aa = 10;
int bb = 20;
int cc = 0;

cc = (aa > bb ? aa : bb);//或者不加括号也可以cc = aa > bb ? aa : bb;
cout << "cc=" << cc << endl;

//在C++中三目运算符返回的是变量，可以继续赋值
(aa > bb ? aa : bb) = 100; //aa>bb返回变量aa，aa不大于bb返回变量bb
cout << "aa=" << aa << endl << "bb=" << bb << endl;



//switch语句
//语法
/*
switch (表达式)
{
case 结果1:
	执行语句;
	break;
case 结果2:
	执行语句;
	break;
default:
	执行语句;
	break;
}
*/
/*
//给电影进行打分
//10~9 经典
//8~7非常好
//6~5一般
//5以下 烂片

//1.提示用户给电影评分
cout << "请给电影进行打分" << endl;

//2.用户开始进行打分
int score = 0;
cin >> score;
cout << "您打的分数为：" << score << endl;

//3.根据用户输入的分数来提示用户最后的结果
switch (score)
{
case 10:
	cout << "您认为是经典电影" << endl; 
	break; //退出当前分支，如果不加的话，会从第一个分支开始一直往下执行到最后一个分支
case 9:
	cout << "您认为是经典电影" << endl; 
	break;
case 8:
	cout << "您认为电影非常好" << endl;
	break;
case 7:
	cout << "您认为电影非常好" << endl;
	break;
case 6:
	cout << "您认为电影一般" << endl;
	break;
case 5:
	cout << "您认为电影一般" << endl;
	break;
default:
	cout << "您认为电影是烂片" << endl;
	break;
}
*/

//switch语句中表达式只能是整型或字符型
//switch结构清晰，执行效率高，但是不可以判断区间
//case里如果没有break，会一直往下执行


//while循环语句
//语法：while(循环条件）{循环语句；}
//只要循环条件的结果为真，就一直执行循环语句
//在写循环时一定要避免死循环的出现
//在屏幕中打印0~9这十个数字

int num = 0;
while (num < 10)
{
	cout << num << endl;
	num++;
}


//猜数字游戏
/*
//添加随机数种子  利用当前系统时间生成随机数，防止每次随机数都一样
srand((unsigned int)time(NULL));

//1.系统生成随机数
int suijishu = rand() % 100 + 1; //rand()%100生成0~99的随机数，%后的数字代表区间

//2.玩家进行猜测
int caice = 0;
while (1)
{
	cout << "请输入猜测的数字" << endl;
	cin >> caice;

//3.判断玩家的猜测
	//猜错  提示猜的结果  过大或者过小，重新返回第二步
	if (caice > suijishu)
	{
		cout << "过大" << endl;
	}
	else if (caice < suijishu)
	{
		cout << "过小" << endl;
	}
	else
	{
		cout << "恭喜" << endl;
		break; //在循环中，可以利用break来退出当前循环
		//猜对  退出游戏
	}

}
*/


//do...while循环语句
//语法：do(循环语句)while(循环条件);
//do...while会先执行一次循环语句，再判断循环条件
//在屏幕中输出0~9这十个数字
int num_do = 0;

do
{
	cout << num_do << endl;
	num_do++;
} while (num_do < 10);
//ctrl+c+k注释多行；ctrl+k+u取消注释


//水仙花数
//获取个位=对数字取模于10   例如：153%10=3
//获取十位=先整除于10，再对数字取模于10   例如153/10%10=5
//获取百位=整除于100  例如153/100=1

//1.先打印所有的三位数字
int num_shui = 100;

do
{
	//2.从所有三位数字中找到水仙花数
	int num_ge = 0;//个位
	int num_shi = 0;//十位
	int num_bai = 0;//百位

	num_ge = num_shui % 10;//获取数字的个位
	num_shi = num_shui / 10 % 10;//获取数字的十位
	num_bai = num_shui / 100;//获取数字的百位

	if (num_ge*num_ge*num_ge + num_shi*num_shi*num_shi + num_bai*num_bai*num_bai == num_shui)
	{
		cout << num_shui << endl;
	}

	num_shui++;
} while (num_shui < 1000);


//for循环
//语句：
/*
for (起始表达式；条件表达式；末尾循环体)
{
	循环语句；
}
*/
//打印数字0~9

for (int i = 0; i < 10; i++)
{
	cout << i << endl;
}


//敲桌子游戏
//1.先输出1~100数字
for (int i = 1; i < 100; i++)
{
	//2.从100个数字中找到特殊数字，打印敲桌子。7的倍数、个位有7、十位有7
	//i%10==7 个位数字是否为7
	//i/10==7 十位数字是否为7
	//i%7==0  是否为7的倍数
	if (i % 10 == 7 || i / 10 == 7 || i % 7 == 0)
	{
		cout << "敲桌子" << endl;
	}
	else //如果不是特殊数字，打印该数字
	{
		cout << i << endl;
	}
}


//利用嵌套循环实现星图
//打印星图
//外层执行一次，内层执行一周
for (int i = 0; i < 10; i++)
{
	for (int j = 0; j < 10; j++)
	{
		cout << "* " ;
	}
	cout << endl;
}


//乘法口诀表
//外层循环控制行数，内层循环控制列数=外行内列
for (int i = 1; i < 10; i++)
{
	for (int j = 1; j <= i; j++)
	{
		cout << j << "*" << i << "=" << i * j << "\t";
	}
	cout << endl;
}


//break 语句
//作用：跳出选择结构或者循环结构

/*
//1.出现在switch语句中，终止case并跳出switch
cout << "请选择副本难度" << endl;
cout << "1.普通" << endl;
cout << "2.中等"<< endl;
cout << "3.困难"<< endl;

int select_fuben = 0; //创建选择结果的变量

cin >> select_fuben; //等待用户的输入
switch (select_fuben)
{
case 1:
	cout << "您选择的是普通难度" << endl;
	break;
case 2:
	cout << "您选择的是中等难度" << endl;
	break;
case 3:
	cout << "您选择的是困难难度" << endl;
	break;
default:
	break;
}
*/

//2.出现在循环语句中，跳出当前的循环语句
for (int i = 0; i < 10; i++)
{
	//如果i=5，退出循环，不再打印
	if (i == 5)
	{
		break;//退出循环，最后只输出0,1,2,3,4
	}
	cout << i << endl;
}

//3.出现在嵌套循环中，跳出最近的内层循环语句
for (int i = 0; i < 10; i++)
{
	for (int j = 0; j < 10; j++)
	{
		//每行只有五个星星
		if (j == 5)
		{
			break;//退出内层循环，不会影响外层循环=break终止多层嵌套中最近的一层循环
		}
		cout << "* ";
	}
	cout << endl;
}


//continue语句
//作用：在循环语句中，跳过本次循环中余下的尚未执行的语句，继续执行下一次循环
for (int i = 0; i < 100; i++)
{
	//如果是奇数输出，偶数不输出 i%2=0为偶数，i%2=1为奇数
	if (i % 2 == 0)
	{
		continue;//可以筛选条件，执行到此就不再向下执行，再执行下一次循环
		//break会退出循环，而continue不会
	}
	cout << i << endl;
}


//goto语句
//作用：可以无条件跳转语句
//语法： 
/*goto 标记；
  标记：
*/
//标记名称一般用大写字母来表示
//如果标记的名称存在，执行到goto语句时，会跳转到标记的位置
cout << "1" << endl;
cout << "2" << endl;
goto FLAG;
cout << "3" << endl;
cout << "4" << endl;
FLAG:
cout << "5" << endl;
//在程序中不建议使用goto，会造成程序流程混乱


//数组
//数组索引从0开始
//特点：1.数组中每个数据元素都是相同的数据类型
//2.数组由连续的内存位置组成的
//数组定义的三种方式

//1.数据类型 数组名 [数组长度];
int arr[5];

//给数组中的元素进行赋值
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
arr[4] = 50;

//访问数据元素
cout << arr[0] << endl;
cout << arr[1] << endl;
cout << arr[2] << endl;
cout << arr[3] << endl;
cout << arr[4] << endl;

//2.数据类型 数组名 [数组长度] = {值1，值2，...};
int arr2[5] = { 10,20,30 };//如果给的值个数不够定义的5个，会自动用0补齐

//cout << arr2[0] << endl;
//cout << arr2[1] << endl;
//cout << arr2[2] << endl;
//cout << arr2[3] << endl;
//cout << arr2[4] << endl;
//利用for循环输出数组中的元素
for (int i = 0; i < 5; i++)
{
	cout << arr2[i] << endl;
}

//3.数据类型 数组名 [] = {值1，值2,...};
//定义数组的时候，必须有初始长度
int arr3[] = { 90,80,70,60,50,40,30,20,10 };
for (int i = 0; i < 9; i++)
{
	cout << arr3[i] << endl;
}
//数组名不要和变量名重名


//一维数组数组名
//1.可以统计整个数组在内存中的长度
//sizeof(数组名)  比如：sizeof(arr)
//sizeof（数组名[索引])  比如：sizeof（arr[0])
//数组元素个数=sizeof(arr)/sizeof(arr[0])
int arr_name[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "整个数组占用内存空间为" << sizeof(arr_name) << endl;
//输出40，因为int类型一个为4字节，10个一共40字节
cout << "每个元素占用内存空间为：" << sizeof(arr_name[0]) << endl;
cout << "数组中元素个数为：" << sizeof(arr_name) / sizeof(arr_name[0]) << endl;

//2.可以获取数组在内存中的首地址
//用cout << 数组名 << endl;来查看数组在内存中的首地址,输出为16进制
cout << "数组首地址为：" << (int)arr_name << endl;//(int)arr强制转换为十进制
//用cout << &数组名[索引] << endl;来查看数组中第i个元素的地址,输出为16进制
cout << "数组中第一个元素地址为" << (int)&arr_name[0] << endl;
cout << "数组中第一个元素地址为" << (int)&arr_name[1] << endl;//每个元素之间相差四个字节，证明数组是连续的

//数组名是常量，不可以进行赋值操作
//arr = 100; //错误，数组名是常量，不可以进行赋值操作


//五只小猪称体重

//1.创建五只小猪体重的数组
int arr_pig[5] = { 300,350,500,400,250 };

//2.从数组中找到最大值
int pig_max = 0;//假设最大值为pig_max=0
for (int i = 0; i < 5; i++)
{
	if (arr_pig[i] > pig_max)//如果访问的数组中元素比我认定的最大值还大，则更新最大值
	{
		pig_max = arr_pig[i];
	}
}

//3.打印最大值
cout << "最重体重为:" << pig_max << endl;


//数组元素逆置

//1.创建数组
int arr_nizhi[5] = { 1,3,2,5,4 };
cout << "数组逆置前：" << endl;
for (int i = 0; i < 5; i++)
{
	cout << arr_nizhi[i] << endl;
}

//2.实现逆置
//2.1记录起始下标位置
//2.2记录结束下标位置
//2.3起始下标与结束下标的元素互换
//2.4起始位置++  结束位置--
//2.5循环执行2.1操作，直道起始位置>=结束位置
int arr_start = 0;//起始元素下标
int arr_end = sizeof(arr) / sizeof(arr[0]) - 1;//末尾元素下标=元素个数-1

while (arr_start < arr_end)
{
	//实现元素互换
	int arr_temp = arr_nizhi[arr_start];//用 temp来暂存数据
	arr_nizhi[arr_start] = arr_nizhi[arr_end];
	arr_nizhi[arr_end] = arr_temp;

	//下标更新
	arr_start++;
	arr_end--;
}

//3.打印逆置后的数组
cout << "数组元素逆置后：" << endl;
for (int i = 0; i < 5; i++)
{
	cout << arr_nizhi[i] << endl;
}


//冒泡排序法实现升序排列
int arr_maopao[9] = { 2,4,0,5,7,1,3,8,9 };

cout << "排序前：" << endl;

for (int i = 0; i < 9; i++)
{
	cout << arr_maopao[i] << endl;
}

//总共排序轮数为：元素个数-1，从0开始
for (int i = 0; i < 9 - 1; i++)
{
	//内层循环：  对比次数=元素个数-1-当前轮数
	for (int j = 0; j < 9 - 1 - i; j++)
	{
		//如果第一个数字比第二个数字大，交换两个数字
		if (arr_maopao[j] > arr_maopao[j + 1])
		{
			int maopao_temp = arr_maopao[j];
			arr_maopao[j] = arr_maopao[j + 1];
			arr_maopao[j + 1] = maopao_temp;
		}
	}
}

cout << "排序后：" << endl;

for (int i = 0; i < 9; i++)
{
	cout << arr_maopao[i] << endl;
}


//二维数组定义方式
//1. 数据类型 数组名[行数][列数]; 
//2. 数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };
//3. 数据类型 数组名[行数][列数] = { 数据1，数据2，数据3，数据4 };
//4. 数据类型 数组名[][列数] = { 数据1，数据2，数据3，数据4 };

//1. 数据类型 数组名[行数][列数]; 
int arr_erwei1[2][3];
arr_erwei1[0][0] = 1;
arr_erwei1[0][1] = 2;
arr_erwei1[0][2] = 3;
arr_erwei1[1][0] = 4;
arr_erwei1[1][1] = 5;
arr_erwei1[1][2] = 6;

//外层循环打印行数，内层循环打印列数
for (int i = 0; i < 2; i++)
{
	for (int j = 0; j < 3; j++)
	{
		cout << arr_erwei1[i][j] << endl;
	}
}

//2. 数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };
int arr_erwei2[2][3]=
{
	{1,2,3,},
	{4,5,6}
};

for (int i = 0; i < 2; i++)
{
	for (int j = 0; j < 3; j++)
	{
		cout << arr_erwei2[i][j] << " ";
	}
	cout << endl;
}

//3. 数据类型 数组名[行数][列数] = { 数据1，数据2，数据3，数据4 };
int arr_erwei3[2][3] = { 1,2,3,4,5,6 };
for (int i = 0; i < 2; i++)
{
	for (int j = 0; j < 3; j++)
	{
		cout << arr_erwei3[i][j] << " ";
	}
	cout << endl;
}

//4. 数据类型 数组名[][列数] = { 数据1，数据2，数据3，数据4 };
int arr_erwei4[][3] = { 1,2,3,4,5,6 };

for (int i = 0; i < 2; i++)
{
	for (int j = 0; j < 3; j++)
	{
		cout << arr_erwei4[i][j] << " ";
	}
	cout << endl;
}
//在定义二维数组时，如果初始化了数据，可以省略行数


//二维数组名称用途
//1.可以查看占用内存空间大小
int arr_ername[2][3]=
{
	{1,2,3},
	{4,5,6}
};
cout << "二维数组占用内存空间为：" << sizeof(arr_ername) << endl;//int四个字节，double八个字节
cout << "二维数组第一行占用内存为：" << sizeof(arr_ername[0]) << endl;
cout << "二维数组第一个元素占用内存为：" << sizeof(arr_ername[0][0]) << endl;

cout << "二维数组的行数为：" << sizeof(arr_ername) / sizeof(arr_ername[0]) << endl;
//行数=二维数组内存空间/一行内存空间
cout << "二维数组的列数为：" << sizeof(arr_ername[0]) / sizeof(arr_ername[0][0]) << endl;
//列数=一行内存空间/一个元素内存空间

//2.可以查看二维数据的首地址
cout << "二维数组的首地址为：" << (int)arr_ername << endl;
cout << "二维数组第一行首地址为：" << (int)arr_ername[0] << endl;
cout << "二维数组第二行首地址为：" << (int)arr_ername[1] << endl;//两行首地址之间差了一行的字节数

cout << "二维数组第一个元素首地址：" << (int)&arr_ername[0][0] << endl;


//考试成绩统计
//1.创建二维数组
int scores[3][3]=
{
	{100,100,100},
	{90,50,100},
	{60,70,80}
};

string names[3] = { "张三","李四","王五" };

//2.统计每个人的总分数
for (int i = 0; i < 3; i++)
{
	int sum = 0;//统计分数总和的变量
	for (int j = 0; j < 3; j++)
	{
		sum += scores[i][j];
		//cout << scores[i][j] << "\t";
	}
	cout << names[i] << "的总分为：" << sum << endl;
}



//main中调用add函数
int aaaa = 10;
int b = 20;
//函数调用语法：函数名称（参数）;
//a和b成为实际参数，简称为实参
int c = add(aaaa, b);//当调用函数时，实参的值会传递给形参
cout << "c=" << c << endl;

aaaa = 100;
b = 500;
c = add(aaaa,b);
cout << "c=" << c << endl;


//指针  指针就是一个地址
//指针的作用：可以通过指针间接访问内存
//内存编号从0开始记录的，一般用十六进制表示
//可以利用指针变量保存地址
//普通变量存放的是数据，指针变量存放的是地址
//1.定义一个指针
int a_zz = 10;

//指针定义的语法：数据类型 * 指针变量名称；
int * p;

//让指针记录变量a的地址
p = &a_zz;//&取址符号  或者直接int * p = &a_zz;
cout << "a的地址为：" << &a << endl;
cout << "指针p为：" << p << endl;

//2.使用指针
//可以通过解引用的方式来找到指针指向的内存
//指针前加 * 代表解引用，找到指针指向的内存  比如：*p
cout << "a_zz=" << a_zz << endl;
cout << "*p=" << *p << endl;

*p = 1000;//指针变量p指向储存在内存中a_zz的数值，并将a_zz赋值1000
cout << "a_zz=" << a_zz << endl;//输出1000
cout << "*p=" << *p << endl;//输出1000


//指针所占的内存空间 sizeof(int/float/double/char *或者指针变量名）
//所有指针在32位操作系统下都是4个字节，64位下占8个字节
cout << "sizeof(int *)=" << sizeof(int *) << endl;
cout << "sizeof(p)=" << sizeof(p) << endl;
cout << "sizeof(float *)=" << sizeof(float *) << endl;
cout << "sizeof(double *)=" << sizeof(double*) << endl;
cout << "sizeof(char *)=" << sizeof(char *) << endl;


//空指针：指针变量指向内存中编号为0的空间
//语法：数据类型 * 指针变量名=NULL；
//用途：初始化指针变量
//空指针指向的内存是不可以访问的，切记！
int * p_k = NULL;

//0-255之间的内存编号是系统占用的，因此不可以访问
//*p_k = 100;//错误，空指针指向的内存是不可以访问的


//野指针
//野指针指向非法的内存空间
//int * p_y = (int *)0x1100;//错误，没有权限访问。要访问某个内存空间要事先预定
//空指针和野指针都不是我们申请的空间，因此不要访问。


//const修饰指针
//把const翻译成常量，*翻译成指针
//const后面跟了啥，啥就不能改

//1.const修饰指针--常量指针
int a_xs = 10;
int b_xs = 20;

const int * p_xs = &a_xs; //*p操作不能进行
//指针指向的值不可以改，指针的指向可以改
//*p_xs = 20;//错误
p_xs = &b_xs;
cout << *p_xs << endl;//输出20

//2.const修饰常量--指针常量
int *  const p_xs2 = &a_xs;//p=&a不能进行
//指针的指向不可以改，指针指向的值可以改
*p_xs2 = 100;
//p_xs2 = &b_xs;//错误，指针的指向不可以改

//3.const既修饰指针又修饰常量
const int * const p_xs3 = &a_xs;//都不可以改
//指针的指向和指针指向的值都不可以改
//*p_xs3 = 100;//错误，指针指向的值不可以改
//p_xs3 = &b_xs;//错误，指针的指向不可以改


//指针和数组
//访问数组首地址语法： 数据类型 * 指针变量名 = 数组名；
//利用指针访问数组中的元素
int arr_zz[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "第一个元素为：" << arr_zz[0] << endl;

int *p_sz = arr_zz;//数组名arr_zz就是数组的首地址
cout << "利用指针来访问第一个元素：" << *p_sz << endl;

p_sz++;//让指针向后偏移四个字节，因为p定义的是int型，int型占四个字节
cout << "利用指针来访问第二个元素：" << *p_sz << endl;

cout << "利用指针来遍历数组" << endl;
int * p_sz2 = arr_zz;
for (int i = 0; i < 10; i++)
{
	cout << *p_sz2 << endl;
	p_sz2++;
}


/*
	cout << "一年有" << month << "个月。" << endl;

	cout << "a = " << a << " " << a+10 << endl;

	cout << "Love life."; //不加endl不换行

	cout << endl; //endl是用来换行的

	cout << "一周有" << Day << "天。" << endl;

	cout << "Hello world!" << endl;

*/
	system("pause");

	//cin.get();

	return 0;

}