C++语法初级-课程笔记（自用）

最新推荐文章于 2024-05-13 09:55:25 发布

Dijkstraand

最新推荐文章于 2024-05-13 09:55:25 发布

阅读量181

点赞数

文章标签： c++ 算法排序算法

本文链接：https://blog.csdn.net/Dijkstraand/article/details/128092119

版权

C++基础

C++初识（2022.10.17）

1.4 常量定义方式

（1）#define 宏常量：一旦修改就会报错

（2）const修饰的变量：也称为常量，修改也会报错

#define Day 7
Day = 14;//报错，Day是常量，一旦修改就会报错

const int month = 12;
cout << "一周总共有" <<Day<<"天" << endl;

month = 24;//也会报错，常量是不可以修改的

1.5 关键字

**作用：**关键字是C++中预先保留的单词

在定义变量或常量时，不要用关键字

1.6标识符命名规则

作用：C++规定给标识符（变量、常量）命名时，有一套自己的规则

标识符不能是关键字
标识符只能是由字母、数字、下划线组成
第一个字符必须为字母或下划线
标识符字母区分大小写

建议：给标识符命名时，争取做到见名知意，方便代码阅读

2 数据类型

2.1 整型

//1.短整型(占2个字节)
short num1 = 10;
//2.整型（占4）
int num2 = 10;
//3.长整型（占4）
long num3 = 10;
//4.常常整型（占8）
long long num4 = 10;

2.2 sizeof关键字

作用：统计数据类型所占内存大小

语法：sizeof(数据类型/变量)

int main(){
    cout<<"short 类型所占内存空间为："<< sizeof(short)<<endl;
    cout<<"int 类型所占内存空间为："<< sizeof(int) << endl;
    cout<<"long 类型所占内存空间为："<< sizeof(long) << endl;
    system("pause");
    return 0;
}

2.3 实型（浮点型）

**作用：**用于表示小数

浮点型变量分两种：

1.单精度float（占4字节）：7位有效数字

2.双精度double（占8字节）：15-16位有效数字

两者的区别在于表示的有效数字范围不同。

float f1 = 3.14f;//f的作用是明显告诉它为单精度，否则默认为双精度
double d1 = 3.1415926;//默认情况下，输出一个小数，会显示6位有效数字，从左往右

2.4 字符型

**作用：**字符型变量用于显示单个字符

**语法：**char ch =‘a’;（单引号内只能有一个字符，不可以是字符串）

char ch = 'a';//字符型变量所占内存大小为1个字节
//常见错误char ch2 = "b"；//创建字符型变量时候，要用单引号
cout<< (int)ch <<endl;  //输出字符型变量对应的ASCII编码

2.5 转义字符

**作用：**用于表示一些不能显示出来的ASCII字符

现阶段常用转义字符有：\n（换行）; \\（反斜杠）; \t（水平制表符，整齐输出数据，一个\t占8个字符空间）

2.6 字符串型

**作用：**用于表示一串字符

两种风格：

1. C风格字符串：char 变量名[] = "字符串值"|

示例：

char str1[] = "hello world";
cout << str1 <<endl;

注意：c风格的字符串要用双引号括起来

2. C++风格字符串： string 变量名 = "字符串值"

#include <string>   //用c++风格字符串时候，要加上这个头文件
string str2 = "hello world";
cout << str2 << endl;

2.7 布尔类型bool

bool类型占1个字节大小

示例：

int main()
{
    bool flag = true;
    cout << flag << endl;//1
    
    flag = false;//重新赋值为fallse
    cout << flag << endl;//0
    cout <<"size of bool="<<sizeof(bool)<<endl;//1
    
    system("pause");
    return 0;
}

2.8 数据的输入

**作用：**用于从键盘获取数据

关键字: cin

语法： cin >> 变量|

示例：

int main(){
    
    //整型输入
    int a = 0;   // 先给a赋一个初始值
    cout << "请给整型变量a赋值:" << endl;
    cin >> a;
    cout << "整型变量a="<<a << endl;
    //浮点型
    float f = 3.14f
    cout << "请给浮点型变量f赋值" <<endl;
    cin >> f;
    cout << "浮点型变量f="<< f <<endl;
    

}

3 运算符

3.1 算数运算符

