C++既可以面向过程编程，也可以面向对象编程。面向过程编程就是程序员需要告诉计算机怎么做。面向过程的编程和C语言基本一致。

一、选择结构

（一）if语句

C++的if语句的一般形式为：

if（表达式）
语句1
else
语句2

含义：
当表达式为真时运行语句1，不为真就运行语句2。其中else及其后面部分是可选的，即当表达式不为真时不执行其他操作，仅当表达式为真执行语句1。
当没有else部分时，称为单行if语句，存在else部分称为多行if语句。

  1.     int a;
  2.     cout << "请输入高考分数：" << endl;
  3.     cin >> a;
  4.     cout << "您的分数为： " << a << endl;
  6.     //单行if语句
  8.     if (a >= 600)  //if语句后不能加分号
  9.     {
  10.         cout << "恭喜您考上重大" << endl;    //满足条件，如果需要执行多行代码，则需要加大括号
  11.     }
  13.     //多行if语句
  15.     if (a >= 600)  //if语句后不能加分号
  16.         cout << "恭喜您考上重大" << endl;   //满足条件执行
  17.     else
  18.         cout << "抱歉，继续加油" << endl;   //不满足条件执行

（二）多条件if语句

if语句包含else部分，而else部分里面包含另一个if语句，这个内嵌if语句的else部分又是另一个if语句，如此循环既是一个内嵌多层的if语句。
多条件if语句的形式一般为：

if（表达式1）
语句1
else if（表达式2）
语句2
…
else if（表达式n-1）
语句n-1
else
语句n

含义·：
当表达式1为真，只执行语句1；当表达式1不为真，表达式2为真，就只执行语句2，如此规则下，如果表达式1到表达式n-1都不为真，则只执行语句n。

  1.     int math;
  2.     cout << "请输入您的数学成绩：" << endl;
  3.     cin >> math;
  5.     if (a >= 600)         //第一个条件
  6.     {
  7.         if (math > 120)    //嵌套if语句
  8.             cout << "恭喜您考上重大" << endl;
  9.         else
  10.             cout << "抱歉，请继续加油" << endl;
  11.     }
  12.     else if(math==150)   //第二个条件
  13.         cout << "恭喜您考上重大" << endl;
  14.     else
  15.         cout << "抱歉，请继续加油" << endl;

（三）嵌套if语句

嵌套if语句是指一个if语句的if部分和else部分分别存在一个不同的内嵌if语句，其一般形式如下（注意与多条件if语句的区别）：

if（表达式1）
if（表达式2）
语句1
else
语句2
else
if（表达式3）
语句3
else
语句4

含义：
当表达式1为真时，若表达式2同时为真，则执行语句1，否则执行语句2；当表达式1不为真时，若表达式3为真时，执行语句3，否则执行语句4。

  1. if (a >= 600)         //第一个条件
  2.     {
  3.         if (math > 120)    //嵌套if语句
  4.             cout << "恭喜您考上重大" << endl;
  5.         else
  6.             cout << "抱歉，请继续加油" << endl;
  7.     }
  8.     else 
  9.     {
  10.         if(math==150)   //第二个条件
  11.             cout << "恭喜您考上重大" << endl;
  12.         else
  13.             cout << "抱歉，请继续加油" << endl;
  14.     }

（四）switch语句

多条件if语句和嵌套if语句在情况较多时，结构比较复杂，不易书写和阅读。switch语句是一种多分支语句，用来实现多分枝选择结构，形式简单，可读性高。其一般形式如下：

