《C++》第1章——第111章

1、Windows开发环境的准备
1）下载Visual Studio 2022安装文件
从微软官方网站下载，网址：https://visualstudio.microsoft.com/zh-hans/

选中Community 2022，它是Visual Studio 2022官方免费社区版，无需注册，不需要破解和盗版。（请不要从国内的其它网站下载安装文件，有病毒和插件）
下载后的文件名是VisualStudioSetup.exe。
2）安装Visual Studio 2022
双击安装文件VisualStudioSetup.exe。

2、Linux开发环境
本课程适用于各种Linux发行版，建议采用CentOS7.0至CentOS7.9之间的版本，它是目前企业在实际项目开发中最广泛采用的Linux版本。
Linux基础知识的学习，请见https://space.bilibili.com/627875426/channel/seriesdetail?sid=720603
用root登录，执行以下命令，将安装gcc和g++编译器以及gdb调试器。
yum -y install gcc gcc-c++ gdb
几十秒即可安装完成。
3、第一个C++程序
VS2022太方便了，它可以帮我们生成一个最简单的C++程序。
1）用VS生成最简单的C++程序
鼠标双击Visual Studio 2002，运行它。

点击“创建新项目”。

选择“控制台应用”，再点“下一步”。

点击“创建”后将生成一个最简单的C++程序。

2）运行C++程序
选择“调试->开始执行“菜单，或快捷键Ctrl+F5运行程序。
3）示例
// 包含头文件。
#include

// main函数，程序从这里开始执行，每个程序只能有一个main函数。
int main()
{
// 在控制台输出一首诗。
std::cout << “\n\n 我是一只傻傻鸟\n”;
std::cout << " 生活美好如鲜花，不懂享受是傻瓜；\n";
std::cout << " 傻呀傻呀傻呀傻，不如小鸟和乌鸦。\n";
std::cout << " 芳草地啊美如画，谁要不去是傻瓜；\n";
std::cout << " 我是一只傻傻鸟，独在枯枝丫上趴。\n";

// std::cout         向控制台输出内容的指令，只能小写，不能用大写。
// <<              输出的运算符。
// ""               字符串内容的边界符，半角。
// Hello World!     输出字符串的内容，可以是中文、英文和任意符号，半角的双引号除外。
// \n               输出一个换行。
// ;                 C++语句结束的标志，半角。

}
4、C++输出数据
数据是信息的载体，写程序的目的就是为了处理数据。
1）数据的分类
数据有数字、字符和字符串三种类型。
 数字：直接书写，如：100、18.52、0、9；
 字符：用半角的单引号包含的一个符号，如：‘A’、‘Z’、‘0’、‘9’、‘~’、‘+’，汉字和全角的标点符号不是字符；
 字符串：用半角的双引号包含的多个符号，如：“Hello World”、“我是一只傻鸟”、“西施”、“100”、“X”。
2）输出数据
 std::cout可以输出各种类型的数据；
 <<操作符可以拼接多个数据项；
 std::endl也可以用于换行；
 using namespace std;指定缺省的命名空间。
3）示例
#include

// 指定缺省的命名空间。
using namespace std;

int main()
{
// 用多个数据项输出超女信息，姓名：西施；年龄：25；体重：48.5；性别：X
// std::cout << “姓名：西施；年龄：25；体重：48.5；性别：X\n”;
cout << “姓名：” << “西施” << “；年龄：” << 25 << “；体重：” << 48.5
<< “；性别：” << ‘X’ << endl;
}
5、程序的注释
在程序中添加的说明文字，对代码的流程或功能加以解释，方便自己和其他的程序员阅读和理解代码。
编译器在编译源代码的时候，会忽略注释。
1）单行注释
用两根反斜线打头，一般放在代码的上方，或者一行语句的末尾。
注意：字符串内容中的两根反斜线是内容的一部分，不是注释。
2）多行注释
从/开始，到/结束，把一些内容夹住。
注意：a）字符串内容中的/和/是内容的一部分，不是注释；b）/和/可以出现在一行代码的中间。
3）注释的注释
单行注释可以注释多行注释，多行注释也可以注释单行注释，但是，不建议使用。
4）VS中的快捷键
添加注释：Ctrl+k+c
取消注释：Ctrl+k+u
5）示例
// 包含头文件。
#include