%：取模运算，求余数，只能两整数进行运算
++（前置递增）：先让变量+1，然后进行表达式运算
++（后置递增）：先进行表达式运算，后让变量+1

int a2 = 10;
int b2 = ++a2 * 10;
cout << a2 <<endl;//11
cout << b2 <<endl;//110

int a3 = 10;
int b3 = a3++ * 10
cout << a3 <<endl;//11
cout << b3 <<endl;//100

–（前置递减）：
–（后置递减）：

3.2 赋值运算符

3.3 比较运算符

3.4 逻辑运算符

4 程序流程结构

4.1 选择结构

4.1.1 if 语句

4.1.2 三目运算符

语法： 表达式1 ？表达式2 ：表达式3

**解释：**如果表达式1的值为真，执行表达式2，并返回表达式2的结果。如果表达式1的值为假，执行表达式3，并返回表达式三的结果。

4.1.3 switch 语句

语法

switch(表达式)
{
        case 结果1：执行语句;break;
        case 结果2：执行语句;break;
        ···
        default:执行语句;break;
}
//if 和 switch区别？
//switch缺点：判断时候只能是整型或字符型，不可以是一个区间
//switch优点：结构清晰，执行效率高

4.2 循环结构

4.2.1 while循环语句

语法： while(循环条件){循环语句}|

案例：

#include <ctime>
int main{
    //添加随机数种子，利用当前系统时间生成随机数，防止每次随机数都一样
	srand((unsigned int)time(NULL));
	int a=rand()%100 + 1;//rand()%100是指生成0-99的随机数
    int b;
	cout << "请输入你猜测的数字：" << endl;
	cin >> b;
	while (a != b) 
	{
		if (a > b) {
			cout << "你猜的太小了，继续" << endl;
			cin >> b;
		}
		else {
			cout << "你猜的太大了，继续" << endl;
			cin >> b;
		}
	}
	cout << "猜对了，过关！" << endl;
	system("pause");
	return 0;
}

4.2.2 do…while循环语句、

语法： do{循环语句} while(循环条件)|

**案例：**在所有三位数中找到水仙花数(该数字所有位的三次方之和等于该数字)

例如水仙花数153，

技巧：获取个位 153%10 = 3 对数字取模于10可以获取个位

获取十位 153/10=15 15%10=5 先整除于10，再取模于10，获得十位

获取百位 153/100=1 直接整除于100获得

int main{
    int num = 100;              //案例三
        do {
            int a = 0;
            int b = 0;
            int c = 0;
            a = num % 10;
            b = (num / 10)%10;
            c = num / 100;
            if (a * a * a + b * b * b + c * c * c == num) 
            {
                cout << num << endl;
            }
            num++;

        } while (num < 1000);
        system("pause");
        return 0;
}

4.2.3 for循环语句

案例：0-100数字中，输出特殊数字，7的倍数，个位有7，十位有7

int main{
    for (int i = 0; i <= 100; i++) {
            if (i % 7 == 0 || i % 10 == 7 || i/10==7) {
                cout << "敲桌子"<< i << endl;
            }
            else {
                cout << i << endl;
            }
        }
      system("pause");
      return 0;
	
}

4.2.4 嵌套循环

案例5：输出10*10的星图

int mian{
    for (int i = 0; i < 10; i++) {
		for (int j = 0; j < 10; j++) {
			cout << "* ";
		}
		cout << endl;
	}
	system("pause");
	return 0;    
}

案例6：输出9*9乘法表

int mian(){
    for (int i = 1; i <10 ; i++) {                  //案例6
            for (int j = 1; j < 10; j++) {
                if (i >= j) {
                    cout << j << "*" << i << "=" << i * j <<" ";
                }
            }
            cout << endl;
        }
     system("pause");
     return 0;
}

5 数组

5.1 概述

5.2 一维数组

5.2.1 一维数组定义方式

三种定义方式：

1.数据类型数组名[数组长度]

2.数据类型数组名[数组长度] = {值1，值2，…}

3.数据类型数组名[] = {值1，值2，…}

