记录跳转

程序流程结构

1.类别

结构	作用
顺序结构	程序按顺序执行，不发生跳转
选择结构	依据条件是否满足，有选择的执行相应功能
循环结构	依据条件是否满足，循环多次执行某段代码

2.选择结构

if语句

作用

执行满足条件语句。

语法

①.单行格式if语句：

if (条件)
{
条件满足执行的语句
}

②.多行格式if语句：

if (条件)
{
条件满足执行的语句
}
else
{
条件不满足执行的语句
}

③.多条件的if语句：

if (条件1)
{
条件1满足执行的语句
}
else if (条件2)
{
条件2满足执行的语句
}
...
else
{
所有条件均不满足执行的语句
}

注意

①.if条件语句末尾不加分号。
②.嵌套if语句

if （条件1）
{
  if (条件2)
  { 
   条件1满足下且符合条件2执行的语句
  }
}

三目运算符

作用

实现简单的判断。

语法

表达式1 ? 表达式2 : 表达式3

如果表达式1为真，执行表达式2，并返回表达式2的结果。
如果表达式1为假，执行表达式3，并返回表达式3的结果。

实践

①.尝试创建a、b和c三个变量，并运用三目运算符将b与c变量中较大的值赋给a？

int a = 0;
int b = 1;
int c = 2;

a = b>c?b:c;

因为b>c为假，所以执行给a赋c的值。

②.尝试结合①给由三目运算符返回的变量重新赋值为3？

(b>c?b:c) = 3;

【注意：C++中三目运算符返回的是变量，可以继续赋值。】

switch语句

作用

执行多条件分支语句。

语法

switch (表达式)

{
  case 结果1:
       表达式结果为结果1时执行语句
       （break;）

  case 结果2:
       表达式结果为结果2时执行语句
       （break;）

  ...

  default:
       表达式结果没有满足的时执行的语句
       （break;）
}

注意

①.当遇到break语句时，switch终止，控制流将跳转到switch语句后的下一行。
case下的break：不是每一个 case都需要包含break。如果case语句不包含break，控制流将会继续后续的case和里面的输出且无视case后的赋值条件，直到遇到break为止（如果default下面依然没有break将意味着输出了整个switch里的所有语句）。所以当只想根据case条件选择一个输出时，要在每个case下加break。
default下的break：当default放在所有case下（即绝大多数的情况），可以不加break。但如果default下仍有case，则需要考虑是否加break跳出switch还是不加break执行下面case里的语句。
② .if和switch的区别？
执行效率：switch > if
【注：switch结构更清晰。】
适用性：if > switch
【注：switch判断的时候表达式必须是一个整型或枚举类型，或者是一个 class类型，如int、short、char、byte，enum。但string，Long、double、float都不能作用于swtich。且switch的判断值不可以是一个区间。但if判断时表达式可以为一个区间。】

3.循环结构

while语句

作用

满足循环条件，执行循环语句。

语法

while(循环条件)
{
循环语句
}

实践

①.尝试运用while循环语句在屏幕上输出0~9这10个数字？

int num = 0;

while (num <= 9)
{
  cout << num << endl;
  num++;
}

②.【案例：猜数字】系统生成随机数（1~100），玩家进行猜测，猜对则退出，猜错则提示过大或过小。

srand((unsigned int)time(NULL));
int num = rand()% 100 +1;
int guess = 0;

while (1)
{
 cout <<"请输入您猜测的数字？"<< endl;
 cin >> guess;

  if (guess > num)
  {
    cout << "要比您猜的数字小呢。"<< endl;
  }
  else if (guess < num)
  {
    cout << "要比您猜的数字大呢。"<< endl;
  }
  else
  {
  cout <<"恭喜猜对了欸!"<< endl;
  break;
  }
}

注意

①.当while语句中循环条件填写非0的数字时，相当于“真”（即没有条件），将持续不断地执行其内部的循环语句（即出现死循环）。
②.C++中生成伪随机数的函数rand来表示0~上限-1，其语法如下：

rand()% 上限;

③.如何打破伪随机数？可以在创建的随机数对应的变量前添加随机数种子，利用系统时间生成随机数。
其语法如下：

srand((unsigned int)time(NULL));

当然，你需要先添加time系统时间头文件#include< ctime >。
④.在循环中可以运用关键字break来退出循环。

do...while语句

作用

先执行一次循环语句，其后若满足循环条件，执行循环语句。

语法

