C++基础知识点（1-8章），期末考试复习

#1.C++初识 常量 定义常量两种方式：

1.#define 宏常量 #define Day 7 不可修改！修改会报错 2.const 修饰的变量 const int month=12; 同样不可修改，修改报错 关键字：关键字是C++预先保留的单词（标识符） 在定义变量或常量时，不要用关键字。（因为已经被系统征用了，如int等等） 标识符（自己给变量或者常量起的名字） 命名规则： 1.标识符不可以是关键字 2.标识符只能由字母，数字，下划线组成 3.第一个字符必须为字母或下划线（不能用数字开头！！！） 4.标识符中的字母区分大小写 建议：给变量起名时最好能做到见名知意

#2.数据类型

C++规定在创建一个变量或者常量时，必须指定出相应的数据类型，否则无法给变量分配内存。 数据类型存在的意义：给变量分配合适的内存空间。 比如，给int类型10分配的空间没有必要给double那么长，避免造成空间浪费。 ##2.1 整型 作用：整型变量表示的是整数类型的数据。 C++中能够表示整型的类型有以下几种方式，区别在于所占内存空间不同。 数据类型 占用空间 取值范围 short（短整型） 2字节 （-2^15~2^15-1） int(整型) 4字节 （-2^31~2^31-1） long(长整型) Windows为4字节，Linux为4字节（32位），8字节（64位） （-2^31~2^31-1） long long（长长整型） 8字节 （-2^63~2^63-1） 字节不同，占用内存空间不同。从而取值范围也不同，超出范围就会出错。 ##2.2 sizeof关键字 作用：可以统计数据类型所占内存大小。 语法 sizeof(数据类型/变量) #include< iostream> using namespace std; int main() { //整型 short（2） int（4） long（4） long long（8） //可以利用sizeof求出数据类型占用内存大小 //语法 ： sizeof（数据类型/变量） short num1 = 10; cout << "short占用的内存空间为:" << sizeof(short) << endl; cout << "short占用的内存空间为:" << sizeof(num1) << endl;

system("pause");
return 0;

}

##2.3 实型（浮点型） 作用：用于表示小数。 浮点型变量分为两种：

1. 单精度float 4个字节 7位有效数字
2. 双精度double 8个字节 15~16位有效数字 有效数字：小数点前加小数点后数字数 例如 3.14有 3位有效数字 ##2.4 字符型 作用：字符型变量用于显示单个字符。 语法：char ch=‘a’； 注意1：用单引号不要用双引号； 注意2：单引号内只能有一个字符，不可以是字符串。 • C和C++中字符型变量只占用一个字节 • 字符型变量并不是把字符本身放到内存中存储，而是将对应的ASII编码放入到存储单元 查看字符对应的ASCII码 cout<<(int)ch<<="" code="" style="box-sizing: border-box;"> ##2.5 转义字符 作用：用于表示一些不能显示出来的ASCII字符 常用：\n换行，\输出一个\，\t制表 ##2.6 字符串型 作用：用于表示一串字符。 两种风格 1.C风格字符串：char 变量名[]="字符串值" 注意要用双引号 2.C++风格字符串：string 变量名="字符串值" 要包含头文件#include ##2.7 布尔类型 bool 作用：布尔数据类型代表真或假的值 bool类型只有两个值：

• true --真（本质是1）
• false--假（本质是0） bool类型占1个字节大小 ##2.8 数据的输入 作用：用于从键盘中获取数据 关键字：cin 语法：cin >> 变量 #3. 运算符 作用：用于执行代码的运算。 ##3.1 算术运算符
• +，-，*，/
• % 取模（取余） 本质就是求余数。不可对0取模，两个小数不可以做取模运算（C++规定）
• 递增递减 ++，-- 前置递增，先让变量 + 1，然后进行表达式运算；后置递增，先进行表达式运算，后让变量 + 1； 前置： int a2 = 10; int b2 = ++a2 * 10; cout << "a2=" << a2 << endl; cout << "b2=" << b2 << endl;

最后输出结果为：a2=11,b2=110 后置： int a3 = 10; int b3 = a3 ++* 10; cout << "a3=" << a3 << endl; cout << "b3=" << b3 << endl;

