01 课程安排
| 阶段 | 课程 | 目标 | 案例 |
| 第一阶段 | C++基础语法入门 | 对C++有初步了解，能够有基础编程能力 | 通讯录管理系统 |
| 第二阶段 | C++核心编程 | 介绍C++面向对象编程，为大型项目做铺垫 | 职工管理系统 |
| 第三阶段 | C++提高编程 | 介绍C++泛型编程思想，以及STL的基本使用 | 演讲比赛系统 |
C++程序框架
#include<iostream>
using namespace std;
int main()
{
system("pause");
return 0;
}02 第一个C++程序-C++书写HelloWorld
创建项目-创建文件-编写代码-运行程序
1.选择VisualC++
2.选中空项目
3.项目名称
4.项目路径
5.确定
6.添加源文件
7.选择C++文件（.cpp）
8.源文件名称
9.添加
10.编写代码
main是一个程序的入口，每个程序都必须有main函数，有且仅有一个
03 程序的注释-单行注释和多行注释
单行注释：//描述信息
通常放在一行代码的上方或一条语句的末尾，对该行代码说明
多行注释：/*描述信息*/
通常放在一段代码的上方，对该代码做整体说明
04 变量-变量的使用 变量的意义
变量：给一段指定的内存空间起名，方便操作这段内存
语法：数据类型 变量名 = 初始值；
#include<iostream>
using namespace std;
int main()
{
int a = 10;
cout << "a=" << a << endl;
system("pause");
return 0;
}05 常量-常量与变量的区别-常量的使用
常量：用于记录程序中不可更改的数据
C++定义常量有两种方式
1、#define宏常量：#define 常量名 常量值
通常在文件上方定义，表示一个常量
2、const修饰的变量 const 数据类型 常量名 = 常量值
通常在变量定义前加关键字const，修饰该变量为常量，不可修改
POINT：
const修饰的变量也称为常量，一旦修改也会报错
#include<iostream>
using namespace std;
//常量的定义方式
//1、#define宏常量
//2、const修饰的变量
//1、#define宏常量
#define Day 7
int main()
{
cout << "一周共有：" << Day << "天" << endl;
//Day = 8;报错，宏常量不可修改
//2、const修饰变量
const int month = 12;
cout << "一年共有：" << month << "月" << endl;
//month = 12;报错，const修饰的变量为常量，不可修改
system("pause");
return 0;
}06 关键字-C++常用的编程关键字
关键字：关键字是C++中预先保留的单词（标识符）
在定义变量或者常量时，不可使用关键字
C++关键字如下：
| asm | do | if | return | typedef |
| auto | double | inline | short | typeid |
| bool | dynamic_cast | int | signed | typename |
| break | else | long | sizeof | union |
| case | enum | mutable | static | unsigned |
| catch | explicit | namespace | static_cast | using |
| char | export | new | struct | virtual |
| class | extern | operator | switch | void |
| const | false | private | template | volatile |
| const_cast | float | protected | this | wchar_t |
| continue | for | public | throw | while |
| default | friend | register | true | |
| delete | goto | reinterpret_cast | try |
#include<iostream>
using namespace std;
int main()
{
//创建变量：数据类型 变量名称 = 变量初始值
//不要用关键字给变量或者常量起名称
//int int = 10；报错，第二个int是关键字，不可以作为变量的名称
system("pause");
return 0;
}07 标识符命名规则
标识符命名规则
C++规定给标识符（变量、常量）命名时，有一套自己的规则
POINT：
1、标识符不能是关键字
2、标识符只能由字母、数字、下划线组成
3、第一个字符必须为字母或下划线
4、标识符中字母区分大小写
08 数据类型-整型
数据类型：C++规定在创建一个变量或常量时，必须要指定出相应的数据类型，否则无法给变量分配内存
整型：整型变量表示的是整数类型的数据
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) |
语法：数据类型 变量名 = 变量初始值 如 int a = 10；
数据类型存在意义：给变量分配合适的内存空间
#include<iostream>
using namespace std;
int main()
{
short num1 = 10;
int num2 = 10;
long num3 = 10;
long long num4 = 10;
cout << "num1=" << num1 << endl;
cout << "num2=" << num2 << endl;
cout << "num3=" << num3 << endl;
cout << "num4=" << num4 << endl;
system("pause");
return 0;
}09 数据类型-sizeof关键字
sizeof关键字
利用sizeof关键字可以统计数据类型所占内存大小
语法：sizeof（数据类型 / 变量）
#include<iostream>
using namespace std;
int main()
{
cout << "short类型所占内存空间为：" << sizeof(short) << endl;
cout << "int类型所占内存空间为：" << sizeof(int) << endl;
cout << "long类型所占内存空间为：" << sizeof(long) << endl;
cout << "long long类型所占内存空间为：" << sizeof(long long) << endl;
//可以利用sizeof求出数据类型占用内存大小
//语法：sizeof（数据类型 或 变量）
short num1 = 10;
cout << "short类型所占内存空间为：" << sizeof(short) << endl;
cout << "short类型所占内存空间为：" << sizeof(num1) << endl;
system("pause");
return 0;
}10 数据类型-实型
实型（浮点型）：用于表示小数
浮点型变量分为两种：
1.单精度float
2.双精度double
两者的区别在于表示的有效数字范围不同
POINT：
float f1 = 3.14f
| 数据类型 | 占用空间 | 有效数字范围 |
| float | 4字节 | 7位有效数字 |
| double | 8字节 | 15-16位有效数字 |
#include<iostream>
using namespace std;
int main()
{
//1、单精度float
//2、双精度double
//float占4个字节，double占8个字节
float f1 = 3.14f;
cout << "f1=" << f1 << endl;
double f2 = 3.14;
cout << "f2=" << f2 << endl;
//统计float和double所占内存空间
cout << "float占用的内存空间为：" << sizeof(float) << endl;
cout << "double占用的内存空间为：" << sizeof(double) << endl;
//科学计数法
float f3 = 3e2;//3*10^2
cout << "f3=" << f3 << endl;
float f4 = 3e-2;//3*0.1^2
cout << "f4=" << f4 << endl;
system("pause");
return 0;
}11 数据类型-字符型
字符型变量用于显示单个字符
语法：char ch = 'a';
POINT：
1、在显示字符型变量时，用单引号将字符括起来，不要用双引号；
2、单引号内只能有一个字符，不可以是字符串
3、C和C++中字符型变量只占用1个字节
4、字符串变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元
5、输出字符型变量对应的ASCII编码：cout<<(int)ch<<endl;
#include<iostream>
using namespace std;
int main()
{
//1、字符型变量创建方式
char ch = 'a';
cout << ch << endl;
//2、字符型变量所占内存大小
cout << "char字符型变量所占内存空间：" << sizeof(char) << endl;
//3、字符型变量对应ASCII编码
cout << (int)ch << endl;
//4、字符型变量对应ASCII编码
//char ch2 = "b";
//char ch2 = 'abcdef';
system("pause");
return 0;
}12 数据类型-转义字符
转义字符：用于表示一些不能显示出来的ASCII字符
常用：
\n：换行
\\：代表一个反斜线字符\
\t：水平制表（HT）跳到下
#include<iostream>
using namespace std;
int main()
{
//换行符\n
cout << "hello world\n";
//反斜杠\\
cout << "\\" << endl;
//水平制表符\t 可以整齐输出数据
cout << "aaaaaa\thelloworld" << endl;
cout << "a\thelloworld" << endl;
cout << "aa\thelloworld" << endl;
system("pause");
return 0;
}13 数据类型-字符串类型
字符串型：用于表示一串字符
两种风格
1.C风格字符串：char 变量名[ ] = "字符串值"
int main(){
char str1[] = "hello world";
cout << str1 << endl;
system("pause");
return 0;
}POINT：C风格的字符串要用双引号括起来
2.C++风格字符串：string 变量名 = "字符串值"
POINT：C++风格字符串，需要加入头文件#include
#include<string> //用C++风格字符串时，要包含这个头文件
using namespace std;
int main(){
string str2 = "hello world";
cout << str2 << endl;
system("pause");
return 0;
} 14 数据类型-布尔类型
布尔类型bool
布尔数据类型代表真或假的值
bool类型只有两个值：
true-真（本质是1）
false-假（本质是0）
bool类型占1个字节大小
#include<iostream>
using namespace std;
#include<string>
int main()
{
//1、创建bool数据类型
bool flag = true;
cout << flag << endl;//1
flag = false;
cout << flag << endl;//0
//2、查看bool类型所占内存空间
cout << "size of bool: " << sizeof(bool) << endl;
system("pause");
return 0;
}15 数据类型-数据的输入
数据的输入：用于从键盘获取数据
关键字：cin
语法：cin >> 变量
POINT：
1、用float时，注意 float f1 = 3.14f
2、string注意：加入包含string头文件#include
#include<iostream>
using namespace std;
#include<string>
int main()
{
//整型输入
int a = 0;
cout << "请输入整型变量：" << endl;
cin >> a;
cout << a << endl;
//浮点型输入
//用float时，注意float f = 3.14f
double d = 0;
cout << "请输入浮点型变量：" << endl;
cin >> d;
cout << d << endl;
//字符型输入
char ch = 'a';
cout << "请输入字符型变量：" << endl;
cin >> ch;
cout << ch << endl;
//字符串型输入
//string注意：加入头文件#include<string>
string str = "hello";
cout << "请输入字符串型变量：" << endl;
cin >> str;
cout << str << endl;
//布尔型输入
bool flag = false;
cout << "请输入布尔型变量：" << endl;
cin >> flag;
cout << flag << endl;
system("pause");
return 0;
}16 运算符-算术运算符-加减乘除运算
运算符：用于执行代码的运算
| 运算符类型 | 作用 |
| 算术运算符 | 用于处理四则运算 |
| 赋值运算符 | 用于将表达式的值赋给变量 |
| 比较运算符 | 用于表达式的比较，并返回一个真值或假值 |
| 逻辑运算符 | 用于根据表达式的值返回真值或假值 |
算术运算符：用于处理四则运算
| 运算符 | 术语 | 示例 | 结果 |
| + | 正号 | +3 | 3 |
| - | 负号 | -3 | -3 |
| + | 加 | 10+5 | 15 |
| - | 减 | 10-5 | 5 |
| * | 乘 | 10*5 | 50 |
| / | 除 | 10*5 | 2 |
| % | 取模（取余） | 10%3 | 1 |
| ++ | 前置递增 | a=2;b=++a; | a=3;b=3; |
| ++ | 后置递增 | a=2;b=a++; | a=3;b=2; |
| -- | 前置递减 | a=2;b=--a; | a=1;b=1; |
| -- | 后置递减 | a=2;b=a--; | a=1;b=2; |
17 运算符-算术运算符-取模运算
POINT：两个小数不可以做取模运算
| 运算符 | 术语 | 示例 | 结果 |
| % | 取模（取余） | 10%3 | 1 |
#include<iostream>
using namespace std;
int main()
{
int a1 = 10;
int b1 = 3;
cout << a1 % b1 << endl;
int a2 = 10;
int b2 = 20;
cout << a2 % b2 << endl;
system("pause");
return 0;
}18 运算符-算术运算符-递增递减
| 运算符 | 术语 | 示例 | 结果 |
| ++ | 前置递增 | a=2;b=++a; | a=3;b=3; |
| ++ | 后置递增 | a=2;b=a++; | a=3;b=2; |
| -- | 前置递减 | a=2;b=--a; | a=1;b=1; |
| -- | 后置递减 | a=2;b=a--; | a=1;b=2; |
#include<iostream>
using namespace std;
int main()
{
//1、前置递增；a=11
int a = 10;
++a;
cout << "a=" << a << endl;
//2、后置递增；b=11
int b = 10;
b++;
cout << "b=" << b << endl;
//前置和后置的区别
//前置递增，先让变量+1，再进行表达式运算；
//a2=11；b2=110
int a2 = 10;
int b2 = ++a2 * 10;
cout << "a2=" << a2 << endl;
cout << "b2=" << b2 << endl;
//后置递增，先进行表达式运算，再让变量+1；
//a3=11；b3=100
int a3 = 10;
int b3 = a3++ * 10;
cout << "a3=" << a3 << endl;
cout << "b3=" << b3 << endl;
system("pause");
return 0;
}19 运算符-赋值运算符
赋值运算符：用于将表达式的值赋给变量
赋值运算符包括以下几个符号：
| 运算符 | 术语 | 示例 | 结果 |
| = | 赋值 | a=2;b=3; | a=2;b=3; |
| += | 加等于 | a=0;a+=2; | a=2; |
| -= | 减等于 | a=5;a-=3; | a=2; |
| *= | 乘等于 | a=2;a*=2; | a=4; |
| /= | 除等于 | a=4;a/=2; | a=2; |
| %= | 模等于 | a=3;a%=2; | a=1; |
20 运算符-比较运算符
比较运算符：用于表达式的比较，并返回一个真值或假值
比较运算符有以下符号：
| 运算符 | 术语 | 示例 | 结果 |
| == | 相等于 | 4==3 | 0 |
| != | 不等于 | 4!=3 | 1 |
| 小于 | 4 | 0 | |
| > | 大于 | 4>3 | 1 |
| 小于等于 | 4 | 0 | |
| >= | 大于等于 | 4>=3 | 1 |
21 运算符-逻辑运算符-非
逻辑运算符：用于根据表达式的值返回真值或假值
逻辑运算符有以下符号：
| 运算符 | 术语 | 示例 | 结果 |
| ! | 非 | !a | 如果a为假，则 !a 为真；如果a为真，则 !a 为假 |
| && | 与 | a && b | 如果a和b都为真，则结果为真，否则为假 |
| || | 或 | a || b | 如果a和b有一个为真，则结果为真，二者都为假时，结果为假 |
#include<iostream>
using namespace std;
int main()
{
int a = 10;
cout<< !a <<endl;//0
cout<< !!a <<endl;//1
system("pause");
return 0;
}22 运算符-逻辑运算符-与
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int b = 10;
cout<<(a && b)<<endl;
system("pause");
return 0;
}23 运算符-逻辑运算符-或
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int b = 10;
cout<<(a || b)<<endl;
a = 0;
b = 10;
cout<<(a || b)<<endl;
system("pause");
return 0;
}24 程序流程结构-选择结构-单行if语句
程序流程结构
C/C++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构
*顺序结构：程序按顺序执行，不发生跳转
*选择结构：依据条件是否满足，有选择的执行相应功能
*循环结构：依据条件是否满足，循环多次执行某段代码
选择结构
if语句
作用：执行满足条件的语句
if语句的三种形式
*单行格式if语句：if（条件）{条件满足执行的语句}
*多行格式if语句：if（条件）{条件满足执行的语句} else {条件不满足执行的语句}；
*多条件的if语句：if（条件1）{条件1满足执行的语句} else if （条件2）{条件2满足执行的语句}... else {都不满足执行的语句}
POINT：
1、if 条件后不要加分号
2、if ( 条件 ){ 执行语句 }
#include<iostream>
using namespace std;
int main()
{
//选择结构 单行if语句
//用户输入分数，如果分数大于600，视为考上一本大学，在屏幕上输出
//1、用户输入分数
int score = 0;
cout<<"请输入您的分数："<<endl;
cin>>score;
//2、打印用户的分数
cout<<"您的分数为："<<score<<endl;
//3、判断分数是否大于600，如果大于，那么输出
if (score>600)
{
cout<<"恭喜考上一本大学"<<endl;
}
return 0;
}25 程序流程结构-选择结构-多行if语句
#include<iostream>
using namespace std;
int main()
{
//选择结构 多行if语句
//用户输入分数，如果分数大于600，视为考上一本大学，在屏幕上输出
//如果没考上一本大学，打印未考上大学
//1、用户输入分数
int score = 0;
cout<<"请输入您的分数："<<endl;
cin>>score;
//2、打印用户的分数
cout<<"您的分数为："<<score<<endl;
//3、判断 分数是否大于600，打印考上一本，否则打印未考上一本
if (score>600)
{
cout<<"恭喜考上一本大学"<<endl;
}
else
{
cout<<"未考上大学"<<endl;
}
return 0;
}26 程序流程结构-选择结构-多条件if语句
#include<iostream>
using namespace std;
int main()
{
//选择结构 多条件if语句
//用户输入分数，如果分数大于600，视为考上一本大学，在屏幕上输出
//大于500，视为考上二本大学，屏幕输出
//大于400，视为考上三本大学，屏幕输出
//小于等于400，视为未考上本科学，打印未考上大学
//1、用户输入分数
int score = 0;
cout<<"请输入您的分数："<<endl;
cin>>score;
//2、打印用户的分数
cout<<"您的分数为："<<score<<endl;
//3、判断
if (score>600)
{
cout<<"恭喜考上一本大学"<<endl;
}
else if（score >500)
{
cout<<"恭喜考上二本大学"<<endl;
}
else if (score >400)
{
cout<<"恭喜考上三本大学"<<endl;
}
else
{
cout<<"未考上大学"<<endl;
}
return 0;
}27 程序流程结构-选择结构-嵌套if语句
嵌套 if 语句：在 if 语句中，可以嵌套使用 if 语句，达到更精准的条件判断
案例需求：
*提示用户输入—个高考考试分数，根据分数做如下判断；
*分数如果大于600分视为考上一本，大于500分考上二本，大于400考上三本，其余视为未考上本科；
*在一本分数中，如果大于700分，考入北大，大于650分，考入清华，大于600考入人大。
#include<iostream>
using namespace std;
int main()
{
//嵌套 if 语句
//用户输入分数，如果分数大于600，视为考上一本大学，在屏幕上输出
//如果没考上一本大学，打印未考上大学
//1、用户输入分数
int score = 0;
cout<<"请输入您的分数："<<endl;
cin>>score;
//2、打印用户的分数
cout<<"您的分数为："<<score<<endl;
//3、判断
//如果大于600 一本
// 大于700 北大
// 大于650 清华
// 其余 人大
//如果大于500 二本
//如果大于400 三本
//其余，未考上本科
if (score > 600)
{
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;
}28 程序流程结构-选择结构案例-三只小猪称体重
练习案例：三只小猪称体重
有三只小猪ABC，请分别输入三只小猪的体重，并且判断哪知小猪最重？
#include<iostream>
using namespace std;
int main()
{
float a = 0.00f;
float b = 0.00f;
float c = 0.00f;
cout << "请输入A的体重（kg）：" << endl;
cout << "请输入B的体重（kg）：" << endl;
cout << "请输入C的体重（kg）：" << endl;
cin >> a;
cin >> b;
cin >> c;
cout << "A的体重（kg）：" << a << endl;
cout << "B的体重（kg）：" << b << endl;
cout << "C的体重（kg）：" << c << endl;
if (a > b)
{
//cout << "A比B重" << endl;
if (a > c)
{
// cout << "A比C重" << endl;
cout << "A最重" << endl;
}
}
else
{
if (b < c)
{
cout << "C最重" << endl;
}
else
{
cout << "B最重" << endl;
}
}
system("pause");
return 0;
}29 程序流程结构-选择结构案例-三目运算符
三目运算符：通过三目运算符实现简单的判断
语法：表达式1 ？ 表达式2 ： 表达式3
解释：
如果表达式1的值为真，执行表达式2，并返回表达式2的结果；
如果表达式1的值为假，执行表达式3，并返回表达式3的结果；
#include<iostream>
using namespace std;
int main()
{
//三目运算符
//创建三个变量abc，将ab作比较，将变量大的值赋给变量c
int a = 10;
int b = 20;
int c = 0;
c = (a>b?a:b);
cout<<"c="<<c<<endl;
//在C++中三目运算符返回的是变量，可以继续赋值
(a>b?a:b) = 100;
cout<<"a="<<a<<endl;
cout<<"b="<<b<<endl;
sysetm("pause");
return 0;
}30 程序流程语句-选择结构-switch语句
switch语句：执行多条件分支语句
语法：
switch（表达式）
{
case 结果1：执行语句；break；
case 结果2：执行语句；break；
...
default：执行语句；break；
}
POINT：
1、switch语句中表达式类型只能是整型或字符型
2、case里如果没有break，那么程序会一直向下执行
3、与if语句相比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间
#include<iostream>
using namespace std;
int main()
{
//switch语句
//给电影进行打分
//10~9经典
//8~7非常好
//6~5一般
//5以下烂片
//1、提示用户给电影评分
cout<<"请给电影打分"<<endl;
//2、用户开始进行打分
int score = 0;
cin>>score;
//3、根据用户输入的分数来提示用户最后的结果
switch(score)
{
case 10:
case 9:
cout<<"经典"<<endl;
break;//退出当前分支
case 8:
case 7:
cout<<"非常好"<<endl;
break;
case 6:
case 5:
cout<<"一般"<<endl;
break;
default:
cout<<"烂片"<<endl;
break;
}
//if和switch区别：
//switch缺点，判断时候只能是整型或者字符型，不可以是一个区间
//switch优点，结构清晰，执行效率高
system("pause");
return 0;
}31 程序流程结构-循环语句-while语句
while循环语句
作用：满足循环条件，执行循环语句
语法：while（循环条件）{循环语句}
POINT：
1、只要循环条件的结果为真，就执行循环语句
2、在写循环时一定要避免死循环的出现
#include<iostream>
using namespace std;
int main()
{
//while循环
//在屏幕中打印0~9这10个数字
int num = 0;
while(num < 10)
{
cout<<num<<endl;
num++;
}
system("pause");
return 0;
}32 程序流程结构-循环语句案例-猜数字
while循环练习案例：猜数字
案例描述：系统随机生成一个1到100之间的数字，玩家进行猜测，如果猜错，提示玩家数字过大或过小，如果猜对恭喜玩家胜利，并且退出游戏。
#include<iostream>
using namespace std;
//time系统时间头文件包含
#include<ctime>
int main()
{
//添加随机数种子，利用当前系统时间生成随机数，防止每次随机数都一样
srand((unsigned int)time(NULL));
//1、系统生成随机数(伪随机数)
//rand()%100生成0~99的随机数，rand()%100+1生成0+1~99+1的随机数
int num = rand() % 100 + 1;
//2、玩家进行猜测
int num1 = 0;
while (1)
{
cin >> num1;
//3、判断玩家的猜测
//猜对 退出游戏
//猜错 提示结果过大或过小
//*猜错后返回循环*
if (num1 > num)
{
cout << "猜测过大" << endl;
}
else if (num1 < num)
{
cout << "猜测过小" << endl;
}
else
{
cout << "猜对，结束游戏" << endl;
break;//break在循环中，可以利用该关键字退出循环
//break语句只能在循环语句中使用，所以使用while语句
//猜对之后才能终止循环，所以最后一处使用break语句
}
}
system("pause");
return 0;
}33 程序流程语句-循环结构-dowhile语句
do...while循环语句
作用：满足循环条件，执行循环语句
语法：do{循环语句}while（循环条件）；
POINT：与while的区别在于 do...while 会先执行一次循环语句，再判断循环条件
#include<iostream>
using namespace std;
int main()
{
//do...while语句
//在屏幕中输出0~9这10个数字
int num = 0;
do
{
cout<<num<<endl;
num++;
}
while(num<10);
system("pause");
return 0;
}34 程序流程语句-循环结构案例-水仙花数
练习案例：水仙花数
案例描述：水仙花数是指一个3位数，它的每个位上的数字的3次幂之和等于它本身
例如：1^3+5^3+3^3=153
请利用do...while语句，求出所有3位数中的水仙花数
point:== a*a*a
#include<iostream>
using namespace std;
int main()
{
//1、将所有三位数进行输出（100~999）
//2、在所有三位数中找出水仙花数（获取个位十位百位）（判断各位^3+十位^3+百位^3=本身）
/*
获取个位 153%10=3 对数字取模10，得到个位
获取十位 153/10=15 15%10=5 先整除10再取模10，得到十位
获取百位 153/100=1 整除100，得到百位
*/
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;
}35 程序流程结构-循环结构-for循环
for循环语句
作用：满足循环条件，执行循环语句
语法：for（起始表达式；条件表达式；末尾循环体）{循环语句；}
POINT：
1、for循环中的表达式，要用分号进行分隔
2、while、do...while、for都是开发中常用的循环语句，for循环结构比较清晰，比较常用
#include<iostream>
using namespace std;
int main()
{
//for循环
//打印数字0~9
for(int i = 0;i<10;i++)
{
cout<<i<<endl;
}
system("pause");
return 0;
}36 程序流程结构-循环结构案例-敲桌子
练习案例：敲桌子
案例描述：从1开始数到数字100，如果数字个位含有7，或者数字十位含有7，或者该数字是7的倍数，我们打印敲桌子，其余数字直接打印输出。
#include<iostream>
using namespace std;
int main()
{
/*
1、先输出1~100
2、从这100个数字中找到特殊数字，改为“敲桌子”
3、特殊数字
7的倍数---num%7 = 0
个位有7---num%10 = 7；
十位有7---num/10 = 7；
*/
for (int i = 1; i <= 100; i++)
{
if (i%7 == 0 || i%10 == 7 || i/10 == 7)
{
cout << "敲桌子" << endl;
}
else
{
cout << i << endl;
}
}
system("pause");
return 0;
}37 程序循环结构-嵌套循环
嵌套循环
作用：在循环体中再嵌套一层循环，解决一些实际问题
#include<iostream>
using namespace std;
int main
{
//利用嵌套循环实现星图
//打印一行星图
for (int i = 0;i<10;i++)
{
for(int j = 0;j<10;j++) //嵌套循环变量修改名称
{
cout<<"* ";
}
cout<<endl; //换行
}
//外层执行一次，内层执行一周
//外层循环
for (int i = 0;i<10;i++)
{
//内层循环
for (int j = 0;j<10;j++)
{
cout<<"* ";
}
cout<<endl;
}
system("pause");
return 0;
}38 程序流程结构-嵌套循环案例-乘法口诀表
练习案例：乘法口诀表
案例描述：利用嵌套循环，实现九九乘法表
#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;
cout << j << "*" << i << "=" << j * i << " ";
}
cout << endl;
}
system("pause");
return 0;
}39 程序流程结构-跳转语句-break语句
break语句
作用：用于跳出选择结构或循环结构
break使用的时机：
*出现在switch条件语句中，作用是终止case并跳出switch
*出现在循环语句中，作用是跳出当前的循环语句
*出现在嵌套循环中，跳出最近的内层循环语句
#include<iostream>
using namespace std;
int main()
{
//break的使用时机
//1、出现在switch语句中
cout<<"请选择副本难度"<<endl;
cout<<"1、普通"<<endl;
cout<<"2、中等"<<endl;
cout<<"3、困难"<<endl;
int select = 0; //创建选择结果的变量
cin>>select; //等待用户输入
switch(select)
{
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;
}
cout<<i<<endl;
}
//3、出现在嵌套循环语句中
for (int i = 0;i<10;i++)
{
for (int j = 0;j<10;j++)
{
if(j == 5)
{
break;
}
cout<<"* "；
}
cout<<endl;
}
system("pause");
return 0;
}40 程序流程语句-跳转语句-continue
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;
}41 程序流程结构-跳转语句-goto
goto语句
作用：可以无条件跳转语句
语法：goto 标记；
解释：如果标记的名称存在，执行到goto语句时，会跳转到标记的位置
POINT：goto 标记；
标记：
#include<iostream>
using namespace std;
int main()
{
//goto语句
cout<<"1、XXXX"<<endl;
cout<<"2、XXXX"<<endl;
goto FLAG;
cout<<"3、XXXX"<<endl;
cout<<"4、XXXX"<<endl;
FLAG:
cout<<"5、XXXX"<<endl;
system("pause");
return 0;
}42 数组-一维数组定义方式
数组
概述：所谓数组，就是一个集合，里面存放了相同类型的数据元素
POINT：
1、数组中的每个数据元素都是相同类型的数据类型
2、数组是由连续的内存位置组成的
3、数组名的命名规范和变量名命名规范一样，不要和变量重名
4、数组中下标是从0开始索引
一维数组
一维数组定义的三种方式：
1、数据类型 数组名 [ 数组长度 ]；
2、数据类型 数组名 [ 数组长度 ] = { 值1，值2...}；
3、数据类型 数组名 [ ] = { 值1，值2...}；
arr 从0开始索引，我们可以通过下标访问数组中的元素
| 10 | 20 | 30 | 40 | 50 |
arr[0] arr[1] arr[2] arr[3] arr[4]
#include<iostream>
using namespace std;
int main()
{
//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...}；
//如果在初始化数据的时候没有全部填写完，会用0来填补剩余数据
int arr2[5] = {10,20,30,40,50};
//cout<<arr2[0]<<endl;
//cout<<arr2[1]<<endl;
//cout<<arr2[2]<<endl;
//cout<<arr2[3]<<endl;
//cout<<arr2[4]<<endl;
//利用循环输出 数组中的元素
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;
}
system("pause");
return 0;
}43 数组-一维数组-数组名
一维数组数组名
一维数组名称的用途：
1、可以统计整个数组在内存中的长度 sizeof（arr）
2、可以获取数组在内存中的首地址 sizeof（arr[ 0 ]）
3、可以通过数组名查看数组首地址 (int)&arr[ i ]
4、数组名是常量，不可以进行赋值操作
#include<iostream>
using namespace std;
int main()
{
//数组名用途
//1、可以通过数组名统计整个数组占用内存大小i
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<<"数组首地址为："<<(int)arr<<endl;记下行即可
cout<<"数组中第一个元素地址为："<<(int)&arr[0]<<endl;
cout<<"数组中第二个元素地址为："<<(int)&arr[1]<<endl;
//数组名是常量，不可以进行赋值操作
//arr = 100;
system("pause");
return 0;
}44 数组-一维数组案例-五只小猪称体重
练习案例1：五只小猪称体重
案例描述：在一个数组中记录了五只小猪的体重，如：int arr [5] = { 300,350,200,400,250 }；找出并打印最重的小猪体重
#include<iostream>
using namespace std;
int main()
{
/*
int max = 0;
访问数组中每个元素，如果这个元素比我认定的最大值要大，更新最大值
1、创建5只小猪的数组
2、从数组中找到最大值
3、打印最大值
*/
int arr[5] = { 300,350,200,400,250 };
int max = 0;
for (int i = 0; i < 5; i++) //遍历数组
{
//cout << arr[i] << endl;
if (arr[i] > max)
{
max = arr[i];
}
}
cout << "最重的小猪体重为：" << max << endl;
system("pause");
return 0;
}45 数组-一维数组案例-元素逆置
练习案例2：数组元素逆置
案例描述：请声明一个5个元素的数组，并且将元素逆置，如原数组元素为：1，3，2，5，4；逆置后输出结果为：4，5，2，3，1
#include<iostream>
using namespace std;
int main()
{
/*
int start = 0; 起始元素下标
int end = sizeof(arr)/sizeof(arr[0]) -1 末尾元素下标
strat和end下标元素进行互换
int temp = arr[start]; 临时变量
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
如果start<end,执行互换
*/
//1、打印逆置前的数组
int arr[5] = { 1,3,2,5,4 };
cout << "数组逆置前：" << endl;
for (int i = 0; i < 5; i++)
{
cout << arr[i] << endl;
}
//2、实现逆置
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;
}46 数组-一维数组-冒泡排序
冒泡排序
作用：最常用的排序算法，对数组内元素进行排序
详解：
1.比较相邻的元素，如果第一个比第二个大，就交换他们两个；
2.对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值；
3.重复以上的步骤，每次比较次数-1，直到不需要比较
POINT：
1、排序总轮数 = 元素个数 - 1
2、每轮对比次数 = 元素个数 - 排序轮数 - 1
eg：将数组{ 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;
}47 数组-二维数组定义方式
二维数组：就是在一维数组上，多加一个维度
二维数组定义的四种方式：
1.数组类型 数组名[ 行数 ][ 列数 ]；
2.数组类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2}，{数据3，数据4} }；
3.数组类型 数组名[ 行数 ][ 列数 ] = {数据1，数据2，数据3，数据4} ；
4.数组类型 数组名[ ][ 列数 ] = {数据1，数据2，数据3，数据4} ；
POINT：
以上4种定义方式，使用第二种更加直观，提高代码可读性
#include<iostream>
using namespace std;
int main()
{
//1.数组类型 数组名[ 行数 ][ 列数 ]；
int arr[2][3];
arr[0][0] = 1;
arr[0][1] = 2;
arr[0][2] = 3;
arr[1][0] = 4;
arr[1][1] = 5;
arr[1][2] = 6;
//cout<<arr[0][0]<<endl;
//外层循环打印行数，内层循环打印列数
for (int i = 0;i<2;i++)
{
for (int j = 0;j<3;j++)
{
cout<<arr[i][j]<<endl;
}
}
//2.数组类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2}，{数据3，数据4} }；
int arr2[2][3] =
{
{1,2,3},
{4,5,6}
};
for (int i = 0;i<2;i++)
{
for (int j = 0;j<3;j++)
{
cout<<arr2[i][j]<<" ";
}
cout<<endl;
}
//3.数组类型 数组名[ 行数 ][ 列数 ] = {数据1，数据2，数据3，数据4} ；
int arr3[2][3] = {1,2,3,4,5,6};
for (int i = 0;i<2;i++)
{
for (int j = 0;j<3;j++)
{
cout<<arr3[i][j]<<" ";
}
cout<<endl;
}
//4.数组类型 数组名[ ][ 列数 ] = {数据1，数据2，数据3，数据4} ；
int arr4[][3] = {1,2,3,4,5,6};
for (int i = 0;i<2;i++)
{
for (int j = 0;j<3;j++)
{
cout<<arr4[i][j]<<" ";
}
cout<<endl;
}
system("pause");
return 0;
}48 数组-二维数组-数组名
二维数组数组名
作用：查看二维数组所占内存空间；获取二维数组首地址
#include<iostream>
using namespace std;
int main()
{
//1、查看占用内存空间大小
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;
//2、查看二维数组的首地址
cout<<"二维数组首地址为："<<int(arr)<<endl;
cout<<"二维数组第一行首地址为："<<int(arr[0])<<endl;
cout<<"二维数组第二行首地址为："<<int(arr[1])<<endl;
cout<<"二维数组第一个元素首地址为："<<(int)&arr[0][0])<<endl;
system("pause");
return 0;
}49 数组-二维数组案例-考试成绩统计
二维数组应用案例：考试成绩统计
案例描述：有三名同学（张三、李四、王五）在一次考试中的成绩分别如下表，请分别输出三名同学的总成绩
| 语文 | 数学 | 英语 | |
| 张三 | 100 | 100 | 100 |
| 李四 | 90 | 50 | 100 |
| 王五 | 60 | 70 | 80 |
#include<iostream>
using namespace std;
#include<string>
int main()
{
/*
1、创建二维数组，3行3列
2、统计考试成绩，让每行的三列相加，统计总和（嵌套循环）
*/
int scores[3][3] =
{
{100,100,100},
{90,50,100},
{60,70,80}
};
string names[3] = { "张三","李四","王五" };
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] << " ";
}
cout <<names[i]<< "的总分为：" << sum << endl;
}
system("pause");
return 0;
}50 函数-函数的定义
函数概述：
作用：将一段经常使用的代码封装起来，减少重复代码
一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能
函数的定义：
函数的定义一般主要有五个步骤：
1、返回值类型
2、函数名
3、参数列表
4、函数体语句
5、return 表达式
语法：
返回值类型 函数名（参数列表）
{
函数体语句
return 表达式
}
eg：实现一个加法函数，功能是，传入两个整型数据，计算数据相加的结果，并且返回
1、返回值函数 int
2、函数名 add
3、参数列表 （int num1，int num2）
4、函数体语句 int sum = num1 + num2；
5、return 表达式 return sum；
语法：
返回值类型 函数名（参数列表） int add(int num1,int num2)
{ {
函数体语句 int sum = num1 + num2;
return 表达式 return sum;
} }
51 函数-函数的调用
函数的调用
功能：使用定义好的函数
语法：函数名（参数）
#include<iostream>
using namespace std;
#include<string>
//定义加法函数
//函数定义的时候，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;
}52 函数-值传递
值传递
所谓值传递，就是函数调用时实参将数值传入给形参
值传递时，如果形参发生改变，并不会影响实参
#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;返回值不需要的时候，可以不写return；
}
int main()
{
int a = 10;
int b = 20;
//当我们做值传递的时候，函数的形参发生改变，并不会影响实参
swap(a, b);
cout << "a=" << a << endl;
cout << "b=" << b << endl;
system("pause");
return 0;
}53 函数-常见的样式
函数的常见样式：
1、无参无返
2、有参无返
3、无参有返
4、有参有返
POINT：
"void"类型的值不能用于初始化"int"类型的实体
#include<iostream>
using namespace std;
//函数常见样式
//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 10;
}
//4、有参有返
int test04(int a)
{
cout << "this is test04 a=" << a << endl;
return a;
}
int main()
{
//无参无返函数调用
test01();
//有参无返函数调用
test02(100);
//无参有返函数调用
int num1 = test03();
cout << "num1=" << num1 << endl;
//有参有返函数调用
int num2 = test04(10000);
cout << "num2=" << num2 << endl;
system("pause");
return 0;
}54 函数-函数的声明
函数的声明
作用：告诉编译器函数名称及如何调用函数，函数的实际主体可以单独定义
POINT：
函数的声明可以多次，但是函数的定义只能有一次
55 函数-函数的分文件编写
函数的分文件编写
作用：让代码结构更加清晰
函数分文件编写一般有4个步骤：
1、创建后缀名为 .h 的头文件；
2、创建后缀名为 .cpp 的源文件；
3、在头文件中写函数的声明；
4、在源文件中写函数的定义
56 指针-指针的定义和使用
指针
作用：可以通过指针间接访问内存（通过指针来保存一个地址）
指针 = 地址
p=&a;
a=*p
POINT：
*内存编号是从0开始记录的，一般用十六进制数字表示；
*可以利用指针变量保存地址；
指针变量定义语法：数据类型 * 指针变量名；
指针p
取址符号&
a的地址：&a
解引用：*p
指针前加*代表解引用，找到指针指向的内存中的数据
例：
int a=10;
10的地址为0X0000；
指针p保存的地址为0X00000；int* p=&a;
那么解引用*p为指向内存中的数据（a=10），即为10；
#include<iostream>
using namespace std;
int main()
{
//1、定义指针
int a = 10;
//指针定义的语法：数据类型 * 指针变量名；
int* p;
//让指针记录变量a的地址
p = &a;
cout << "a的地址为：" << &a << endl;
cout << "指针p为：" << p << endl;
//p = a
//2、使用指针
//可以通过解引用的方式来找到指针指向的内存
//指针前加*代表解引用，找到指针指向的内存中的数据
*p = 1000;//通过*p修改这段内存
cout << "a=" << a << endl;
cout << "*p=" << *p << endl;
system("pause");
return 0;
}57 指针-指针所占内存空间
指针所占内存空间
指针也是种数据类型，这种数据类型占用的内存空间：
指针变量的创建、定义、使用
占用多少字节？
//在32位操作系统下，指针是占4个字节空间大小，不管是什么数据类型
//在64位操作系统下，指针是占8个字节空间大小
x86为32位
x64为64位
#include<iostream>
using namespace std;
int main()
{
//指针所占内存空间
int a = 10;
int* p = &a;
cout << "sizeof(int*)=" << sizeof(p) << endl;
//输出看数据（变量、数据类型）占内存空间多大
//cout << "sizeof(int*)=" << sizeof(int *) << endl;此时p和int* 是一样的
//在32位操作系统下，指针是占4个字节空间大小，不管是什么数据类型
//在64位操作系统下，指针是占8个字节空间大小
cout << "sizeof(int*)=" << sizeof(int*) << endl;
cout << "sizeof(int*)=" << sizeof(float*) << endl;
cout << "sizeof(int*)=" << sizeof(double*) << endl;
cout << "sizeof(int*)=" << sizeof(char*) << endl;
system("pause");
return 0;
}58 指针-空指针
空指针和野指针
空指针：指针变量指向内存中编号为0的空间
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的
#include<iostream>
using namespace std;
int main()
{
//空指针
//1、空指针用于给指针变量进行初始化
int* p = NULL;
//2、空指针是不可以进行访问的，访问会出错
//0~255之间的内存编号是系统占用的，因此不可以访问
*p = 100;
system("pause");
return 0;
}59 指针-野指针
野指针：指针变量指向非法的内存空间
#include<iostream>
using namespace std;
int main()
{
//野指针
//在程序中，尽量避免出现野指针
int* p = (int*)0x1100;//0x1100这段内存空间未申请，不能访问
cout << *p << endl;//报错，读取访问权限冲突
system("pause");
return 0;
}60 指针-const修饰指针
const 修饰指针
const 修饰指针有三种情况：
1、const 修饰指针 -- 常量指针 const int * p = &a; 指向√值× *p=20（×）;p=&b（√）; 取*操作×（const后面为*）
2、const 修饰常量 -- 指针常量 int * const p = &a; 指向×值√ *p=20（√）;p=&b（×）; 对p操作×（const后面为p）
3、const 既修饰指针，又修饰常量 const int * const p = &a; 指向×值× *p=20（×）;p=&b（×）;
记忆：const记忆为常量，*记忆为指针；用来区分常量指针和指针常量；
#include<iostream>
using namespace std;
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 = 100;//正确
//p2 = &b；错误，指针指向不可改
//3、const修饰指针和常量
const int* const p3 = &a;
//指针的指向和指针指向的值都不可以改
//*p3 = 100；错误
//p3 = &b；错误
system("pause");
return 0;
}61 指针-指针和数组
指针和数组
作用：利用指针访问数组中元素
注意：数组名就是数组的首地址，使用p++来让指针向后偏移4个字节来获取后面的地址
#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;//数组名就是数组首地址；
cout << "利用指针访问第一个元素：" << *p << endl;
p++;//让指针向后偏移4个字节
cout << "利用指针访问第二个元素" << *p << endl;
//利用指针遍历数组《重要！！！！！！》
cout << "利用指针遍历数组" << endl;
int* p2 = arr;
for (int i = 0; i < 10; i++)
{
//cout<<arr[i]<<endl;此方法为不使用指针遍历
cout << *p2 << endl;
p2++;//i=0时，输出arr[0]，p2++之后，向右偏移4个，变为arr[1]，遍历输出
}
system("pause");
return 0;
}62 指针-指针和函数
指针和函数
作用：利用指针作函数参数，可以修改实参的值
注意：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递
#include<iostream>
using namespace std;
//值传递
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()
{
//值传递
int a = 10;
int b = 20;
swap01(a, b);
cout << "a=" << a << endl;
cout << "b=" << b << endl;
//地址传递
swap02(&a, &b);//传递的是ab变量的地址
cout << "a=" << a << endl;
cout << "b=" << b << endl;
system("pause");
return 0;
}63 指针-指针配合数组和函数案例
案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序
例如数组：int arr [10] = { 4,3,6,9,1,2,10,8,7,5 };
//案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序
//例如数组：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++)
{
//如果j>j+1，交换数字
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 };
//2、创建函数，实现冒泡排序
int len = sizeof(arr) / sizeof(arr[0]);
bubbleSort(arr, len);
//3、打印排序后的数组
printArray(arr, len);
system("pause");
return 0;
} 64 结构体-结构体定义和使用
结构体
结构体基本概念
结构体属于用户自定义的数据类型，允许用户存储不同的数据类型
结构体定义和使用
语法：struct 结构体名 { 结构体成员列表 } ；
通过结构体创建变量的方式有三种：
1、struct 结构体名 变量名
2、struct 结构体名 变量名 = { 成员1值，成员2值... }
3、定义结构体时顺便创建变量
#include<iostream>
using namespace std;
#include<string>
//1、创建学生数据类型：学生包括（姓名、年龄、分数）
//自定义数据类型，一些类型集合组成的一个类型
//语法 struct 类型名称{ 成员列表 }
struct Student//struct不可省略
{
string name;
int age;
int score;
};
//2、通过学生类型创建具体学生
int main()
{
//2.1 struct Student s1
//struct关键字可以省略
struct Student s1;//给s1属性赋值，通过 . 访问结构体变量中的属性//struct可以省略
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 在定义结构体时顺便创建结构体变量
/*
在第一步创建学生类型时，做如下修改
struct Student
{
string name;
int age;
int score;
}s3;----顺便创建结构体变量
*/
system("pause");
return 0;
}POINT：
1、定义结构体时的关键字是struct，不可省略；
2、创建结构体变量时，关键字struct可以省略；
3、结构体变量利用操作符" . "访问成员；
65 结构体-结构体数组
结构体数组
作用：将自定义的结构体放入到数组中方便维护
语法：struct 结构体名 数组名[ 元素个数 ] = { {}，{}，... ，{} }
#include<iostream>
using namespace std;
#include<string>
//结构体数组
//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 = 80;
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;
}66 结构体-结构体指针
结构体指针
作用：通过指针访问结构体中的成员
注意：利用操作符 -> 可以通过结构体指针访问结构体属性
记忆点：
1、通过指针指向结构体变量 Student* p = &s;
2、输出cout p->name p->age p->score
#include<iostream>
using namespace std;
#include<string>
//结构体指针
//定义学生结构体
struct Student
{
string name;
int age;
int score;
};
int main()
{
//1、创建学生结构体遍历
Student s = { "张三",18,100 };
//2、通过指针指向结构体变量
Student* p = &s;
//3、通过指针访问结构体变量中的数据
cout << "姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl;
system("pause");
return 0;
}67 结构体-结构体嵌套结构体
结构体嵌套结构体
作用：结构体中的成员可以是另一个结构体
例如：每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体
#include<iostream>
using namespace std;
#include<string>
//定义学生结构体
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 = 10000;
t.name = "老王";
t.age = 50;
t.stu.name = "小王";
t.stu.age = 20;
t.stu.score = 60;
cout << "老师姓名：" << t.name << "老师编号：" << t.id << "老师年龄：" << t.age << endl;
cout<< "老师辅导的学生姓名：" << t.stu.name << "学生年龄：" << t.stu.age << "学生分数：" << t.stu.score << endl;
system("pause");
return 0;
}68 结构体-结构体做函数参数
结构体做函数参数
作用：将结构体作为参数向函数中传递
传递方式有两种：
值传递：形参改变，实参不会改变
地址传递：形参改变，实参也改变
如果不想修改主函数中的数据，用值传递，反之用地址传递
#include<iostream>
using namespace std;
#include<string>
struct student
{
string name;
int age;
int score;
};
//值传递
void printStudent1(student s)
{
s.age=100;
cout<<"子函数1"<<s.name<<s.age<<s.score<<endl;
}
//地址传递
void printStudent2(student* p)
{
p->age=200;
cout<<"子函数2"<<p->name<<p->age<<p->score<<endl;
}
int main()
{
student s;
s.name="zhang";
s.age=20;
s.score=85;
//值传递和地址传递
printStudent1(s);
printStudent2(&s);
cout<<"主函数"<<s.name<<s.age<<s.score<<endl;
return 0;
}69 结构体-结构体中const使用场景
结构体中const使用场景
作用：用const来防止误操作
const限定只读状态，防止修改操作
#include<iostream>
using namespace std;
#include<string>
struct student
{
string name;
int age;
int score;
};
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudent(const student *s) //添加const使得不能修改
{
//s->age = 160;无法修改
cout << s->name << s->age << s->score << endl;
}
int main()
{
student s = { "zhang",15,70 };
printStudent(&s);
system("pause");
return 0;
}70 结构体-结构体案例1
案例描述：
学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下：
设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和1一个存放5名学生的数组作为成员
学生的成员有姓名、考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值
最终打印出老师数据以及老师所带的学生数据
#include<iostream>
using namespace std;
#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];//追加ABCDE
//通过循环给每名老师所带的学生赋值
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 <<
" 学生成绩" << 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;
}总结：
1、追加姓名后缀nameSeed；
2、学生成绩添加随机数种子
71 结构体-结构体案例2
案例描述：
设计一个英雄的结构体，包括成员姓名，年龄，性别；创建结构体数组，数组中存放5名英雄
通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排列，最终打印排序后的结果
#include<iostream>
using namespace std;
#include<string>
//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];
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]);
cout << "排序前打印：" << endl;
for (int i = 0; i < len; i++)
{
cout << "姓名：" << heroArray[i].name << " 年龄：" << heroArray[i].age
<< " 性别："<< heroArray[i].sex << endl;
}
//3、对数组进行排序，按照年龄进行升序排序
bubbleSort(heroArray, len);
//4、将排序后结果打印输出
cout << "排序后打印：" << endl;
printHero(heroArray, len);
system("pause");
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