using namespace std; // 指定缺省的命名空间。

// main函数，程序从这里开始执行，每个程序只能有一个main函数。
int main()
{
// 在控制台输出一首诗。
cout << “\n\n 我是一只傻傻鸟\n”;
cout << " 生活美好如鲜花，不懂享受是傻瓜；\n";
cout << " 傻呀傻呀傻呀傻，不如小鸟和乌鸦。\n";
cout << " 芳草地啊美如画，谁要不去是傻瓜；\n";
cout << " 我是一只傻傻鸟，独在枯枝丫上趴。\n";

cout << "姓名：" << "西施" << /*"；年龄：" << 25 << */"；体重：" << 48.5 << "。" << endl;

/*
 std::cout         向控制台输出内容的指令，只能小写，不能用大写。
 <<              输出的运算符。
 ""               字符串内容的边界符，半角。
 Hello World!     输出字符串的内容，可以是中文、英文和任意符号，半角的双引号除外。
 \n               输出一个换行。
 ;                 C++语句结束的标志，半角。
 */

}
6、使用变量
变量是内存变量的简称，用于存放数据。
1）声明变量
变量在使用之前要先声明。
语法：数据类型 变量名
C++常用的数据类型有五种：整数（int）、浮点数（float和double）、字符（char）、字符串（string）和布尔（bool）。
变量在声明的时候可以赋初始值。
语法：数据类型 变量名=值
2）变量的赋值
语法：变量名=值
3）示例
#include // 包含头文件。

using namespace std; // 指定缺省的命名空间。

// main函数，程序从这里开始执行，每个程序只能有一个main函数。
int main()
{
// 整数（int）、浮点数（float和double）、字符（char）、字符串（string）和布尔（bool）。
// 超女基本信息：姓名、年龄、体重、性别、颜值。
// 声明变量，存放超女基本信息的数据项。
string name = “西施”; // 姓名。
int age = 25; // 年龄。
double weight = 48.6; // 体重（kg）。
char sex = ‘X’; // 性别：X-女；Y-男。
bool yz = false; // 颜值：true-漂亮；false-不漂亮。

cout << "姓名：" << name << "，年龄：" << age << "，体重：" << weight 
     << "，性别：" << sex << "，颜值：" << yz << endl;

name = "冰冰";           // 字符串有双引号包含。
age = 23;                // 整数直接书写。
weight = 50.5;           // 浮点数直接书写。
sex = 'X';                // 字符用单引号包含。
yz = true;                // 布尔型取值只能是true和false，或1和0。

cout << "姓名：" << name << "，年龄：" << age << "，体重：" << weight
     << "，性别：" << sex << "，颜值：" << yz << endl;

}
注意，布尔型变量输出的时候，如果值是true，将显示1，false显示0。
7、使用常量
常量是程序中固定不变的数据。
1）宏常量
一般在main函数的上面声明，用大写命名。
语法：#define 常量名 值
2）const修饰的变量
在程序的任何地方都可以声明。
语法：const 数据类型 常量名=值
3）常量的特点
程序中不允许改变常量的值，否则编译的时候会报错。
4）示例
#include // 包含头文件。

#define MONTHS 12 // 一年中的月份数。
#define PI 3.14159 // 圆周率。

using namespace std; // 指定缺省的命名空间。

// main函数，程序从这里开始执行，每个程序只能有一个main函数。
int main()
{
const int days = 7; // 一个星期中的天数。

cout << "一年有" << MONTHS << "个月。" << endl;
cout << "圆周率的值是：" << PI << endl;

cout << "一个星期有" << days << "天。\n";

}
8、标识符的命名
1）C++命名规则
C++规定给标识符（变量、常量、函数、结构体、类等）命名时，必须遵守以下规则。
 在名称中只能使用字母字符、数字和下划线；
 名称的第一个字符不能是数字；
 名称区分大写字符与小写字符；
 不能将C++关键字用作名称；
 以下划线和大写字母打头的名称被保留给编译器及其使用的资源使用，如果违反了这一规则，会导致行为的不确定性。
 C++对名称的长度没有限制，但有些平台可能有长度限制（64字符）。