最后输出结果为: a3=11,b3=100 递减同理。 ##3.2 赋值运算符 作用：用于将表达式的值赋给变量。 =，+=，-=，*=，/=，%= a+=2 就等价于 a=a+2，其余皆同理 ##3.3 比较运算符 作用： 用于表达式的比较，并返回一个真值或假值。 ==（相等于），！=（不等于），<,>,<=,>= ##3.4 逻辑运算符 作用：用于表达式的值返回真值或假值。 运算符 术语 示例 结果 ！ 非 ！a 如果a为假，则！a为真；如果a为真，则！a为假 && 与 a&&b 如果a和b都为真，则结果为真，否则为假 || 或 a||b 如果a和b有一个为真，则结果为真，二者都为假时，结果为假

#4. 程序流程结构 C/C++支持最基本的三种程序运行结构：顺序结构,选择结构，循环结构 ##4.1 选择结构 ###4.1.1 if语句 作用：执行满足条件的语句。 ###4.1.2 三目运算符 作用：通过三目运算符实现简单的判断。 语法：表达式1 ？ 表达式2 ： 表达式3 解释： 如果表达式1的值为真，执行表达式2，并返回表达式2的结果。 如果表达式1的值为假，执行表达式3，并返回表达式3的结果。 在C++中三目运算符返回的是变量，可以继续赋值。 ###4.1.3 switch语句 作用：执行多条件分支语句。 语法： switch（表达式） {

case 结果1：执行语句；break；
 case 结果2：执行语句；break；
 ...
  default：执行语句；break；

}

必须用break退出当前分支，不然会一直向下执行 if和switch的区别： -switch缺点：判断时只能是整型或者字符型，不可以是一个区间（switch后（）中的内容） -switch优点：结构清晰，执行效率高。 ##4.2 循环结构 ###4.2.1 while循环语句 作用：满足循环条件，执行循环语句。 语法：whlie(循环条件){循环语句} 解释：只要循环条件的结果为真，就执行循环语句。 注意：在执行循环语句时，程序必须提供跳出循环的出口，否则会出现死循环。 生成随机数： rand()%100 生成一个0~99的随机数(伪随机数) 要想使随机数变化，需要添加随机数种子，作用是利用当前系统的时间生成随机数，防止每次随机数都一样 #include< ctime> srand（(unsigned int )time(NULL)）;

###4.2.2 do...while循环语句 作用：满足循环条件，执行循环语句。 语法：do{循环语句}while（循环条件） 注意：与while的区别在于do...while会先执行一次循环语句，再判断循环条件。 练习案例：水仙花数 案例描述：水仙花数是指一个3位数，它的每个位上的数字的三次幂之和等于它本身 例如1^3+5^3+3^3=153 请利用do...while语句，求出所有三位数中的水仙花数。 #include< iostream> using namespace std;

int main() { //1.先打印所有的三位数字 int num = 100; do { //2.从所有三位数字中找到水仙花数 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循环语句 作用：满足循环条件，执行循环语句。 语法：for(起始表达式；条件表达式；末尾循环体){循环语句；} 练习案例：敲桌子 案例描述：从1开始数到数字100，如果数字个位含有7，或者数字十位含有7，或者该数字是7的倍数，我们打印敲桌子，其余数字直接打印输出。 #include< iostream> using namespace std;

int main() { //1.先输出1~100的数字 for (int i = 1; i <= 100; i++) { //2.从100个数字中找到特殊的数字，打印“敲桌子” //如果是7的倍数、个位有7、或者十位有7，打印敲桌子 if (i % 7 == 0 || i % 10 == 7 || i / 10 == 7)//如果是特殊数字，打印敲桌子 { cout <<"敲桌子" << endl;

    }
    else//如果不是特殊数字，才打印数字
    {
        cout << i << endl;
    }
}
 system("pause");
 return 0;

}

###4.2.1 嵌套循环 练习案例：乘法口诀表 重要：99乘法表 #include< iostream> using namespace std;

int main() { //行数列数=计算结果 //列数<=当前行数 //打印行数 for (int i =1; i <= 9; i++) { //cout << i << endl; for (int j = 1; j <= i; j++) { cout << j << "" << i << "=" << i * j << " "<<"\t";//\t水平制表符 } cout << endl; }

system("pause");
 return 0;

}