do
{
循环语句
}
while (循环条件);

注意

①.do...while语句中while()后有分号。

实践

①.【案例：水仙花数】输出所有三位的水仙花数。

int num = 100;

do
{
int ge = num % 10;
int shi = num / 10 % 10;
int bai = num / 100;

   if (ge*ge*ge + shi*shi*shi +     
       bai*bai*bai== num )
   {
    cout << num << endl;
   }

num++;
}
while (num <= 999);

注意

①.取三位数的个位、十位和百位...的方法：
个位——取模于10；
十位——除于10再取模于10；
百位——除于100；
②.【错误补正】在实践①中：
第一次尝试的时候把个十百位的变量放到了if语句的前面，这样这三个变量的赋值只进行1次，而不是依次取递增的num的个十百位。

for语句

作用

满足循环条件，执行循环语句。

语法

for (起始表达式;条件表达式;末尾循环体)
{
循环语句
}

实践

①.【案例：敲桌子】依次输出1-100且把其中个位或者十位是7或者是7的倍数的数字替换为敲桌子。

for (int num =1;num<101;num++)
{
 if (num%10 == 7 || num/10 == 7 || num%7 == 0)
 {
  cout << "敲桌子" << endl;
 }
 else
 {
  cout << num << endl;
}

注意

①.for语句后括号内的三个表达式都可以拆分成单行。实际上执行的循环顺序为：起始表达式（只执行1次）→条件表达式（即循环条件）→循环语句→末尾循环体。
②.for语句的结构比较清晰。
③.【优解补正】在实践①中：
判断循环条件时我用了好多else if，答案把各个循环条件运用逻辑运算符“||”放在一个if里。
且我创建了三个变量，其实可以直接书写在循环条件表达式里。

嵌套循环

作用

在循环体中再嵌套一层循环。

实践

①.尝试输出一份10x10的星（由*构成）图？

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 << "x" << i << "=" << j*i << "  ";
 }
 cout << endl;
}

注意

①.嵌套循环的原理：外层执行一次，内层执行一周。
②.【错误补正】在实践①中for循环语句括号里第一个起始表达式一定要书写数据类型。
③.就近原则：
如果在嵌套循环外层与内层两个变量名一样，那么输出的变量的值取就近的该变量的值。
④.【错误补正】在实践②中：
此处内外两层起始表达式可以拆分到各自的循环体上方，但不可都放于外层循环体上面创建，否则内层循环体执行一周后，其变量j在外层第二次循环时不会重新从初始值计算，而是外层第一次循环结束时的值（即i的值）。这样得到的乘法表只是两个相同的数相乘的所有程式。
换行应写在外层循环体，若写在内层循环体则将每输出一个程式便换一行，最终结果一个程式一行。实际想要的是效果是内层循环体执行一周后再换行。

4.跳转语句

break语句

作用

跳出选择结构或者循环结构。

类型

使用时机	作用
switch条件语句	终止case并跳出switch
循环语句	跳出当前循环语句
嵌套循环	跳出最近的内层循环语句

语法

①.switch条件语句情况下：

swith (表达式)

{
  case 结果1:
       表达式结果为结果1时执行语句
       break;

  case 结果2:
       表达式结果为结果2时执行语句
       break;

  ...

  default:
       表达式结果没有满足的时执行的语句
       break;
}

②.循环语句情况下：

for (起始表达式;条件表达式;末尾循环体)
{
 if (条件)
 {
  break;
 }
 循环语句
}

②.嵌套循环语句情况下：

for (起始表达式1;条件表达式1;末尾循环体1)
{
 for (起始表达式2;条件表达式2;末尾循环体2)
 {
  if (条件)
  {
   break；
  }
 循环语句1
 }
 循环语句2
}

continue语句

作用

在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环。

实践

①.尝试运用循环语句和continue语句输出0~100中的所有奇数？

for (int i = 0;i <= 100;i++)
{
 if (i%2 == 0)
 {
  continue;
 }
 cout << i << endl;
}

注意

①.break语句与continue语句的区别：
continue并不会直接使循环终止，而是不执行循环体内位于其下方的语句，可以搭配if语句使用；但break语句会直接跳出循环体，终止循环。

goto语句

作用

无条件跳转代码。

语法

goto 标记;

实践

①.尝试运用goto语句随意书写几行代码输出些东西？

cout<< "些" ;
cout<< "东" ;
goto SHAKUAMEJI;

cout<< "喵喵喵" << endl;