C++提倡有一定含义的名称（望名知义）。
2）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

9、输入数据
程序输入数据的方式有多种。
 从控制台的界面中输入（网页、PC桌面程序、APP程序）；
 从文件中读取；
 从数据库中读取；
 从网络中读取。
1）用std::cin输入数据
语法：std::cin>>变量名;
注意：
 a）布尔型变量的值在计算机内部用1（true）和0（false）存储；b）程序中可以书写true和false，也可以书写1和0，其它值将强制转换成1；c）用cin输入时可以填1和0，其它值也强制转换成1；d）用cout输出时只显示1和0，不显示true和false。
 如果输入的数据与变量的数据类型不匹配，会导致行为的不确定性。
2）示例
#include // 包含头文件。

using namespace std; // 指定缺省的命名空间。

// main函数，程序从这里开始执行，每个程序只能有一个main函数。
int main()
{
string name; // 姓名。
cout << “请输入超女的姓名：”;
cin >> name;
cout << “输入的超女姓名是：” << name << endl;

int age;               // 年龄。
cout << "请输入超女的年龄：";
cin >> age;
cout << "输入的超女年龄是：" << age << endl;

double weight;        // 体重（kg）。
cout << "请输入超女的体重（kg）：";
cin >> weight;
cout << "输入的超女体重是：" << weight << endl;

char sex;              // 性别：X-女；Y-男。
cout << "请输入超女的性别（X-女；Y-男）：";
cin >> sex;
cout << "输入的超女性别是：" << sex << endl;

bool yz;               // 颜值：true-漂亮；false-不漂亮。
cout << "请问输入超女的颜值（1-漂亮；0-不漂亮）：";
cin >> yz;
cout << "输入的超女颜值是：" << yz << endl;

}
10、算术运算
运算符 描述

• 两个数相加。

• 一个数减另一个数。

• 两个数相乘。
  / 分子除以分母。
  % 取模运算，整除后的余数。
  注意：
   整数进行除法运算时，如果分母为0，程序将异常退出；
   浮点数进行除法运算时，如果分母为0.0，将得到inf（infinite，无穷大）；
   两个整数进行除法运算时，将舍去小数部分，得到一个整数；
   整数与浮点数进行除法运算时，得到的结果是浮点数；
   进行除法运算时，在整数前面加(float)或(double)可以将整数转换为float或double类型；
   取模运算只能用于整数（分母也不能为0）。
  11、自增和自减
  运算符 描述
  ++变量名 先把变量的值加1，然后再执行表达式。
  变量名++ 先执行表达式，再把变量的值加1。
  –变量名 先把变量的值减1，然后再执行表达式。
  变量名-- 先执行表达式，再把变量的减1。
  12、赋值运算
  1）赋值运算
  运算符 示例 描述
  = c = a + b; 将把a + b的值赋给c。 把右边操作数的值赋给左边操作数。
  += c += a; 相当于 c = c + a; 加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数。
  -= c -= a; 相当于 c = c - a; 减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数。
  *= c *= a; 相当于 c = c * a; 乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数。
  /= c /= a; 相当于 c = c / a; 除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数。
  %= c %= a; 相当于 c = c % a; 求余数且赋值运算符，求两个操作数的模赋值给左边操作数，浮点数不适用取余数。
  注意：
   字符串（string）只能使用等号（=）赋值，不能使用其它的赋值运算符；
   浮点数不能使用%=运算符；
   等号（=）赋值运算符可以连续使用；
   如果赋值运算符两边操作数的数据类型不同，C++将自动转换数据类型，可能会损失精度，也可能超出取值范围，如果转换不成功，编译时会报错。
  2）示例
  #include // 包含头文件。

using namespace std; // 指定缺省的命名空间。