##4.3 跳转语句 ###4.3.1 break语句 作用：用于跳出选择结构或者循环结构。 break使用的时机：

• 出现在switch条件语句中，作用是终止case并跳出switch*
• 出现在循环语句中，作用是跳出当前的循环语句
• 出现在嵌套循环中，跳出最近的内层循环语句 ###4.3.2 continue语句 作用：在循环语句中，跳过本次循环中余下尚未执行的语句，执行下一次循环。 #include< iostream> using namespace std;

int main() { //continue语句 for (int i = 0; i <= 100; i++) { //如果是奇数输出，偶数不输出。 if (i % 2 == 0) { continue; } cout << i << endl; } system("pause"); return 0; }

break会直接退出循环，而continue不会。 ###4.3.3 goto语句 作用：可以无条件跳转语句。 语法：goto 标记; 解释：如果标记的名称存在，执行到goto语句时，会跳转到标记的位置。 不推荐使用以免造成流程混乱。 #5 数组 ##5.1 概述 所谓数组，就是一个集合，里面存放了相同类型的数据元素。 特点1：数组中的每个数据元素都是相同的数据类型。 特点2：数组是由连续的内存位置组成的。 ##5.2 一维数组 ###5.2.1 一维数组定义方式 1.数据类型 数组名[数组长度] 2.数据类型 数组名[数组长度]={值1，值2.....}；//如果在初始化数据时候，没有全部填写完，会用0来填补剩余的数据。 3.数据类型 数组名[]={值1.值2......};//定义数组时，必须要有初始长度（指{}内至少要有一个数据） 数组元素的下标是从0开始索引的。 ##5.2.2 一维数组数组名 一维数组名称的用途：

1. 可以统计整个数组在内存中的长度。
2. 可以获取数组在内存中的首地址。 #include< iostream> using namespace std; int main() { //数组用途 //1. 可以统计整个数组在内存中的长度。 int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; cout << "整个数组占用内存空间为 ：" << sizeof(arr) << endl; cout << "每个元素所占用的内存空间为： " << sizeof(arr[0]) << endl; cout << "数组中元素的个数为: " << sizeof(arr) / sizeof(arr[0]) << endl; //2. 可以获取数组在内存中的首地址。 cout << "数组首地址为: " << arr << endl;//16进制 cout << "数组首地址为: " << (int)arr << endl;//强转成十进制 cout << "数组中第一个元素的地址为： " << (int)&arr[0] << endl; cout << "数组中第二个元素的地址为： " << (int)&arr[1] << endl;//与第一个紧挨着，只差四个字节。 //数组名是常量，不可以进行赋值的操作。 //arr = 100;报错 system("pause"); return 0;

} 数组名是常量，不可以进行赋值的操作。 练习案例：元素逆置 #include< iostream> using namespace std;

int main() { //实现数组元素逆置 //1.创建数组 int arr[5] = { 1,3,2,5,4 }; cout << "元素数组逆置前：" << endl; for (int i = 0; i < 5; i++) cout << arr[i] << endl; //2.实现逆置 //2.1记录起始下标的位置 //2.2记录结束下标的位置 //2.3起始下标与结束小标的元素互换 //2.4起始位置++，结束位置-- //2.5循环执行2.1操作，直到起始位置>=结束位置 int start = 0;//起始下标 int end = sizeof(arr) / sizeof(arr[0]) - 1;//结束下标 while (start < end) //重要：停止条件，自己之前没有想到。 { //交换代码 int temp = arr[start]; arr[start] = arr[end]; arr[end] = temp; //下标更新 start++; end--; } //3.打印逆置后的数组 cout << "数组元素逆置后：" << endl; for (int i = 0; i < 5; i++) cout << arr[i] << endl;

system("pause");
 return 0;

} 停止条件注意 ##5.2.3 冒泡排序 作用：最常用的排序方法，对数组内元素进行排序。

1. 比较相邻的元素，如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。
3. 重复以上的步骤，每次比较次数-1，直到不需要比较。 示例：将数组{4，2，8，0，5，7，1，3，9}进行升序排序 #include< iostream> using namespace std;