//不同定义类型示例：
//1.数据类型  数组名[数组长度]
int arr[5];
arr[0]=10; //给数组中的元素赋值
arr[1]=20;
arr[2]=30;
arr[3]=40;
arr[4]=50;
//2.数据类型  数组名[数组长度] = {值1，值2，...}
//如果在初始化数据时候，没有全部填写完，会用0来填补剩余数据
int arr2[5] = {10,20,30,40,50};
//3.数据类型  数组名[] = {值1，值2，...}
//定义数组的时候，必须有初始长度，不能像这样 int arr[]; 
int arr[] = {90,80,70,60}

//数组名用途
//1.可以通过数组名统计整个数组占内存大小
int arr[10] = {1,2,3,4,5,6}
cout <<"整个数组占用内存空间为："<<sizeof(arr)<< endl;
cout <<"每个元素占用内存空间为："<<sizeof(arr[0])<<endl;
//2.可以通过数组名查看数组首地址
cout<<"数组首地址为："<<(int)arr <<endl;
cout<<"数组中第一个元素地址为："<<(int)&arr[0]<<endl;//访问具体元素地址，需要加取址符&

//arr = 100;错误，数组名是常量，因此不可以赋值

案例2：数组元素逆置

案例描述：请声明一个5个元素的数组，并将元素逆置。例如数组{1,3,2,5,4}逆置为{4,5,2,3,1}

//法一：自己写的方法,申请了额外的空间存放新数组
int main(){
    int arr1[5] = { 1,3,2,5,4 };
	int arr2[5];
	int j = 0;         //末尾元素下标可这样求：end = sizeof(arr)/sizeof(arr[0]) - 1
	for (int i = 4; i >= 0; i--) {
		arr2[j] = arr1[i];
		j++;
	}
	for (int n = 0; n < 5; n++) {
		cout<<arr2[n]  ;
	}
	system("pause");
	return 0;	
}

//法2:老师的方法，不需要申请额外空间，用交换排序
int main(){
	int arr1[5] = { 1,3,2,5,4 };
	int start = 0;
	int end = sizeof(arr1)/sizeof(arr1[0]) - 1;//末尾元素下标=元素长度-1
	while (start < end) {
		int temp = arr1[start];
		arr1[start] = arr1[end];
		arr1[end] = temp;
		start++;
		end--;
	}
	for (int i = 0; i < 5; i++) {
		cout << arr1[i];
	}
	system("pause");
	return 0;
}

5.2.3 冒泡排序

**作用：**最常见的排序算法，对数组内元素进行排序

1.比较相邻的元素，如果第一个比第二个大，就交换他们两个

2.对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值

3.重复以上的步骤，每次比较次数减一，知道不需要比较

示例：将数组{4,2,8,0,5,7,1,3,9}进行升序排序