// main函数，程序从这里开始执行，每个程序只能有一个main函数。
int main()
{
int a = 10;
int c = 20;

// c += a;                       // c=c+a;
// c -= a;                        // c=c-a;
// c *= a;                        // c = c * a;
// c /= a;                        // c = c / a;
//c %= a;                       // c = c % a;
// cout << "c=" << c << endl;

a = c = 30;
cout << "a=" << a<<endl;
cout << "c=" << c << endl;

}
13、C++11初始化赋值

1）C++和C++11初始化赋值
 把值写在小括号中，等于号可以省略（C++标准）
int a=(15); // 声明变量a，初始化值为15。
int b(20); // 声明变量b，初始化值为20。
 把值写在花括号中，等于号也可以省略（C++11标准），统一初始化列表。
int a={15}; // 声明变量a，初始化值为15。
int b{20}; // 声明变量b，初始化值为20。
注意：在Linux平台下，编译需要加-std=c++11参数。
2）示例
#include // 包含头文件。

using namespace std; // 指定缺省的命名空间。

// main函数，程序从这里开始执行，每个程序只能有一个main函数。
int main()
{
int a = 10;
int b = (10);
int c(10);
int e = {10};
int f{ 10 };

cout << "a=" << a << endl;
cout << "b=" << b << endl;
cout << "c=" << c << endl;
cout << "e=" << e << endl;
cout << "f=" << f << endl;

}
14、关系运算
用于比较两个表达式的值，运算的结果为1-true和0-false。
1）关系运算
关系 数学的表示 C++的表示
等于 = ==
不等于 ≠ !=
小于 < <
小于等于 ≤ <=
大于 > >
大于等于 ≥ >=
注意：
 关系运算符的两边可以是数值，也可以是表达式；
 用std::cout输出关系运算表达式时，关系表达式要加括号；
 关系运算也适用于字符串（string），字符串常用的关系运算是==和!=，其它的基本上不用。
2）示例
#include // 包含头文件。

using namespace std; // 指定缺省的命名空间。

// main函数，程序从这里开始执行，每个程序只能有一个main函数。
int main()
{
int a = 7;
int b = 7;
bool result;

result = a <= b-3;            // a和b先做比较（关系）运算，然后再赋值给result。

cout << "result=" << result << endl;    // 关系运算表达式需要括号，算术运算表达式可以不用括号。

string str1 = "西施";
string str2 = "西瓜";
cout << (str1 ==> str2) << endl;

}
 
15、逻辑运算
1）逻辑运算
根据给定的逻辑因子（表达式或值）返回一个新的逻辑因子。
运算符 术语 示例 结果
&& 逻辑与 a&&b; 如果a和b都为真，则结果为真，否则为假。
|| 逻辑或 a||b; 如果a和b中有一个为真，则结果为真，二者都为假时，结果为假。
! 逻辑非（反） !a; 如果a为假，则!a为真； 如果a为真，则!a为假。
注意：
 逻辑运算符的两边可以是数值，也可以是表达式；
 用std::cout输出逻辑运算表达式时，逻辑表达式要加括号；
 在实际开发中，逻辑运算的多重组合是重点。
2）示例
#include // 包含头文件。

using namespace std; // 指定缺省的命名空间。

// main函数，程序从这里开始执行，每个程序只能有一个main函数。
int main()
{
bool a = false;
bool b = true;
// bool c = a && b; // 如果a和b都为真，则结果为真，否则为假。
// bool c = a || b; // 如果a和b中有一个为真，则结果为真，二者都为假时，结果为假。
bool c = !a; // 如果a为假，则!a为真； 如果a为真，则!a为假。

// cout << "c=" << c << endl;
// cout << "a&&b=" << (a && b) << endl;
// cout << "a||b=" << (a || b) << endl;
cout << "!a=" << c << endl;

}

///

#include // 包含头文件。

using namespace std; // 指定缺省的命名空间。

// main函数，程序从这里开始执行，每个程序只能有一个main函数。
int main()
{
// 超女必须满足四个条件：年龄25岁以下，身高165以上、体重50公重以下，颜值要漂亮。
int age = 23;
int height = 168;
double weight = 48.8;
bool yz = true;

cout << "result="<<(age<25&&height>165&&weight<50&&yz==true) << endl;

}