int main() { //利用冒泡排序实现升序序列。 int arr[9] = { 4,2,8,0,5,7,1,3,9 }; cout << "排序前： " << endl; for (int i = 0; i < 9; i++) { cout << arr[i] << " "; } cout << endl; //开始冒泡排序 //总共排序轮数为 元素个数-1 for (int i = 0; i < 9 - 1; i++) { //内层循环对比 次数=元素个数-当前轮数 -1 for (int j = 0; j < 9 - i - 1; j++) { //如果第一个数字比第二个数字大，交换两个数字 if (arr[j] > arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } //排序后结果 cout << "排序后： " << endl; for (int i = 0; i < 9; i++) { cout << arr[i] << " ";

}
cout << endl;

system("pause");
 return 0;

} 注意总共排序轮数为  元素个数-1，而内层循环对比次数=元素个数-当前轮数 -1 #5.3 二维数组 二维数组就是在一维数组上，多加一个维度。 ##5.3.1 二维数组定义方式 二维数组定义的四种方式：

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

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

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

4. 数据类型 数组名[][列数]={数据1，数据2，数据3，数据4} 建议：以上4种定义方式，第二种更加直观，提高代码的可读性。 ##5.3.2 二维数组数组名 用途： – 查看二位数组所占内存空间。 – 获取二维数组首地址。 示例 #include< iostream> using namespace std; int main() { //二维数组数组名 int arr[2][3] = { {1,2,3}, {4,5,6} }; cout << "二维数组大小: " << sizeof(arr) << endl; cout << "二维数组一行大小: " << sizeof(arr[0]) << endl; cout << "二维数组元素大小: " << sizeof(arr[0][0]) << endl;

   cout << "二维数组行数： " << sizeof(arr) / sizeof(arr[0]) << endl; cout << "二维数组列数： " << sizeof(arr[0]) / sizeof(arr[0][0]) << endl; //地址 cout << "二维数组首地址" << (int) arr << endl; cout << "二维数组第一行地址" << arr[0] << endl; cout << "二维数组第二行地址" << arr[1] << endl;

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

   system("pause"); return 0;

} #6 函数 ##6.1 概述 作用：将一段经常使用的代码封装起来，减少重复代码 一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。 ##6.2 函数的定义 函数的定义一般主要有5个步骤：

1. 返回值类型
2. 函数名
3. 参数列表
4. 函数体语句
5. return表达式 语法： 返回值类型 函数名 （参数列表） { 函数体语句 return表达式 } //函数的定义 //语法： //返回值类型 函数名（参数列表） {函数体语句 return表达式} //加法函数，实现两个整型相加，并将相加结果返回 int add(int num1, int num2) { int sum = num1 + num2; return sum; } ##6.3 函数的调用 功能：使用定义好的函数。 语法:函数名（参数） #include< iostream> using namespace std;

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

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

system("pause");
return 0;

} ##6.4 值传递 – 所谓值传递，就是函数调用时实参将数值传入给形参 – 值传递时，如果形参发生变化，并不会影响实参 #include< iostream> using namespace std; //值传递 //定义函数，实现两个数字进行交换函数 //如果函数不需要返回值，声明时可以写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;返回值不需要时，可以不写reurn

} int main() { int a = 10, b = 20; cout << "a= " << a << endl; cout << "b= " << b << endl; //当我们做值传递时，函数的形参发生变化，并不会影响实参 swap(a, b); cout << "a= " << a << endl; cout << "b= " << b << endl;//a和b并没有发生变化 system("pause"); return 0; } ##6.5 函数的常见形式 常见的函数形式有4种：

1. 无参无返
2. 有参无返
3. 无参有返
4. 有参有返 ##6.6 函数的声明 作用：告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义 函数的声明可以多次，但函数的定义只能有一次 #include using namespace std;

//函数的声明 //比较函数，实现两个整型数字进行比较，返回较大的值

//提前告诉编译器函数的存在，可以利用函数的声明 //函数的声明 //声明可以写多次，但是定义只能有一次 int max(int a, int b); int max(int a, int b); int max(int a, int b); int max(int a, int b); int main() { int a = 10; int b = 20; cout << max(a, b) << endl;

system("pause");

return 0;

}

//定义 int max(int a, int b) { return a > b ? a : b; } ##6.7 函数的分文件编写 作用：让代码的结构更加清晰。 函数分文件编写一般有四个步骤：