switch（表达式）
{
case 常量表达式1：
语句1
case 常量表达式2：
语句2
…
case 常量表达式n：
语句n
default：
语句n+1

含义：
根据表达式的值跳转至选择对应的case语句，并执行对应的语句。当表达式的值没有对应的case语句，则执行default语句的语句n+1。（swtich语句一般需要配合跳转语句使用，详情见跳转语句部分）

  1.     int score = 0, b;
  2.     cout << "请给电影进行打分：" << endl;
  3.     cin >> score;
  5.     switch (b)
  6.     {
  7.     case 2:                                 //只能是整型和字符型，不可以是区间
  8.         cout << "您认为电影很好看" << endl;
  9.         break;
  10.     case 1:
  11.         cout << "您认为电影一般" << endl;
  12.         break;
  13.     case 0:
  14.         cout << "您认为电影不好看" << endl;
  15.         break;
  16.     default:
  17.         cout << "请输入正确的打分" << endl;
  18.     }

（五）三目运算符

当程序在某一位置只需要一个进行一个判断选择，可以选用三目运算符进行简化书写。
三目运算符的一般形式为：

（表达式）？（语句1）：（语句2）

含义：
当表达式为真时，执行语句1，否则执行语句2。

  1.     int a = 10;
  2.     int b = 20;
  3.     int c = 0;
  5.     (a > b) ? (c = a) : (c = b);  //取大值
  6.     //c = (a > b) ? a : b;
  7.     cout << "c =" << c << endl;
  9.     //三目运算符选择的是变量，可以继续对其赋值
  10.     (a > b ? a : b) = 100;        //因为b>a，所以表达式返回的是变量b，等价于b=100
  11.     cout << ("a = ") << a << endl;
  12.     cout << ("b = ") << b << endl;

二、循环结构

（一）while语句

当程序需要反复执行某一操作时，就可以使用循环控制结构。
while语句的一般形式为：

while（表达式）
语句

含义：
当表达式为真时，执行while语句中的循环体。
特点：
先判断，再执行。
注意：
1、如果循环体存在一个以上的语句，需要用大括号括起来。
2、循环体中需要有使循环结束的语句。

  1. #include<iostream>
  2. #include<ctime>                 //time系统时间头文件，用于随机数生成
  3. using namespace std;
  5. int main()
  6. {
  7.     //随机生成1-100的随机数，系统提醒玩家猜的数大了还是小了
  9.     //添加随机数种子，利用当前系统时间生成随机数，防止每次随机数一样
  10.     srand((unsigned int)time(NULL));
  12.     int target = rand() % 100+1;   //随机生成一个1-100的目标随机数字，伪随机数
  13.     int num = 0;                 //猜测值
  15.     while (num != target)
  16.     {
  17.         cout << "请输入你猜测的数字：" << endl;
  18.         cin >> num;
  19.         if (num > target)
  20.             cout << "猜大了，你再猜" << endl;
  21.         if(num < target)
  22.             cout << "猜小了，你再猜" << endl;
  23.     }
  25.     cout << "恭喜你答对了，这数是：" << target << endl;
  27.     system("pause");
  29.     return 0;
  30. }

（二）do while语句

do while循环结构的一般形式为：

do
语句
while（表达式）

含义：
当程序运行到此处时，先执行一次循环体语句，再进行表达式判断，表达式为真则继续执行循环体，否则结束循环。
特点：
先执行，后判断。

  1. #include<iostream>
  2. #include<math.h>           //数学计算头文件
  3. using namespace std;
  5. int main()
  6. {
  7.     //找到所有的水仙花数
  8.     //水仙花数：三位数字，每一位数的三次方之和等于这个数
  10.     int num = 100;
  11.     int a, b, c;
  13.     do
  14.     {
  15.         a = num / 100;          //求数字的百位
  16.         b = (num / 10) % 10;    //求数字的十位
  17.         c = num % 10;           //求数字的个位
  19.         if (num == pow(a, 3) + pow(b, 3) + pow(c, 3))          //pow（x，y）表示x的y次方
  20.         {
  21.             cout << num << endl;
  22.         }
  23.         num++;
  24.     } while (num < 1000);
  26.     system("pause");
  28.     return 0;
  29. }

（三）for循环语句

for语句一般用于已经确定循环次数的循环结构中，同时也可以用于不确定循环次数的循环结构中，在常见情况下是可以代替while语句的。
for语句的一般结构为：

for（表达式1：表达式2：表达式3）
语句

更为一般的形式为：

for（循环变量赋初值：循环条件：循环变量增值）
语句

其中语句就是循环体，当循环体不只一条语句时，需要用大括号括起来。
语句1可以省略，取而代之在for循环前赋初值；语句2省略则表示循环不结束，进入死循环；同样的，语句3也可以省略，但需要保证循环能正常结束。

  1. #include<iostream>
  2. using namespace std;
  4. int main()
  5. {
  6.     //敲桌子
  7.     //输出0-100中含有7和七的倍数
  9.     for (int i = 0; i <= 100; i++)
  10.     {
  11.         if ((i % 7 == 0) || (i % 10 == 7) || (i / 10 == 7))  //(i % 7 == 0):7的整数倍    (i % 10 == 7)：个位数为7     (i / 10 == 7)：十位数字为7
  12.             cout << "敲桌子" << endl;
  13.         else
  14.             cout << i << endl;
  15.     }
  18.     system("pause");    //保持在输出窗口
  20.     return 0;
  21. }

三、嵌套循环

循环的嵌套是指一个循环里包含另一个循环。3种循环结构可以相互嵌套。3种循环结构两两组合成的新结构都是合法结构（以for语句嵌套for语句为例）：

for（表达式1：表达式2：表达式3）
{
for（表达式4：表达式5：表达式6）
{
…
}
}

外层循环执行一次就需要将内层循环完全执行结束以便。

  1. #include<iostream>
  2. using namespace std;
  4. int main()
  5. {
  7.     //打印矩阵*图
  8.     //利用嵌套循环
  10.     int i = 0, j = 0;
  11.     for (i = 0; i < 10; i++)
  12.     {
  13.         for (j = 0; j < 10; j++)           //输出行
  14.         {
  15.             cout << "* ";
  16.             //if (j >= 9)                    //一行输出结束
  17.             //{
  18.             //    cout << endl;              //换行
  19.             //}
  20.         }
  21.         //j = 0;                             //行计数值归零
  22.         cout << endl;
  23.     }
  25.     system("pause");    //保持在输出窗口
  27.     return 0;
  28. }

四、跳转语句

（一）break语句

一般用于提前结束某一循环过程，其一般形式为：

break；

break语句最为常见时用于switch语句中（代码见switch语句），同时可以用于其他循环语句的循环体中，用于提前结束循环。不能单独用于其他语句中。

  1. switch (num)
  2.     {
  3.     case 1:
  4.         cout << "您选择的是简单难度" << endl;
  5.         break;
  6.     case 2:
  7.         cout << "您选择的是普通难度" << endl;
  8.         break;
  9.     case 3:
  10.         cout << "您选择的是困难难度" << endl;
  11.         break;
  12.     }

（二）continue语句

continue语句的作用是提前结束本次循环并跳转到下一次循环（循环条件满足情况下），一般结构为：

continue；

用于循环体中使本次循环结束，跳过continue下面的语句直接进入下一次循环判定。注意与break语句的区别，break语句直接结束所在循环结构的所用循环，开始执行其他语句。

  1. #include<iostream>
  2. using namespace std;
  4. int main()
  5. {
  7.     //continue语句：结束当前循环，不执行循环之中剩余语句，进入下一次循环
  9.     //输出奇数，不输出偶数
  11.     int a = 0;
  12.     for (a; a < 30; a++)
  13.     {
  14.         if (a % 2 == 0)
  15.             continue;                 //用于筛选条件
  16.         cout << a << endl;
  17.     }
  19.     system("pause");    //保持在输出窗口
  21.     return 0;
  22. }

可以将break语句代码块中的break改成continue观察输出结果。

（三）goto语句

goto语句的作用时直接使程序跳转到指定位置处开始执行，形式为：

goto 标志

…
标志：
…

含义：
当程序运行到goto语句时，直接将程序跳转到设置的标志处继续执行，标志可以位于程序的任何位置。可以实现一定的循环效果，不推荐使用，会增大程序阅读的体验和程序的稳定性。

  1. #include<iostream>
  2. using namespace std;
  4. int main()
  5. {
  6.     //goto语句
  7.     //直接跳转至标志处
  8.     //不推荐使用，影响代码阅读体验
  10.     cout << "请选择关卡难度" << endl;
  11.     goto flag;                               //goto 标志
  12.     cout << "1。简单" << endl;
  13.     cout << "2。普通" << endl;
  14.     flag:                                    //标记
  15.     cout << "3。困难" << endl;
  17.     system("pause");    //保持在输出窗口
  19.     return 0;
  20. }

END