16、逗号运算
1）逗号运算
把一行语句中的多个表达式连接起来，程序将从左到右执行表达式。
语法：表达式一,表达式二,……,表达式n;
逗号运算常用于声明多个变量。
int a,b; // 声明变量a和b。
int a=10,b=20; // 声明变量a和b并初始化。
也可以用于其它语句中，但是，逗号运算符是所有运算符中级别最低的，以下两个表达式的效果是不同的。
int a,b;
b=a=2,a2;
b=(a=2,a2);
2）示例
#include // 包含头文件。

using namespace std; // 指定缺省的命名空间。

// main函数，程序从这里开始执行，每个程序只能有一个main函数。
int main()
{
/*int a =10, b=20;

cout << "a=" << a << endl;
cout << "b=" << b << endl;*/

int a, b;
//b = a = 2, a * 2;
b = (a = 2, a * 2);
cout << "a=" << a << endl;
cout << "b=" << b << endl;

}
17、运算的优先级
1）运算的优先级
一个表达式可以包含多个运算符，运算符的优先级决定了表达式各部分的执行顺序。
例如，按照运算规则， *的优先级比+高，所以的b * c将先执行：
a + b * c;
如果想让a + b先执行，则必须使用括号：
(a + b) * c;
如果一个表达式中操作符的优先级相同，那么它们的结合律（associativity）决定了它们的执行顺序（从左到右或从右到左）。例如，算术运算的组合方式是从左到右，赋值运算则是从右到左。如下：
表达式 结合律 组合方式
a/b%c 从左到右 (a/b)%c
a=b=c 从右到左 a=(b=c)
下表是全部运算符的优先级和结合律：
优先级 运算符 名称或含义 使用形式 结合方向
1 [] 下标 地址[表达式] 左到右
() 圆括号 （表达式）/函数名(形参表)
. 成员选择（对象） 对象.成员名
-> 成员选择（指针） 对象指针->成员名
2 - 负号运算符 -表达式 右到左
(类型) 强制类型转换 (数据类型)表达式
++ 前置自增运算符 ++变量名
++ 后置自增运算符 变量名++
– 前置自减运算符 --变量名
– 后置自减运算符 变量名--
* 取值运算符 指针变量
& 取地址运算符 &变量名
! 逻辑非运算符 !表达式
~ 按位取反运算符 ~表达式
sizeof 长度运算符 sizeof(表达式)
3 / 除 表达式/表达式 左到右
* 乘 表达式表达式
% 余数（取模） 整型表达式/整型表达式
4 + 加 表达式+表达式 左到右
- 减 表达式-表达式
5 << 左移 变量 左到右
>> 右移 变量>>表达式
6 > 大于 表达式>表达式 左到右
>= 大于等于 表达式>=表达式
< 小于 表达式
<= 小于等于 表达式
7 == 等于 表达式==表达式 左到右
!= 不等于 表达式!= 表达式
8 & 按位与 表达式&表达式 左到右
9 ^ 按位异或 表达式^表达式 左到右
10 | 按位或 表达式|表达式 左到右
11 && 逻辑与 表达式&&表达式 左到右
12 || 逻辑或 表达式||表达式 左到右
13 ?: 条件运算符 表达式1? 表达式2: 表达式3 右到左
14 = 赋值运算符 变量=表达式 右到左
/= 除后赋值 变量/=表达式
= 乘后赋值 变量=表达式
%= 取模后赋值 变量%=表达式
+= 加后赋值 变量+=表达式
-= 减后赋值 变量-=表达式
<<= 左移后赋值 变量
>>= 右移后赋值 变量>>=表达式
&= 按位与后赋值 变量&=表达式
^= 按位异或后赋值 变量^=表达式
|= 按位或后赋值 变量|=表达式
15 , 逗号运算符 表达式,表达式,… 左到右
注意：
 如果不确定运算符的优先级，可以加括号；
 多用括号，让代码的可读性更好。