1. 创建后缀名为.h的头文件
2. 创建后缀名为.cpp的源文件。
3. 在头文件中写函数的声明。
4. 在源文件中写函数的定义。 头文件swap.h #include< iostream> using namespace std; //函数的声明 void swap(int a, int b); 源文件swap.cpp #include"swap.h"

//函数的定义 void swap(int a, int b) { int temp = a; a = b; b = temp; cout << "a= " << a << endl; cout << "b= " << b << endl; } 程序 #include using namespace std; #include"swap.h"

//1. 创建后缀名为.h的头文件 //2. 创建后缀名为.cpp的源文件。 //3. 在头文件中写函数的声明。 //4. 在源文件中写函数的定义。 int main() { int a = 10; int b = 20; swap(a, b);

system("pause");
return 0;

}

#7 指针 ##7.1 指针的基本概念 指针的作用：可以通过指针间接访问内存。 – 内存编号是从0开始记录的，一般用十六进制数字表示 – 可以用指针变量保存地址。 ##7.2 指针变量的定义和使用 指针变量定义语法:  数据类型*变量名 指针定义： int a=10; int p; p=&a; //指针p就是a的地址，&为取址符，&a和p的输出结果相同。 使用指针： 1 2 3 4 5 //可以通过解引用的方式找到指针指向的内存 //指针前加代表解引用，找到指针指向内存中的数据 p=1000; //改变p等同于改变a的值，现在a=1000

##7.3 指针所占内存空间 提问：指针也是一种数据类型，那么这种数据类型占用多少内存空间？ 答：32位操作系统无论是什么数据类型都占4个字节，64位则是8个字节。一般开发都是在32位系统下。 ##7.4 空指针和野指针 空指针：指针变量指向内存中编号为0的空间。 用途：初始化指针变量 注意：空指针指向的内存是不可以访问的。 #include< iostream> using namespace std; int main() { //空指针 //1.空指针用于给指针变量初始化 int *p = NULL;

//2.空指针是不可以进行访问的
//0~255之间的内存编号是系统占用的，因此不可以访问
*p = 100;//只要有*p的操作编译就会出错

system("pause");

return 0;

}

野指针：指针变量指向非法的内存空间。 #include< iostream> using namespace std;

int main() { //野指针 //在程序中，尽量避免出现野指针 int *p = (int *)0x1100;//此地址并没有申请使用所以无法操纵 cout << *p << endl;//一旦操纵就会报错

system("pause");

return 0;

}

空指针和野指针都不是我们自己申请的空间，因此不要访问。 ##7.5 const修饰指针 const修饰指针有三种情况：

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

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

3. const即修饰指针，又修饰常量 int a = 10; int b = 10; int *p = &a; //1.const修饰指针——常量指针 const int *p = &a; //特点：指针的指向可以修改，但是指针指向的值不可以改。 *p = 20;//错误，指针指向的值不可以修改 p = &b;//正确，指针的指向可以改

   //2.const修饰常量——指针常量 int * const p = &a; //特点：指针的指向不可以改，指针指向的值可以改 *p = 20;//正确，指向的值可以改 p = &b;//错误，指针的指向不可以修改

   //3.const即修饰指针，又修饰常量 const int *const p = &a; //特点：指针的指向和指向的值都不可以修改 *p = 20;//错误 p = &b;//错误 技巧：看const右侧紧跟着的是指针还是常量，是指针就是常量指针，是常量就是指针常量。

##7.6 指针和数组 作用：利用指针访问数组中元素。 #include< iostream> using namespace std;

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++;//让指针向后偏移四个字节

cout << "利用指针来访问第二个元素为： " << *p << endl;

cout << "用指针遍历数组" << endl;

int *p2 = arr;
for (int i = 0; i < 10; i++)
{
    //cout << arr[i] << endl;
    cout << *p2 << endl;
    p2++;
}


system("pause");
return 0;

}

##7.7 指针和函数 作用：利用指针作函数参数，可以修改实参的值 #include< iostream> using namespace std; //实现两个数字进行交换 void swap01(int a, int b) { int temp = a; a = b; b = temp; cout << "swao01 a= " << a << endl; cout << "swap01 b= " << b << endl; } void swap02(intp1, intp2) { int temp = *p1; *p1 = *p2; *p2 = temp; } int main() { //指针和函数 //1.值传递(swap里a和b发生了变化，但实际函数里ab未发生变化) int a = 10; int b = 20; //swap01(a, b);