SHAKUAMEJI:
cout<< "西" << endl;

注意

①.标记一般写成纯大写的单词，命名规则和标识符命名规则相符。
②.如果标记在goto语句的上方相当于循环且很可能是死循环。

数组

1.作用

作为一个集合，在里面存放了相同类型的数据元素

2.类别

①.一维数组
②.二维数组

3.一维数组

语法

①.

数据类型 数组名[ 数组长度 ];

②.

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

③.

数据类型 数组名[] = { 值1,值2... };

实践

①.尝试声明一个5个元素的数组并从中输出最大值？

int arr[5] = {1,3,4,2,5};
int max = 0;

for(int i = 0 ;i<5;i++)
{
 if ( arr[i] > max )
 {
  max = arr[i];
 }
}
cout << max;

②.【案例：元素逆置】声明一个5个元素的数组并使元素排列顺序倒置并输出,但不允许直接引用具体下标进行替换。

int arr[5] = {1,2,3,4,5};
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--;
}

cout << "元素逆置后arr[5] = {";

for(int i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
{
 cout << arr[i] ;
 if (i < end)
 {
  cout << ",";
 }
}
cout << "}";
cout << endl;

注意

①.数组中的每个数据元素都是相同的数据类型。
②.数组是由连续的内存位置组成的。
③.下标：
图片.png
④.数组内元素下标从0开始索引。
⑤.若初始化数组内数据时填写的值数少于数组长度，则会用0来填补剩余值数的数据。
⑥.数组名的命名与变量命名规则一致，且不能和变量名重复。但数组名是一个常量，不能对数组名重新赋值。
⑦.一维数组数组名用途：
1）统计整个数组或莫个下标对应的元素在内存中的长度：

sizeof (数组名或数组名[下标])

2）统计数组中元素个数：

sizeof(数组名)/sizeof(数组名[0])

【注：因此求数组中末尾元素下标为：sizeof(数组名)/sizeof(数组名[0]) - 1 。】
3）获取数组在内存中的首地址：
十六进制：

cout << 数组名;

十进制：

cout << (int)数组名;

【注：数组的首地址即第一个元素的地址。】
4）获取数组中某个下标对应的元素在内存中的首地址：
十六进制：

cout << &数组名[下标];

十进制：

cout << (int)&数组名[下标];

冒泡排序

作用

最常用的排序算法，对数组内的元素进行排序。

实践

①.尝试将数组arr{4,2,8,0,5,7,1,3,9}进行升序排序并输出？

int arr[9]={4,2,8,0,5,7,1,3,9};

for (int i = 0;i<9;i++)
{
 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 << "升序排序后arr[9] = {";

for(int a = 0;a<sizeof(arr)/sizeof(arr[0]);a++)
{
 cout << arr[a];
 if (a < sizeof(arr)/sizeof(arr[0])-1)
 {
  cout << ",";
 }
}
cout << "}";
cout << endl;

注意

①.逻辑：
1）将所有元素分为两两相邻的一组，比较相邻的元素，若第一个比第二个大，则交换他们两个。
2）对每一对相邻元素做相同的工作，执行完毕后，找到最一个最大数（即换序完最后一个）。
3）重复以上步骤，每轮比较次数-1（因为上一次工作中最后两个相邻元素第一个一定小于第二个），直至不需要比较。
②.规律：
1）排序总轮数 = 元素个数 - 1
2）每轮对比次数 = 元素个数 - 排序轮数 - 1
（这里的排序轮数依然是从0开始计数）
③.实践①中的“替换逻辑”要熟记：
先把前者存入temp，再把前者赋值成后者，最后把后者赋值成temp。

4.二维数组

语法

①.

数据类型 数组名[行数][列数];
数组名[行][列] = 值1;
数组名[行][列] = 值2;
数组名[行][列] = 值3;
数组名[行][列] = 值4;
...

②.

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

③.

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

④.

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

实践

①.【案例：成绩之和统计】A、B和C一同参加3场考试，假设A取得100，100，100；B取得70，80，90；C取得40，50，60。请分行输出三人的成绩之和。

char names[3] = {'A','B','C'};
int scores[3][3] = 
{
 {100,100,100},
 {70,80,90},
 {40,50,60},
};

for (int i = 0;i<3;i++)
{
 int sum = 0;
 for (int j = 0;j<3;j++)
 {
  sum += scores[i][j];
 }
  cout << names[i] << "的总成绩为：" << sum << "分。\n";
}

注意

①.一般采用语法中第②种创建数组，因为其更直观且可读性强。
②.可以利用嵌套循环输出二维数组（矩阵）内所有元素：外层循环创建行的下标变量，外层循环创建行的下标变量。打印矩阵效果则可以在内层循环体下方加入输出换行。
③.二维数组数组名用途：
1）统计整个数组或第n行或第x行第y列对应的元素在内存中的长度：

sizeof (数组名或数组名[n-1]或数组名[x-1][y-1])

【注：因此二维数组行数为：sizeof(数组名)/sizeof(数组名[0])。】
【注：因此二维数组列数为：sizeof(数组名[0])/sizeof(数组名[0][0])。】
2）获取二维数组首地址或其第n行首地址：
十六进制：

cout << 数组名或数组名[n-1] ;

十进制：

cout << (int)数组名或(int)数组名[n-1] ;

【注：实际上二维数组首地址，第一行首地址，第一个元素首地址相同。】
2）获取二维数组第x行第y列元素首地址：
十六进制：

cout << &数组名[x-1][y-1];

十进制：

cout << (int)&数组名[x-1][y-1];

④.【忘却补正】在实践①中：
书写二维数组语法频繁出错，应注意：每行的开头结尾都有大括号；除最后一行外的前面所有行末尾都有逗号；最后一个回大括号后面还有一个分号。
书写创建char语法时出错，应注意：要用单引号将赋值的每一个字符括起来。
尾句书写转义字符换行时出错，应注意：换行的转义字符是反斜线+n，反斜线是\（“向右为反”！！！正斜线一般用于目录！！！）。

函数

作用

将一段经常使用的代码封装起来，减少重复代码。

语法

返回值类型 函数名(参数列表)
{
 函数体语句

 return 表达式
}

注意

①.一个较大的程序，一般分为若干程序块，每个模块实现特定的功能。
②.参数列表是什么意思呢？
即对使用函数时输入的数据。比如我要输入一个整数，则参数列表为：int num1 。
③.返回值类型和return表达式的关系？
返回值类型与return表达式返回的数据类型应相同。

函数的调用

作用

使用定义好的函数

语法

函数名 (参数);

实践

①.尝试定义一个整数加法函数并在main函数中调用并输出？

int add (int num1,int num2)
{
 int sum;
 sum = num1 + num2;
 return sum;
}

int main()
{ 
 int a;
 int b;
 cout <<"请输入第一个整数？"<<endl
 cin >> a;
 cout <<"请输入第二个整数？"<<endl
 cin >> b; 
 int sum = add(a,b);
 cout << "它们相加之和为：" << sum <<endl;

 system("pause");
 return 0;
}

注意

①.实践①中num1、num2叫形式参数（形参），a、b叫实际参数（实参）。当调用函数时，实参的值会传递给形参。
②.【忘却补正】在实践①中：
书写add函数体语句时，忘记为sum创建变量。
书写mian函数体语句时，多次忘记为文本输出两端加双引号。
忘记书写mian函数return表达式。

值传递

作用

在调用函数时，将实参数值传递给形参。且在值传递时，形参发生改变并不会影响实参。

实践

①.尝试定义一个可以实现交换输入的两个变量数值的函数，并输出交换后的结果？

void swap(int num1,int num2)
{
 int temp = num1;
 num1 = num2;
 num2 = temp;

 cout<<"交换后num1的值为："<< num1 <<endl;
 cout<<"交换后num2的值为："<< num2 <<endl;
}

int main()
{
 int a;
 int b;
 cout<<"请为整型变量num1赋值？"<<endl;
 cin>>a;
 cout<<"请为整型变量num2赋值？"<<endl;
 cin>>b;

 swap(a,b);

 system("pause");
 return 0;
}

注意

①.如果定义函数时不需要返回值，则可以声明返回值类型为void，并且return表达式也不需要写或者只写为return;。
②.【错误补正】在实践①中：
当前在做值传递，即使形参num1，num2交换改变，但实参a，b不受影响，因此若想通过调用swap输出交换，则应该在swap函数体里书写输出语句。
且需要注意swap函数和main函数里创建的变量并不通用，swap函数体中只能出现参数列表里或在函数体语句内创建的变量名。
③.为什么上一组实践即加法函数中没有值传递时形参不影响实参的问题？
因为上一组实践①中：main函数输出语句引用的是sum，sum是add函数中额外创建的变量，它既不是形参也不是实参。