2）示例
#include // 包含头文件。

using namespace std; // 指定缺省的命名空间。

// main函数，程序从这里开始执行，每个程序只能有一个main函数。
int main()
{
int a, b, c;

c = 10;                             // 赋值表达式的值为赋值符号右边的值。
cout << "(c = 10)=" << (c = 10) << endl;

a = b = c = 10;               // 赋值运算的结合律是从右到左。

}

///
#include // 包含头文件。

using namespace std; // 指定缺省的命名空间。

// main函数，程序从这里开始执行，每个程序只能有一个main函数。
int main()
{
int a, b, c, d;

a = 4, b = 2, c = 5;

d = a * (b / c);                       // 算术运算的结合律是从左到右。

cout << "d=" << d << endl;

}
 
18、if语句的基本结构
语法：
if (表达式)
{
// 表达式为真时执行的语句。
}
else
{
// 表达式为假时执行的语句。
}
注意：
 if (表达式)之间的空格可以不写。
 表达式必须使用括号。
 表达式可以是具体的值。
 表达式一般是关系运算和逻辑运算表达式，也可以是赋值运算或其它的表达式。
 不要把if（变量名==值）写成if（变量名=值）。
 整个if语句可以没有else分支。
 if或else分支花括号内的代码如果只有一行，花括号可以不写；如果一行也没有，花括号一定要写；如果有多行，花括号一定要写，如果不写，除了第一行，其它的代码将不是if语句的一部分。
 if (表达式)和else后不能加分号，因为分号表示空语句。（C++用分号作为一条语句结束的标志。如果在C++程序中不小心多写了一个分号，那么该分号会被当成一条空语句。）
2）示例
#include // 包含头文件。
using namespace std; // 指定缺省的命名空间。

int main()
{
// C++用分号作为一条语句结束的标志。
// 如果在C++程序中不小心多写了一个分号，那么该分号也许会被视作一个空语句。

// 判断超女的颜值，如果漂亮，在控制台输出“晋级下一轮”，否则输出“冲关失败”。
// 1）声明一个bool型变量，用于存放超女的颜值数据。
bool yz;

// 2）显示输入超女颜值的提示信息。
cout << "请输入超女的颜值（1-漂亮；0-不漂亮）：";

// 3）输入超女的颜值数据，存放在变量中。
cin >> yz;

// 4）用if语句判断超女的颜值，如果漂亮，显示“晋级下一轮”，否则显示“冲关失败”。
if (yz == true)
{
	cout << "小姐姐很漂亮哟！" << endl;
	cout << "恭喜您，晋级下一轮！" << endl;
}
else
{
	cout << "对不起，冲关失败！" << endl;
	cout << "推荐一个美容院，......" << endl;
}

}
19、嵌套使用if语句
1）嵌套使用if语句
if语句可以嵌套使用，实现多级（层）的条件判断（最多127层）。
语法：
if (表达式一)
{
if (表达式二)
{
// 表达式二为真时执行的语句。
}
else
{
// 表达式二为假时执行的语句。
}
}
else
{
// 表达式一为假时执行的语句。
}
2）示例
#include // 包含头文件。
using namespace std; // 指定缺省的命名空间。