//2.地址传递
//如果是地址传递，可以修饰实参（ab改变了）
swap02(&a, &b);
cout << "a= " << a << endl;
cout << "b= " << b << endl; 
system("pause");
return 0;

} 总结：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递。 ##7.8 指针、数组、函数 案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序。 例如数组：int arr[10]={4,3,6,9,1,2,10,8,7,5}; #include< iostream> using namespace std; //冒泡排序函数 参数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() { //1.先创建数组 int arr[10] = {4,3,6,9,1,2,10,8,7,5};

//数组长度
int len = sizeof(arr) / sizeof(arr[0]);
//2.创建函数，实现冒泡排序
bubbleSort(arr, len);

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

system("pause");
return 0;

}

#8 结构体 ##8.1 结构体基本概念 结构体属于用户自定义的数据类型，允许用户储存不同的数据类型 ##8.2 结构体定义和使用 语法 struct 结构体名{结构体成员列表}； 通过结构体创建变量的方式有三种： – struct 结构体名 变量名 – struct 结构体名 变量名={成员1值，成员2值…..} – 定义结构体时顺便创建变量 #include< iostream> using namespace std; #include

//1.创建学生数据类型：学生包括（姓名，年龄，分数） //自定义数据类型，一些类型的集合组成的一个类型 //语法 struct 类型名称{成员列表} struct Student { //成员列表 //姓名 string name; //年龄 int age;
//分数 int score; }s3;//顺便创建结构体变量

//2.通过学生类型创建具体学生

int main() {

//2.1 struct Student s1
//struct 关键字可以省略，创建时可省略，定义时不可以（上面为定义）
struct Student s1;
//Student s1;
//给s1属性赋值,通过.访问结构体变量中的属性
s1.name = "张三";
s1.age = 18;
s1.score = 100;

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

//2.2 struct Student s2={...}
struct Student s2 = { "李四",19,80};
cout << "姓名： " << s2.name << " 年龄： " << s2.age << " 分数： " << s2.score << endl;
//2.3 在定义结构体时顺便创建结构体变量
s3.name = "王五";
s3.age = 20;
s3.score = 60;
cout << "姓名： " << s3.name << " 年龄： " << s3.age << " 分数： " << s3.score << endl;
  system("pause");
return 0;

}

总结1：定义结构体时的关键字是struct，不可省略 总结2：创建结构体变量时，关键字struct可以省略 总结3：结构体变量利用操作符”.”访问成员 ##8.3 结构体数组 作用：将自定义的结构体放入到数组中方便维护 语法  struct 结构体名 数组名[元素个数]={ {},{},....{}}; 示例 #include< iostream> using namespace std; #include

//结构体数组 //1.定义结构体 struct Student { //姓名 string name; //年龄 int age; //分数 int score;

}; int main() {
//2.创建结构体数组 struct Student stuArray[3] = { {"张三",18,100}, {"李四",28,99 }, {"王五",38,66}

};

//3.给结构体中数组中的元素赋值
stuArray[2].name = "赵六";
stuArray[2].age = 86;
stuArray[2].score = 60;


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

system("pause");
return 0;

}

##8.4 结构体指针 作用：通过指针访问机构体中的成员 – 利用操作符->可以通过结构体指针访问结构体属性 #include< iostream> using namespace std; #include

//结构体指针 struct Student { string name;//姓名 int age;//年龄 int score;//分数 };

int main() {
//1.创建学生结构体变量 struct Student s = { "张三",18,100 };//struct可省略

//2.通过指针指向结构体变量
Student *p = &s;//struct可省略

//3.通过指针访问结构体变量中的数据
//通过结构体指针 访问结构体中的属性，需要利用‘ -> ’

cout << "姓名： " << p->name << " 年龄： " << p->age << " 分数： " << p->score << endl;

system("pause");
return 0;

}

总结：结构体指针可以通过 -> 操作符来访问结构体中的成员 ##8.5 结构体嵌套结构体 作用： 结构体中的成员可以是另一个结构体。 例如： 每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体 示例： #include< iostream> using namespace std; #include

//定义学生结构体 struct student { string name; int age; int score; };

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