int main(){
     //冒泡排序案例
    int arr[9] = { 4,2,8,0,5,7,1,3,9 };
	for (int i = 0; i < 9-1; i++) 
    {     //排序总轮数=元素个数-1
		for (int j = 0; j < 9 -i - 1; j++) 
        {  //每轮对比次数=元素个数-排序轮数-1
			if (arr[j] > arr[j + 1]) 
            {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
	for (int n = 0; n < 9; n++) {
		cout << arr[n] ;
	}
    system("pause");
	return 0; 
}

5.3 二维数组

5.3.1 二维数组定义方式

四种定义方式：

1. 数据类型数组名[行数][列数]；

2. 数据类型数组名[行数][列数]={{数据1，数据2},{数据3，数据4}}；

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

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

建议利用第二种更加直观，提高代码的可读性

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

//案例,求三个人的分数和
//1.创建二维数组
   
	int score[3][3] =
	{
		{100,100,100},
		{90,50,100},
		{60,70,80}
	};
	//2.统计每个人的总和分数
	for (int i = 0; i < 3; i++) {
		int sum = 0;
		for (int j = 0; j < 3; j++) {
			 sum += score[i][j];
		}
		cout << "第"<<i+1 <<"个人的分数和为：" << sum << endl;
	}
	system("pause");
	return 0;

6 函数

6.1 概述

6.2 函数的定义

语法:

返回值类型函数名(参数列表)

{

函数体语句；

return 表达式；

}

6.3 函数的调用

int add(int num1, int num2)      //num1,num2称为形式参数，形参
{
	int sum = num1 + num2;
	return sum;
}
int main(){
    int a = 10;                   //a,b称为实参     
	int b = 20;
	int c = add(a, b);
	cout << c << endl;
	system("pause");
	return 0;
}

6.4 值传递

6.5 函数的常见样式

常见得函数样式有4种：

1.无参无返

2.有参无返

3.无参有返

4.有参有返

//函数常见样式
//1.无参无返
void test01()
{
	cout << "this is test01" << endl;
}
//2.有参无返
void test02(int a) 
{
	cout << "this is test02 a =" << a << endl;
}
//3.无参有返
int test03() {
	cout << "this is test03" << endl;
	return 1000;
}
//4.有参有返
int test04(int a) {
	cout<<"this is test04 a=" << endl;
	return a;
}

int main() {
	//无参无返函数调用
	test01();
	//有参无返函数调用
	test02(1000);
	//无参有返函数调用
	int num = test03();
	//有参有返函数调用
	int num2 = test04(10000);
	system("pause");
	return 0;
}

6.6 函数的声明

//可以利用函数的声明,提前告诉编译器函数的存在
//声明可以写多次，但定义只能有一次
int max(int a, int b);    //函数的声明
int main(){
    int a=10;
    int b=20;
    cout<<max(a,b)<<endl;
}
//定义函数
int max(int a ,int b){
    return a > b ? a:b ;
}
//如果函数声明有默认参数，函数实现就不能有默认参数

6.7 函数的分文件编写

作用：让结构更加清晰

函数分文件编写一般有4个步骤：

1.创建后缀名为.h的头文件

2.创建后缀名为.cpp的源文件

3.在头文件中写函数的声明 //记得添加标准头文件 #include

4.在源文件中写函数的定义 // #include “自己写的头文件.h”

7 指针

7.1 指针的基本概念

**指针的作用：**可以通过指针间接访问内存

内存编号是从0开始记录的，一般用十六进制数字表示
可以利用指针变量保存地址

7.2 指针的定义和使用

指针变量定义语法：数据类型 * 变量名；

示例：

int main(){
    //1.指针的定义
    int a = 10;
    //指针定义语法： 数据类型 * 变量名；
    int * p;
    //指针变量赋值
    P = &a;  //指针指向变量a的地址
    cout<< &a <<endl; //打印数据a的地址
    cout<< p <<endl;  //打印指针变量p
    //2.指针的使用
    //通过*操作指针变量指向的内存
    cout<<"*p="<<*p<<endl;
    
    system("pause");
    return 0;
    
}

7.3 指针所占内存空间

在32位操作系统下，指针是占4个字节空间大小，不管是什么数据类型的指针。
在64位操作系统下，指针是占8个字节空间大小，不管是什么数据类型的指针。

7.4 空指针和野指针

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

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的

示例1：空指针

int main(){
    //空指针
	//1、空指针用于给指针变量进行初始化
	int * p = NULL;
	//2、空指针是不可以进行访问的
	//*p = 100;  //cout<< *p <<endl;       //都是错误操作，0-255之间的内存编号是系统占用的，因此不可以访问
    system("pause");
    return 0;
}

野指针：指针变量指向非法的内存空间

示例2：野指针

int main(){
    //指针变量p指向内存地址编号为0x1100的空间
    int * p = (int *)0x1100; //用(int *)把十六进制数强转为地址，因为是随便指向的一个地址，并没有申请，所有必会报错，出现野指针的情况。
    
    //对*p解引用，访问野指针报错
    
    cout<< *p <<endl;
    
    system（"pause"）;
    return 0;
}

总结：空指针和野指针都不是我们申请的空间，因此不要访问,会报错。

7.5 const 修饰指针

const修饰指针有三种情况：

1.const修饰指针 —常量指针

2.const修饰常量 —指针常量

3.const既修饰指针又修饰常量

int main(){
//1.const修饰指针-- - 常量指针
	int a = 10;
	int b = 10;
	const int * p = &a;
	//指针指向的值不可以改，指针的指向（地址）可以改。
	//*p = 20;错误
	p = &b;  //正确

	//2.const修饰常量-- - 指针常量
	int * const p2 = &a;
	//指针指向的值可以改，指针的指向（地址）不可以改
	*p2 = 20; //正确
	//p2 = &b;  //错误

	//3.const既修饰指针又修饰常量
	const int* const p3 = &a;
	//指针指向的值，指针的指向（地址）都不可以改
	//*p3 = 20; //错误
	//p3 = &b;  //错误

	system("pause");
	return 0;
}

7.6 指针和数组

**作用：**利用指针访问数组中的元素

示例：

int main(){
//利用指针访问数组中的元素
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	cout << "第一个元素为：" << arr[0] << endl;

	int* p = arr;//可以通过数组名查看数组首地址，所有arr就是数组的首地址
	cout << "利用指针访问第一个元素：" << *p << endl;
	p++;         //作用是让指针后移4个字节，相当于p->next
	cout << "利用指针访问第二个元素：" << *p << endl;

	//利用指针遍历数组
	int* p2 = arr;
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
		cout << *p2 << endl;
		p2++;
	}
    system("pause");
    return 0;
}

7.7 指针和函数

void swap01(int a,int b){
    int temp = a;
    a = b;
    b = temp;    
}

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

int main(){
    //1.值传递，实参不会被修改
    int a=10;
    int b=20;
    swap01(a,b);
    //2.地址传递
    //如果是地址传递，实参会被修改
    swap02(&a,&b);
    
    system("pause");
    return 0;
}

7.8 指针、数组、函数综合使用

案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序

例如数组： int arr[10] = {4,3,6,9,1,2,10,8,7,5}

//冒泡排序    参数1 数组首地址  参数2 数组长度
void Bubblesort(int *arr,int len)
{

	for (int i = 0; i < len - 1; i++) {
		for (int j = 0; j < len - i - 1; 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;
	}
}
int main(){
    int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
	//数组长度
	int len = sizeof(arr) / sizeof(arr[0]);
    //调用冒泡排序
	Bubblesort(arr, len);//arr表示数组首地址，len表示数组长度
	//打印排序后的数组
	printArray(arr, len);
    
    system("pause");
    return 0;
}//注：传数组的时候一般传首地址进来即可，写函数的时候用指针 int* p 接收首地址。

8 结构体

8.1 结构体的基本概念

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

8.2 结构体定义和使用

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

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

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

示例：

#include<iostream>
#include<string>
//创建一个结构体
struct Student{
    string name;
    int age;
    int score;
}s3;
int mian(){
    //通过结构体创建变量的方式有三种：
    //1.struct  结构体名 变量名
    struct Student s1;
    s1.name = "张三"；
    s1.age = 18;
    s1.score = 100;
    
    //2.struct  结构体名 变量名={成员值1，成员值2，.....}
    struct Student s2={"李四"，19,80};
   
    //3.定义结构体时顺便创建变量
    //s3就是一个结构体变量
    s3.name = "王五";
    s3.age =17;
    s3.score = 88;
    system("pause");
    return 0;
}                          //推荐使用前两种

8.3 结构体数组

**作用:**将自定义的结构体放入到数组中方便维护

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

示例:

#include<string>
//1.定义一个结构体
struct Student{
    string name;
    int age;
    int score;
};
int main(){
    //2.创建结构体数组
    struct Student stuArray[3] ={
        {"张三"，18,100},
        {"李四"，28,99}，
        {"王五"，44,88}
    };
    
    //3.给结构体数组中的元素赋值
    stuArray[2].name = "赵六";
    stuArray[2].age = 50;
    stuArray[2].score = 87;
    //遍历结构体数组
    for(int i=0;i<3;i++){
        cout<<"姓名："<<stuArray[i].name
            <<"年龄"<<stuArray[i].age
            <<"分数"<<stuArray[i].score<<endl;
    }
}

8.4 结构体指针

**作用：**通过指针访问结构体中的成员

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

示例：

//创建一个结构体
struct Student {
	string name;
	int age;
	int score;
};
int main(){
//1.创建学生结构体变量
	struct Student s = { "张三",18,100 };
	//2.通过指针指向结构体变量
	struct Student* p = &s;
	//3.通过指针访问结构体变量中的数据
	//通过结构体指针 访问结构体的属性，需要利用'->'
	cout << "姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl;

	system("pause");
	return 0;
}

8.5 结构体嵌套结构体

**作用:**结构体中的成员可以是另一个结构体

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

//结构体嵌套一个结构体
struct student {
	int age;
	string name;
	int score;
};
struct teacher {
	int id;
	string name;
	int age;
	struct student stu;//老师结构体嵌套一个学生结构体,即一个学生结构体变量
};
int main(){
//结构体嵌套一个结构体
	teacher t;//创建一个结构体变量，前面的struct关键字可以写可以不写
	t.age = 50;
	t.id = 10000;
	t.name = "王老五";
	t.stu.age = 18;
	t.stu.name = "小李";
	t.stu.score = 80;
	cout << "老师的姓名: " << t.name << "老师的编号 " << t.id << "老师的年龄 " <<t.age<< endl;
	cout << "小李的姓名: " << t.stu.name << "小李的分数 " << t.stu.score << "小李的年龄 " <<t.stu.age<< endl;
    system("pause");
    return 0;
}

8.6 结构体做函数参数

//创建一个结构体
struct student {
	string name;
	int age;
	int score;
};
//值传递
void printStudent1(struct student s) {
	s.age = 100;
	cout << "子函数中 姓名：" << s.name << "年龄：" << s.age << "分数：" << s.score << endl;

}
//地址传递
void printStudent2(struct student * p) {
	p->age = 200;
	cout << "子函数中 姓名：" <<p->name << "年龄：" << p->age << "分数：" << p->score << endl;
}
int main(){
//结构体做函数参数
	//创建结构体变量
	struct student s;
	s.name = "张三";
	s.age = 20;
	s.score = 85;

	//值传递
	printStudent1(s);
	//地址传递
	printStudent2(&s);
	cout << "main函数中 姓名：" << s.name << "年龄：" << s.age << "分数：" << s.score << endl;
     system("pause");
     return 0;
}

总结：如果不想修改主函数中的数据，用值传递，反之用地址传递

8.7 结构体中const使用场景

**作用：**用const来防止误操作

//学生结构体定义
struct student{
    //成员列表
    string name;
    int age;
    int score;
};
//const使用场景
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudent(const student *s){
    //s->age = 100;//加了const,一旦修改便会提示操作失败，因为加了const修饰，常量是不可以修改的
    cout<<"姓名："<< s->name << "年龄："<<s->age<<"分数："<<s->score<<endl;
}
int main(){
    
    student s={"张三",18,100};//创建结构体变量
    printStudent(&s);
    system("pause");
    return 0;
}

8.8 结构体案例

8.8.1 案例1

案例描述：

每名老师带领5名学生，总共3名老师，需求如下：设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员，学生的成员有姓名，考试分数;创建数组存放3名老师，通过函数给每个老师及所带的学生赋值，最终打印出老师数据以及老师所带的学生数据.

#include<string>
#include<ctime>
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() % 50 + 50;
			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 << "学生姓名：" << tArray[i].sArray[j].sName<< 
				"考试分数：" << tArray[i].sArray[j].score << endl;
		}
	}

}
int main(){
    //随机种子
    srand((unsigned)time(NULL));
    //创建3名老师的数组
    struct teacher tArray[3];
	int len = sizeof(tArray) / sizeof(tArray[0]);
	allocateSpace(tArray, len);

	//打印老师及带学生信息
	printInfo(tArray, len);
   
	system("pause");
	return 0;
    
}

8.8.2 案例2

案例描述：

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

struct hero {
	string name;
	int age;
	string sex;
};

void bubblesort(struct hero p[],int len) {
	for (int i = 0; i < len - 1; i++) {
		for (int j = 0; j < len - i - 1; j++) {
			if (p[j].age > p[j + 1].age) {
				struct hero temp = p[j]; //创建一个结构体临时变量，拿来存放三个属性
				p[j] = p[j + 1];
				p[j + 1] = temp;
			}
		}
	}
}
void PrintInfo(struct hero yxArray[], int len) {
	for (int i = 0; i < len; i++) {
		cout <<"姓名："<< yxArray[i].name << " 年龄："<<yxArray[i].age << " 性别："<<yxArray[i].sex << endl;
	}
}

int main(){
    
    struct hero yxArray[5] =
	{
		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",22,"男"},
		{"貂蝉",19,"女"}
	};
	int len = sizeof(yxArray) / sizeof(yxArray[0]);
	bubblesort(yxArray,len);
	PrintInfo(yxArray,len);
	system("pause");
	return 0;
}