int main()
{
// 超女选秀：1）性别（X-女，Y-男）；2）颜值（1-漂亮，0-不漂亮）；3）身材（1-火辣，2-丰满，3-苗条）。

// 声明三个变量，存放超女的性别、颜值和身材数据。
char sex;        // 性别（X-女，Y-男）。
bool yz;         // 颜值（1-漂亮，0-不漂亮）。
int    sc;         // 身材（1-火辣，2-丰满，3-苗条）。

// 显示“请输入超女的性别（X-女，Y-男）：”的提示文字。
cout << "请输入超女的性别（X-女，Y-男）：";

// 输入超女的性别，存放在变量中。
cin >> sex;

// 判断超女的性别，如果是女，流程继续，否则程序结束。
if (sex == 'X')
{
	// 显示“请输入超女的颜值（1-漂亮，0-不漂亮）：”的提示文字。
	cout << "请输入超女的颜值（1-漂亮，0-不漂亮）：";

	// 输入超女的颜值，存放在变量中。
	cin >> yz;

	// 判断超女的颜值，如果是漂亮，流程继续，否则程序结束。
	if (yz == true)     // 漂亮。
	{
		// 显示“请输入超女的身材（1-火辣，2-丰满，3-苗条）：”的提示文字。
		cout << "请输入超女的身材（1-火辣，2-丰满，3-苗条）：";

		// 输入超女的身材，存放在变量中。
		cin >> sc;

		// 判断超女的身材，如果是火辣，显示“晋级成功”，如果是丰满，显示“待定”，程序结束。
		if (sc == 1)        // 1-火辣。
		{
			cout << "晋级成功！" << endl;
		}
		else
		{
			if (sc == 2)    // 2-丰满
			{
				cout << "待定！" << endl;
			}
		}
	}
}

}
20、嵌套if语句的坑
嵌套使用if语句时候，会出现if与else的配对问题。
C++编译器处理该问题的原则是：else总是与前面最近if 配对。
如果要改变这种配对关系，可以使用花括号来确定新的配对关系。
if (sex == ‘X’)
if (yz == true)
cout << “sexX,yztrue\n”;
else
cout << “sexY,yztrue or false\n”;
以上代码中的else与第二个if配对，如果想让它与第一个if配对，代码如下：
if (sex == ‘X’)
{
if (yz == true)
cout << “sexX,yztrue\n”;
}
else
cout << “sexY,yztrue or false\n”;
21、多条件的if语句
1）多条件的if语句
语法：
if (表达式一)
{
// 表达式一为真时执行的语句。
}
else if (表达式二)
{
// 表达式二为真时执行的语句。
}
else if (表达式三)
{
// 表达式三为真时执行的语句。
}
……
else if (表达式n)
{
// 表达式n为真时执行的语句。
}
else
{
// 全部表达式都不为真时执行的语句。
}
注意：
 多条件的if语句本质上是嵌套的if语句。
 最多只能有127个条件分支。
 最后一个else可以没有。
2）示例
#include // 包含头文件。
using namespace std; // 指定缺省的命名空间。

int main()
{
// 超女的身材：1-火辣；2-丰满；3-苗条；4-强壮；5-肥胖；>5-未知 。

// 声明存放超女身材数据的变量。
int sc;

// 显示“请输入身材的代码（1-火辣；2-丰满；3-苗条；4-强壮；5-肥胖；>5-未知）：”的提示文字。
cout << "请输入身材的代码（1-火辣；2-丰满；3-苗条；4-强壮；5-肥胖；其它表示未知）：";

// 输入超女身材的代码，存放在变量中。
cin >> sc;

// 用多条件的if语句，判断身材代码，显示身材的中文描述。
if (sc == 1)     cout << "火辣!\n";
else if (sc == 2) cout << "丰满!\n";
else if (sc == 3) cout << "苗条!\n";
else if (sc == 4) cout << "强壮!\n";
else if (sc == 5) cout << "肥胖!\n";
else			 cout << "未知!\n";

}
22、if语句中的逻辑表达式
采用括号、对齐、空格、换行有助于更清晰的表达复杂的逻辑表达式。
示例：
#include // 包含头文件。
using namespace std; // 指定缺省的命名空间。