int main() {
//结构体嵌套结构体 //创建老师 teacher t; t.id = 100000; t.name = "老王"; t.age = 50; t.stu.name = "小王"; t.stu.age = 20; t.stu.score = 60; cout << "老师姓名： " << t.name << " 老师编号 " << t.id << " 老师年龄： " << t.age << " 老师辅导的学生姓名： " << t.stu.name << " 学生年龄： " << t.stu.age << " 学生分数： " << t.stu.score << endl;

system("pause");
return 0;

}

总结：在结构体中可以定义另一个结构体作为成员，用来解决实际问题。 ##8.6 结构体做函数参数 作用：将结构体作为参数向函数中传递。 传递方式有两种： – 值传递 – 地址传递 示例： #include< iostream> using namespace std; #include

//定义学生结构体 struct student { string name; int age; int score; }; //打印学生信息函数 //1.值传递 void printStudent1(struct student s) { s.age = 100; cout << " 子函数中打印结果 姓名： " << s.name << " 年龄： " << s.age << " 分数： " << s.score << endl; }

//2.地址传递 void printStudent2(struct student *p) { p->age = 101; cout << " 子函数2中打印结果 姓名： " << 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来防止误操作。 示例： #include< iostream> using namespace std; #include

//const使用场景 struct student { string name; int age; int score; }; //将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来（指针只占四个字节） void printStudents(const student *s) { //s->age=150;//加入const后，一旦有修改的操作就会报错，可以防止我们的误操作 cout << " 姓名： " << s->name << " 年龄： " << s->age << " 分数： " << s->score << endl; }

int main() {
//创建结构体变量 struct student s = {"张三",15,70};

//通过函数打印结构体变量信息
printStudents(&s);
system("pause");
return 0;

}

##8.8 结构体案例 ###8.8.1 案例1 案例描述： 学校正在做毕设项目，每名老师带领5个学生，总共有三位老师，需求如下 设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员。 学生的成员有姓名、考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值 最终打印出老师数据以及老师所带的学生数据. #include< iostream> using namespace std; #include #include

//学生的结构体 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;//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 
          << " 考试分数： " << tArray[i].sArray[j].score<< endl;
    }
}

} int main() {
//随机数种子 srand((unsigned int)time(NULL)); //1.创建3名老师的数组 struct Teacher tArray[3];

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

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


system("pause");
return 0;

}

##8.2 案例2 案例描述： 设计一个英雄的结构体，包括成员姓名，年龄，性别；创建结构体数组，数组中存放5名英雄。 通过冒泡排序的方法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。 五名英雄信息如下： 1 2 3 4 5 6 {"刘备", 23, "男"}; {"关羽", 22, "男"}; {"张飞", 20, "男"}; {"赵云", 21, "男"}; {"貂蝉", 19, "女"};

示例： #include< iostream> using namespace std; #include

//1.设计英雄结构体 //英雄结构体 struct Hero { //姓名 string name; //年龄 int age; //性别 string sex;

};

//冒泡排序 void bubbleSort(struct Hero heroArray[], int len) { for (int i = 0; i < len - 1; i++) { for (int j = 0; j < len - i - 1; j++) { //如果j下标的元素年龄大于j+1下标的元素年龄，交换两个元素 if (heroArray[j].age > heroArray[j + 1].age) { struct Hero temp = heroArray[j];//类型是自定义类型，所以不用int heroArray[j] = heroArray[j + 1]; heroArray[j + 1] = temp; } }

}

} //打印排序后数组中的信息 void printHero(struct Hero heroArray[], int len) { for (int i = 0; i < len; i++) { cout << "姓名： " << heroArray[i].name << " 年龄： " << heroArray[i].age << " 性别： " << heroArray[i].sex << endl; } } int main() {
//2.创建数组存放5名英雄 struct Hero heroArray[5]= { {"刘备", 23, "男"}, {"关羽", 22, "男"}, {"张飞", 20, "男"}, {"赵云", 21, "男"}, {"貂蝉", 19, "女"} };

int len = sizeof(heroArray) / sizeof(heroArray[0]);

//3.对数组进行排序，按年龄进行升序排序
bubbleSort(heroArray, len);

//4.将排序后结果打印输出
printHero(heroArray, len);


system("pause");
return 0;

}

Word文件稿，请发邮件索取854466042@qq.com