int main()
{
// 超女的数据：年龄（16-50岁），身高（150cm-190cm），身材（火辣；丰满；苗条）
// 颜值（漂亮；一般；歪瓜裂枣）。
// 晋级的标准：年龄25-30岁，身高165cm-175cm，身材火辣，颜值漂亮或者一般。

// 已准备好的超女数据。
int age = 28;
int height = 170;
string sc = "火辣";
string yz = "漂亮";

if (  (age > 25       && age < 30      ) &&        // 年龄
	  (height > 165 && height < 175    ) &&        // 身高
	  (sc == "火辣"                      ) &&        // 身材
	  (yz == "漂亮"  ||     yz == "一般"  )  )         // 颜值
{
	cout << "晋级成功！\n";
}

}
23、三目运算
三目运算也叫条件运算或三元运算，可以实现简单if语句的功能，但是书写更简洁。
语法： 表达式一 ? 表达式二 : 表达式三
先计算表达式一的值，如果为真，整个表达式的结果为表达式二的值，如果为假，整个表达式的结果为表达式三的值。
int a,b,c;
a=7;
b=6;
c=(a>b)?a:b;
等同于
if (a>b) c=a;
else c=b;
三目运算表达式可以嵌套使用，但是，过于复杂的三目运算表达式不方便理解。
比如判断year是不是闰年，是则返回1，不是返回0。
int year;
year=(year%1000)?(year%4000?1:0):(year%4==0?1:0)
① 、普通年能被4整除且不能被100整除的为闰年。
② 、世纪年能被400整除的是闰年。
③ 、对于数值很大的年份，这年如果能整除3200，并且能整除172800则是闰年。如172800年是闰年，86400年不是闰年。
24、switch语句
switch也是一种选择结构的语句，可以代替简单的多条件的if语句。
语法：
switch (表达式)
{
case 值一:
语句一;
break;
case 值二:
语句二;
break;
…
case 值n:
语句n;
break;
default:
上述条件都不满足时执行的语句;
}
注意：
 case后面必须是整数和字符，或者是结果为整数和字符的表达式，但不能使用变量。
 default不是必须的，当没有default时，如果全部的case匹配失败，那么就什么都不执行。
 每个分支不要漏写break;语句。
25、while循环语句
语法：
while (表达式)
{
语句块
}
先计算表达式的值，如果为真就执行语句块，执行完语句块后，回到循环首部再次计算表达式的值，如果为真又执行一次语句块……，这个过程会一直重复，直到表达式的值为假时不再执行语句块。
注意：
 如果表达式的值永远为真，那么将进入死循环，所以在循环中应该有改变表达式的值的方法。
 如果循环体中的语句块只有一行代码，大括号可以不书写。
 有疑问先放一边，在以后的课程中，会介绍循环的各种使用方法。
示例：
#include // 包含头文件。
using namespace std; // 指定缺省的命名空间。

int main()
{
// 有十个超女，编号是1-10，在控制台输出这十个超女的编号。
int no = 1; // 超女的编号。

while (no <= 10)
{
	cout << "这是第" << no++ << "名超女的编号。\n";
}

}
26、循环的跳转
break和continue两个关键字用于控制循环体中代码的执行流程。
break跳出（中止）当前循环语句。
continue回到当前循环语句的首部。
示例：
#include // 包含头文件。
using namespace std; // 指定缺省的命名空间。

int main()
{
// break跳出（中止）当前循环语句，continue回到当前循环语句的首部。
// 程序运行后一直工作，逐个输入超女的数据，判断是否晋级，如果到了休息时间，就把程序停下来。
// 超女选秀的流程：1）如果漂亮，直接晋级；2）不漂亮也行，身材火辣的也可以晋级。
bool once = true; // 是否为第一次执行循环。

while (true)
{
	if (once == false)
	{
		// a）显示“是否继续下一名超女选秀（1-继续，0-结束）：”的提示文字。
		cout << "是否继续下一名超女选秀（1-继续，0-结束）：";
		// b）输入是否继续的决定，存放在变量中。
		bool exist; cin >> exist;
		// c）判断输入的决定，如果是结束，流程跳出循环。
		if (exist == false) break;
	}
	
	once = false;     // 表示循环已经被执行过。

	// 1）显示“请输入超女的颜值（1-漂亮，0-不漂亮）：”的提示文字。
	cout << "请输入超女的颜值（1-漂亮，0-不漂亮）：";
	// 2）输入超女的颜值，存放在变量中。
	bool yz; cin >> yz;
	// 3）判断超女的颜值，如果漂亮，显示“晋级成功”，流程跳转到循环的首部。
	if (yz == true)
	{
		cout << "晋级成功\n";  continue;
	}

	// 4）显示“请输入超女的身材（1-火辣，0-不辣）：”的提示文字。
	cout &l