2.1 2.1 字符集字符集2.2 2.2 词法记号和空白 词法记号和空白 2.2.1 2.2.1 词法记号词法记号 2.2.2 2.2.2 空白空白2.3 2.3 基本数据类型基本数据类型2.4 2.4 变量与常量变量与常量 2.4.1 2.4.1 变量变量 2.4.2 2.4.2 常量常量2.5 2.5 枚举类型 枚举类型

2.6 2.6 数组类型数组类型2.7 2.7 关键字关键字 typedef typedef 2.8 2.8 运算符运算符2.9 2.9 表达式表达式2.10 2.10 数据类型转换数据类型转换2.11 2.11 控制语句控制语句 2.11.1 2.11.1 选择语句选择语句 2.11.2 2.11.2 循环语句循环语句 2.11.3 2.11.3 转移语句转移语句

第 第 2 2 章章C++C++ 语言编程基础语言编程基础

本章介绍本章介绍 CC ＋＋语言的基础概念，如：字符集、词法记号、基本数据＋＋语言的基础概念，如：字符集、词法记号、基本数据类型、变量和常量等；讨论两种自定义数据类型：枚举和数组类型；并通类型、变量和常量等；讨论两种自定义数据类型：枚举和数组类型；并通过大量实例演示控制语句在过大量实例演示控制语句在 CC ＋＋程序中的使用。＋＋程序中的使用。

【【 2.1 2.1 字符集字符集】】

字符是 C++ 语言的基本要素，是程序中可以区分的最小符号。

英文字母 英文字母 A ~ Z , a ~ zA ~ Z , a ~ z

数字字符 数字字符 0 ~ 90 ~ 9

特殊字符 空格 ！ 特殊字符 空格 ！ ## 　％　　％　 ^̂ 　＆　＊　＿ 　＆　＊　＿ (( 下划线 下划线 )) 　　 ++ 　　 == 　　 -- 　　　　　　　 　　　　　 ~ ~ 〈〈　〉　／　　〉　／　 \\ 　︱　′　〃　；　　︱　′　〃　；　 .. 　，　（）　　，　（）　　　　　　 ［］ ｛｝　：　？　　　　　　　　 ［］ ｛｝　：　？　　　

表　Ｃ＋＋语言字符集的构成表　Ｃ＋＋语言字符集的构成

词法记号是 C++ 语言的最小语法单位。

编译时，词法分析将 C ＋＋程序正文分解为词法记号和空白。

C++C++ 语言中共有语言中共有 55 种词法记号：种词法记号：关键字、关键字、标识符、文字常量、运算符和分隔符。标识符、文字常量、运算符和分隔符。

【【 2.2 2.2 词法记号与空白词法记号与空白】】

【【 2.2.1 2.2.1 词法记词法记号号】】

1. 1. 关键字关键字

关键字——是Ｃ＋＋语言的保留字，是具有特殊含义的专用单词。关键字——是Ｃ＋＋语言的保留字，是具有特殊含义的专用单词。

特点：　它们各自有不同的使用目的，在程序中不能用作别的用途。特点：　它们各自有不同的使用目的，在程序中不能用作别的用途。

标识符是程序员为命名程序中的一些要素所定义的单词，如变量名、函数名等。标识符是程序员为命名程序中的一些要素所定义的单词，如变量名、函数名等。

２２ . . 标识符标识符

标识符的命名规则标识符的命名规则由字母、数字和下划线组成由字母、数字和下划线组成

以字母或下划线作为第一个字符，以字母或下划线作为第一个字符，其后跟其后跟 00 个或多个字母、数字、下划线。个或多个字母、数字、下划线。

大写字母与小写字母分别代表不同的标识符大写字母与小写字母分别代表不同的标识符

不能与关键字相同不能与关键字相同

举例举例

正确的正确的 错误的错误的

sumsum 、、Dram_Dram_rectanglrectangle e 、、 _my_myfriendfriend

2_peo //2_peo // 起始字符非法起始字符非法operator //operator // 是关键字是关键字my $ //my $ // 含有非法字符含有非法字符

表　标识符的命名规则表　标识符的命名规则

【【 2.2.1 2.2.1 词法记号 词法记号 】】

常用的分隔符有 （） 常用的分隔符有 （） {} {} ， ： ， ： ;;

４４ . . 运算符运算符

运算符——是运算符——是 C++C++ 语言是实现加、减等各种运算的符号。语言是实现加、减等各种运算的符号。

５ . 分隔符

编写程序时，分隔符用于分隔词法记号或程序正文。编写程序时，分隔符用于分隔词法记号或程序正文。

注注C++C++ 编译器将注释也当作空白对待编译器将注释也当作空白对待

又称文字，指在程序中直接使用符号标示的数据，包括数字、字符、字符串等。又称文字，指在程序中直接使用符号标示的数据，包括数字、字符、字符串等。

３３ . . 文字常量文字常量

【【 2.22.2..2 2 空白 空白 】】

空白包括空格符（空格键所产生的字符）、制表符（空白包括空格符（空格键所产生的字符）、制表符（ TABTAB 键所产生的字符）键所产生的字符）、换行符（、换行符（ EnterEnter 键所产生的字符）。键所产生的字符）。

数据是程序处理的对象，数据是程序处理的对象， C++C++ 语言中，所有的对象都属于某种数据类型。语言中，所有的对象都属于某种数据类型。

数据类型的分类数据类型的分类基本数据类型基本数据类型自定义数据类型自定义数据类型

44 个关键字（修饰符）可用来作为前缀修饰字符型、整型、浮点型。个关键字（修饰符）可用来作为前缀修饰字符型、整型、浮点型。

基本数据类型的分类基本数据类型的分类

布尔型（布尔型（ boolbool ））

字符型（字符型（ charchar ））

整型（整型（ intint ））

浮点型（浮点型（ floatfloat 、、 doubledouble ））

signedsigned （表示有符号）（表示有符号）

44 个关键字个关键字 unsignedunsigned （表示无符号）（表示无符号）

longlong （表示长型）（表示长型）

shortshort （表示短型）（表示短型）

【【 2.3 2.3 基本数据类基本数据类型型】】

长度（字节）长度（字节） 取值范围取值范围类型类型boolbool 11 falsefalse （（ 00 ） ）

truetrue （（ 11 ））charchar

unsigned charunsigned char

signed charsigned char

short intshort int （（ shortshort ））signed short intsigned short int （（ signed shortsigned short ））unsigned short intunsigned short int （（ unsigned shortunsigned short ））

intint

11

11

11

22

22

22

44

-128-128 ～～ 127127

00 ～～ 255255

-128-128 ～～ 127127

-32768-32768 ～～ 3276732767

-32768-32768 ～～ 3276732767

00 ～～ 6553565535

-2147483648-2147483648 ～～ 21474836472147483647

signed intsigned int

unsigned intunsigned int

signed long intsigned long int （（ signed longsigned long ））long intlong int （（ longlong ））

unsigned long intunsigned long int （（ unsigned intunsigned int ））floatfloat

doubledouble

long doublelong double

-2147483648-2147483648 ～～ 21474836472147483647

00 ～～ 42949672954294967295

-2147483648-2147483648 ～～ 21474836472147483647

-2147483648-2147483648 ～～ 21474836472147483647

00 ～～ 42949672954294967295

3.4E-383.4E-38 ～～ 3.4E+383.4E+38

1.7E-3081.7E-308 ～～ 1.7E+3081.7E+308

1.7E-3081.7E-308 ～～ 1.7E+3081.7E+308

44

44

44

44

44

44

88

88

【【表　表　 C++C++ 语言的基本数据类型语言的基本数据类型】】

一个变量对应着计算机中的一组内存单元，这组内存单元在一个变量对应着计算机中的一组内存单元，这组内存单元在 C+C+++ 语言中用一个标识符来标识，即语言中用一个标识符来标识，即变量名变量名。。

数据类型可以是数据类型可以是 C++C++ 语言中的任一合法类型，每个变量都必须属于一语言中的任一合法类型，每个变量都必须属于一种类型。变量名的命名应遵照种类型。变量名的命名应遵照标识符的命名规则标识符的命名规则。。

C++C++ 语言中使用变量前必须对变量进行声明。变量声明的格式如下：语言中使用变量前必须对变量进行声明。变量声明的格式如下：

数据类型 变量名数据类型 变量名 11 ，变量名，变量名 22 ，…，变量名，…，变量名 nn ；；

注意注意

在声明变量时，必须注意变量类型的选择。应该保证该变量在声明变量时，必须注意变量类型的选择。应该保证该变量中将要存储的值不突破该变量类型所能表示的最大值。中将要存储的值不突破该变量类型所能表示的最大值。

【【 2.4 2.4 变量与常量变量与常量】】

变量变量 数据的值在程序运行过程中是可以改变的数据的值在程序运行过程中是可以改变的

数据的值在运行期间是不允许改变的数据的值在运行期间是不允许改变的 常量常量

【【 2.4.1 2.4.1 变量变量】】

常量的分类常量的分类文字常量文字常量符号常量符号常量

数据类型是由它的表示方法决定的。数据类型是由它的表示方法决定的。

1. 1. 整型常量整型常量

整型常量就是以文字形式出现的整数，包括整型常量就是以文字形式出现的整数，包括 33 种形式。各种表示形式前均种形式。各种表示形式前均可加上正或负号以表示它们值的正负，正号可以省略。可加上正或负号以表示它们值的正负，正号可以省略。

形式形式

十进制十进制

八进制八进制

十六进制十六进制

举例举例

19801980 ，， -50-50

表　整型常量的表　整型常量的 33 种形式种形式组成组成

由若干个由若干个 00 ～～ 99 的数字组成，但不的数字组成，但不能以能以 00 开头开头

以以 00 开头，由若干开头，由若干 00 ～～ 77 的数字组成的数字组成

以以 0X0X 或或 0x0x 开头，由若干开头，由若干 00 ～～ 99 的的数字及数字及 AA ～～ FF （大小写均可）的字（大小写均可）的字母组成母组成

010010 ，， -0276-0276

0x1Fa0x1Fa-0X4Ab-0X4Ab

备注备注

LL （或（或 ll ）表示）表示长整型，长整型， UU（或（或 uu ）表示无）表示无符号型，如果后符号型，如果后缀包括缀包括 LL （或（或ll ）和）和 UU （或（或uu ）则表示无符）则表示无符号长整型。号长整型。

【【 2.4.2 2.4.2 常量常量】】

2. 2. 实型常量实型常量

实型常量只能用十进制表示，共有两种表示形式实型常量只能用十进制表示，共有两种表示形式一般表示形式一般表示形式指数表示形式指数表示形式

形式形式

一般表示一般表示

指数表示指数表示

举例举例

10.210.2 ，， 110.0. ，， .2.2

表　实型常量的两种形式表　实型常量的两种形式

组成组成

又称小数表示形式。使用这种表示形式时，又称小数表示形式。使用这种表示形式时，实型常量由整数和小数两部分组成。其中实型常量由整数和小数两部分组成。其中的一部分在实际使用时可省略，但不允许的一部分在实际使用时可省略，但不允许两部分同时省去。两部分同时省去。

表示很大或很小的实数，由尾数部分、字母表示很大或很小的实数，由尾数部分、字母EE （或（或 ee ）、指数部分三部分组成。尾数部）、指数部分三部分组成。尾数部分的表示和一般表示形式相同，指数部分必分的表示和一般表示形式相同，指数部分必须是整数，但可正可负，当指数大于零时，须是整数，但可正可负，当指数大于零时，正号可省。正号可省。

1.2E21.2E200 ，， .24e.24e100100 ，， 12.12.

E7E7

备注备注

默认数据类默认数据类型为型为 doubldoublee 型，如果型，如果加上后缀加上后缀 FF（或（或 ff ）则）则为为 floatfloat 型，型，加上加上 LL（或（或 ll ）则）则为为 long doulong doubleble 型。型。

【【 2.4.2 2.4.2 常常量量】】

字符常量通常是指用单引号括起来的一个字符，其数据类型是字符常量通常是指用单引号括起来的一个字符，其数据类型是 charchar 。其。其中单引号只是用来说明被它括起来的字符是字符常量，它本身不是字符常量中单引号只是用来说明被它括起来的字符是字符常量，它本身不是字符常量的内容。如：′的内容。如：′ a′a′ ，′，′ #′#′ ，′，′ G′G′ 。。

C++C++ 语言中，还有一种转义序列的表示方法可用来表示字符常量。语言中，还有一种转义序列的表示方法可用来表示字符常量。

是用转义符号“＼”后跟一是用转义符号“＼”后跟一个字符或一个个字符或一个 ASCIIASCII 码来表码来表示一个单一字符。若“＼”示一个单一字符。若“＼”后跟一个后跟一个 ASCIIASCII 码，则表示码，则表示的是该的是该 ASCIIASCII 码所代表的字码所代表的字符。符。

在这里在这里 ASCIIASCII 码用八进制码用八进制或十六进制表示，这里八进制或十六进制表示，这里八进制和十六进制的表示与前面表示和十六进制的表示与前面表示整型常量的方式不同，应无第整型常量的方式不同，应无第一个“一个“ 0”0” 。例如′＼。例如′＼ X62′X62′ 就表就表示字符′示字符′ b′b′ 。。

表表 1 2 C++1 2 C++ 预定义的转义序列预定义的转义序列符 号符 号 含 义含 义＼＼ aa＼＼ bb＼＼ ff＼＼ nn＼＼ rr＼＼ tt＼＼ vv＼＼＼＼＼″＼″＼′＼′

响铃响铃退格（退格（ BackspaceBackspace 键）键）换页换页换行换行回车回车水平制表符（水平制表符（ TabTab 键）键）垂直制表符垂直制表符反斜杠反斜杠双引号双引号单引号单引号

3. 3. 字符常量字符常量

【【 2.4.2 2.4.2 常常量量】】

4. 4. 字符串常量字符串常量

字符串常量又称字符串或串常量，是用一对双引号括起来的字符序列。字符串常量又称字符串或串常量，是用一对双引号括起来的字符序列。例如：″例如：″ xyz″, ″I am a student″xyz″, ″I am a student″ ，″，″ This is a string″This is a string″

由于双引号在字符串中用做定界符，所以，若字符串中需要出现由于双引号在字符串中用做定界符，所以，若字符串中需要出现双引号时，则必须采用双引号时，则必须采用转义序列转义序列。。

注注

I I ＼＼00

C++C++ 语言中字符串的存储与字符不同，它在内存中的存放并不是简单地按语言中字符串的存储与字符不同，它在内存中的存放并不是简单地按串中字符的顺序排放，而是在末尾加上一个′＼串中字符的顺序排放，而是在末尾加上一个′＼ 0′0′ ，表示字符串的结束。，表示字符串的结束。

字符串、字符及与其对应的存储形式字符串、字符及与其对应的存储形式″″I″ I″

′′I′I′ II

在在 C++C++ 语言中已经有了其他特定的含义：“＼”是转义字符；“′”被语言中已经有了其他特定的含义：“＼”是转义字符；“′”被用于表示字符常量，“″”用于表示字符串常量。如果需要把它们用作字符用于表示字符常量，“″”用于表示字符串常量。如果需要把它们用作字符常量，就必须采用转义序列。常量，就必须采用转义序列。

注注 字符常量在内存中以字符常量在内存中以 ASCIIASCII 码形式存储，码形式存储，每个字符占一个字节每个字符占一个字节。。

【【 2.4.2 2.4.2 常常量量】】

5. 5. 布尔常量布尔常量

布尔常量仅有两个：布尔常量仅有两个： falsefalse （假）和（假）和 truetrue （真），其数据类型为（真），其数据类型为 boolbool 。。C++C++ 语言中，经常用到符号常量。语言中，经常用到符号常量。

符号常量在声明时一定要赋初值，而且其值在初始化后不能再改变符号常量在声明时一定要赋初值，而且其值在初始化后不能再改变，，这一点与变量完全不同。这一点与变量完全不同。 C++C++ 语言提供了两种声明符号常量的方法。语言提供了两种声明符号常量的方法。

注注

解释解释

形式形式

正确声明正确声明

用用 #define#define 声明符号常量声明符号常量

CC 语言中声明符号常量的方法。语言中声明符号常量的方法。其中其中 #define#define 是预处理指令。缺是预处理指令。缺点是不能显式声明常量的类型。点是不能显式声明常量的类型。

用用 constconst 声明符号常量声明符号常量

C++C++ 语言中广泛采用的声明符语言中广泛采用的声明符号常量的方法号常量的方法

const const 数据类型 常量名数据类型 常量名 == 常量值；常量值；或： 或： 数据类型 数据类型 const const 常量名常量名 == 常量值；常量值；

const double pi=3.1415926;const double pi=3.1415926; #define pi 3.1415926#define pi 3.1415926

错误声明错误声明 const double pi; //const double pi; // 错误错误pi=3.1415926; //pi=3.1415926; // 错误错误 最后不允许加 “；” 最后不允许加 “；”

表　两种声明符号常量的方法表　两种声明符号常量的方法

在声明枚举类型时，用户需要把变量的可能取值一一枚举出来，形式如下：在声明枚举类型时，用户需要把变量的可能取值一一枚举出来，形式如下：enum enum 枚举类型名 ｛变量值枚举类型名 ｛变量值 11 ，变量值，变量值 22 ，…变量值，…变量值 nn ｝；｝；

【【 2.5 2.5 枚举类型枚举类型】】

例 例 2-42-4 枚举类型的声明枚举类型的声明

enum color {red,blue,white,black,green};enum color {red,blue,white,black,green};

说明：说明： redred 的值为的值为 00 ，， blueblue的值为的值为 11 ，， whitewhite 的值为的值为 22 ，， blblackack 的值为的值为 33 ，， greengreen 的值为的值为 44 。。

声明枚举类型时，并不一定需要对枚举常量初始化，声明枚举类型时，并不一定需要对枚举常量初始化，枚举常量取默认值，即枚举常量取默认值，即第一个常量的值为第一个常量的值为 00 ，其他常量的值为前一个常量的值加，其他常量的值为前一个常量的值加 11 。。

在声明枚举类型时，枚举出的变量的可能取值又称枚举常量。在声明枚举类型时，枚举出的变量的可能取值又称枚举常量。

每个枚举常量实际上就是一个整数值，其值可以在声明枚举类型时以初始化每个枚举常量实际上就是一个整数值，其值可以在声明枚举类型时以初始化的方式指定。例如： 的方式指定。例如：

enum color {red,blue=100,white,black=50,green};enum color {red,blue=100,white,black=50,green};

在给枚举常量赋初值时，不一定要求常量的值互不相同。例如： 在给枚举常量赋初值时，不一定要求常量的值互不相同。例如：

enum color {red,blue=100,white,black=100,green=0};enum color {red,blue=100,white,black=100,green=0};

说明：说明： red=0red=0 ，， blue=100,white=101blue=100,white=101 ，， black=50black=50 ，， green=51green=51 。。被赋值的常量取所赋的值，没有赋值的常量取默认值。被赋值的常量取所赋的值，没有赋值的常量取默认值。

【【 2.5 2.5 枚举类型枚举类型】】

在声明枚举类型后，必须声明枚举变量才能使用这种数据类型。格式如在声明枚举类型后，必须声明枚举变量才能使用这种数据类型。格式如下（其中下（其中 enumenum 可有可无）：可有可无）：

enum enum 枚举类型名 变量枚举类型名 变量 11 ，变量，变量 22 ，…，变量，…，变量 nn ；；

事实上，也可以在声明枚举类型的同时，声明枚举变量。例如： 事实上，也可以在声明枚举类型的同时，声明枚举变量。例如：

enum color {red,blue,white,black,green} flower;enum color {red,blue,white,black,green} flower;enum {red,blue,white,black,green} flower;enum {red,blue,white,black,green} flower;

给枚举变量赋值时，必须注意枚举变量的值应该是所属枚举类型的给枚举变量赋值时，必须注意枚举变量的值应该是所属枚举类型的某一枚举常量。某一枚举常量。

例如：例如： enum color {red,blue,white,black,green};enum color {red,blue,white,black,green};enum color flower(red);enum color flower(red);flower=white;flower=white;

说明：声明了一个无名的枚举类型，说明：声明了一个无名的枚举类型，并声明了一个名为并声明了一个名为 flowerflower 的枚举变量。的枚举变量。使用这种方法，程序的其他地方就不能使用这种方法，程序的其他地方就不能再声明这种类型的枚举变量了。再声明这种类型的枚举变量了。

【【 2.5 2.5 枚举类型枚举类型】】

枚举类型的应用枚举类型的应用#include<iostream.h>#include<iostream.h>enum Sex {Male,Female};enum Sex {Male,Female};

int main()int main(){{

int i;int i;Sex s;Sex s;cout<<"cout<<" 请输入性别： 请输入性别： 0-0- 男男 , 1-, 1- 女女 ";";

cin>> i;cin>> i; s=Sex(i);s=Sex(i); if(s==Male) { // ifif(s==Male) { // if 语句的使用本章后面讲解语句的使用本章后面讲解

cout<<s<<endl;cout<<s<<endl;cout<<"cout<<" 性别：男性别：男 "<<endl;"<<endl;

}}else {else {

if(s==Female) {if(s==Female) {cout<<s<<endl;cout<<s<<endl;cout<<"cout<<" 性别：女性别：女 "<<endl;"<<endl;

}}

例 例 2-52-5

枚举变量的值是一个整数。如果希望输出其标识符，程序中需要另外处枚举变量的值是一个整数。如果希望输出其标识符，程序中需要另外处理。理。

请输入性别： 请输入性别： 0-0- 男男 , 1-, 1- 女女

输入 输入 00

输入 输入 11

输入 输入 22

00性别：男性别：男

11性别：女性别：女

22对不起对不起 ,, 性别输入错误！性别输入错误！

提示用户输入提示用户输入

elseelse{{

cout<<s<<endl;cout<<s<<endl;cout<<"cout<<" 对不起对不起 ,, 性别输入错误！性别输入错误！ "<<endl;"<<endl;

}}}}

return 0; return 0; }}

（续）（续）

数据类型 数组名［常量表达式数据类型 数组名［常量表达式 11 ］［常量表达式］［常量表达式 22 ］…［常量表达式］…［常量表达式 nn ］］;;

数组是类型相同、数目一定的变量的有序集合，组成数组的变量称为该数数组是类型相同、数目一定的变量的有序集合，组成数组的变量称为该数组的元素。在内存分配时，数组对应着一组顺序排放的存储单元，数组的组的元素。在内存分配时，数组对应着一组顺序排放的存储单元，数组的每个元素按照声明时的次序在其中存放。每个元素按照声明时的次序在其中存放。

给出了数组中元素的给出了数组中元素的类型，它可以是类型，它可以是 C++C++语言中任一合法类型。语言中任一合法类型。

常量表达式又称下常量表达式又称下标表达式，必须是标表达式，必须是unsigned intunsigned int 类型类型的整数。的整数。

常量表达式常量表达式 nn 表示表示的是第的是第 nn 维的大小。维的大小。

是一个标识符，是一个标识符，代表着数组元素代表着数组元素在内存中的起始在内存中的起始地址，是一个常地址，是一个常量，不能给它赋量，不能给它赋值。值。

““ ［］”的个数代表着［］”的个数代表着数组的维数。数组的维数。一个方括一个方括号表示一维数组，两个号表示一维数组，两个表示二维数组，…，表示二维数组，…， nn个表示表示个表示表示 nn 维数组。维数组。

这些表达式的值这些表达式的值的乘积就是数组元素的乘积就是数组元素的个数。的个数。

注注

数组的声明形式如下：数组的声明形式如下：

【【 2.6 2.6 数组类型数组类型】】

声明了一个一维数组声明了一个一维数组 声明了一个二维数组声明了一个二维数组

char cchar c ［［ 55 ］］ ;; int iint i ［［ 55 ］［］［ 22 ］］ ;;

cc 是数组名，数组有是数组名，数组有 55 个元素，个元素，每个元素都是每个元素都是 charchar 型变量。型变量。

ii 是数组名，数组有是数组名，数组有 1010 个元素，个元素，都是都是 intint 型变量。型变量。

举例举例

解释解释

下标表达式也限定了数组中元素的排列次序及每个元素在数组中的位置，下标表达式也限定了数组中元素的排列次序及每个元素在数组中的位置，我们可以通过数组名和下标顺利地访问其中的每一个元素。我们可以通过数组名和下标顺利地访问其中的每一个元素。访问数组中元素的一般形式如下：访问数组中元素的一般形式如下：

数组名［下标表达式数组名［下标表达式 11 ］［下标表达式］［下标表达式 22 ］……［下标表达式］……［下标表达式 nn ］］

char cchar c ［［ 55 ］］ ;; int iint i ［［ 55 ］［］［ 22 ］］ ;;

有有 55 个元素：个元素： cc ［［ 00 ］，］， cc ［［ 11 ］， ］， cc ［［ 22 ］， ］， cc ［［ 33 ］， ］， cc ［［ 44 ］。］。

有有 1010 个元素：个元素： ii ［［ 00 ］［］［ 00 ］，］， ii ［［ 00 ］］［［ 11 ］，］， ii ［［ 11 ］［］［ 00 ］，］， ii ［［ 11 ］［］［ 11 ］， ］， ii ［［ 22］［］［ 00 ］， ］， ii ［［ 22 ］［］［ 11 ］， ］， ii ［［ 33 ］［］［ 00］， ］， ii ［［ 33 ］［］［ 11 ］， ］， ii ［［ 44 ］［］［ 00 ］，］， ii［［ 44 ］［］［ 11 ］。］。

下标表达式的个数应与数组的维数相同，下标表达式的个数应与数组的维数相同，下标表达式的值从下标表达式的值从 00 开始。开始。

一维数组：一维数组：就是简单地按下标顺序存储。就是简单地按下标顺序存储。例如： 例如： int iint i ［［ 55 ］］ ;; ii ［［ 00 ］］ ii ［［ 11 ］］ ii ［［ 22 ］］ ii ［［ 33 ］］ ii ［［ 44 ］］

图 一维数组的存储图 一维数组的存储二维数组二维数组：可以把它看成是由多个一维数组构成的。：可以把它看成是由多个一维数组构成的。例如： 例如： int iint i ［［ 22 ］［］［ 33 ］］ ;;

ii ［［ 00 ］［］［ 00 ］］ii ［［ 00 ］［］［ 11 ］］ ii ［［ 11 ］［］［ 22 ］］ii ［［ 00 ］［］［ 22 ］］ii ［［ 11 ］［］［ 00 ］］图 二维数组的存储图 二维数组的存储

三维数组三维数组：可把它看成是由多个二维数组构成的。：可把它看成是由多个二维数组构成的。例如： 例如： int iint i ［［ 22 ］［］［ 33 ］［］［ 44 ］］ ;;

i [0] [0] [0]i [0] [0] [0] i [0] [0] [1]i [0] [0] [1] i [0] [0] [2]i [0] [0] [2] i [0] [0] [3]i [0] [0] [3] i [0] [1] [0]i [0] [1] [0] i [0] [1] [1]i [0] [1] [1]

i [0] [1] [2]i [0] [1] [2] i [0] [1] [3]i [0] [1] [3] i [0] [2] [0]i [0] [2] [0] i [0] [2] [1]i [0] [2] [1] i [0] [2] [2]i [0] [2] [2] i [0] [2] [3]i [0] [2] [3]

i [1] [0] [0]i [1] [0] [0] i [1] [0] [1]i [1] [0] [1] i [1] [0] [2]i [1] [0] [2] i [1] [0] [3]i [1] [0] [3] i [1] [1] [0]i [1] [1] [0] i [1] [1] [1]i [1] [1] [1]

i [1] [1] [2]i [1] [1] [2] i [1] [1] [3]i [1] [1] [3] i [1] [2] [0]i [1] [2] [0] i [1] [2] [1]i [1] [2] [1] i [1] [2] [2]i [1] [2] [2] i [1] [2] [3]i [1] [2] [3]

图 三维数组的存储图 三维数组的存储

数组元素在内存中是顺序存储的。数组元素在内存中是顺序存储的。

进行数组声明时，也可以给其中部分或全部元素赋初值。进行数组声明时，也可以给其中部分或全部元素赋初值。对于对于一维数组一维数组，初始化有以下两种形式：，初始化有以下两种形式：

（（ 11 ）全部元素都初始）全部元素都初始化化

int iint i ［［ 55 ］］ ={1,2,3,4,5};={1,2,3,4,5};

（（ 22 ）部分元素被初始）部分元素被初始化化

声明了一个有声明了一个有 55 个元素的个元素的数组，每个元素都被赋初数组，每个元素都被赋初值。其中值。其中 ii ［［ 00 ］］ =1=1 ，， ii［［ 11 ］］ =2=2 ，， ii ［［ 22 ］］ =3=3 ，，ii ［［ 33 ］］ =4=4 ，，ii ［［ 44 ］］ =5=5 。。

int iint i ［［ 55 ］］ ={1,={1,2};2};

初始化了数组的前两个元素：初始化了数组的前两个元素：ii ［［ 00 ］］ = 1= 1 ，， ii ［［ 11 ］］ =2=2 。。其他元素则未赋值，其他元素则未赋值，程序一程序一般都自动给它们赋般都自动给它们赋 00 。。

举例举例 例题解释例题解释形式形式

对于对于全部元素都被初始化全部元素都被初始化的情况，还有如下声明形式： 的情况，还有如下声明形式： int iint i ［］［］ ={1,2,3,4,5};={1,2,3,4,5};

注注

在声明时可不说明数组元素的个数。元素的个数与初始化数据的个数相同。在声明时可不说明数组元素的个数。元素的个数与初始化数据的个数相同。

一个一个 nn 维数组可看成是由维数组可看成是由多个多个 n-1n-1 维数组维数组构成的。构成的。

例如： 例如： int iint i ［［ 22 ］［］［ 33 ］］ ={1,2,3,4,5,={1,2,3,4,5,6};6};

int iint i ［［ 22 ］［］［ 33 ］］ ={ {1,2,3}, {4,5,6}};={ {1,2,3}, {4,5,6}};

等价等价

多维数组也可以只初始化部分元素，例如： 多维数组也可以只初始化部分元素，例如：

int iint i ［［ 22 ］［］［ 33 ］］ ={1,2,3,4 };={1,2,3,4 };如果在声明的同时给元素赋初值，最多可以省略第一维中的下标个数，如果在声明的同时给元素赋初值，最多可以省略第一维中的下标个数，例如： 例如： int iint i ［］［［］［ 33 ］］ ={ {1,2,3}, {4,5,6}}={ {1,2,3}, {4,5,6}} ；；

等价等价

int iint i ［［ 22 ］［］［ 33 ］］ ={ {1,2,3}, {4,5,6}};={ {1,2,3}, {4,5,6}};

int iint i ［］［］［］［］ ={ {1,2,3}, {4,5,6}}={ {1,2,3}, {4,5,6}} ；；

说明：把说明：把 ii ［［ 00 ］［］［ 00 ］初始化为］初始化为11 ，， ii ［［ 00 ］［］［ 11 ］初始化为］初始化为 22 ，， ii［［ 00 ］［］［ 22 ］初始化为］初始化为 33 ，， ii ［［ 11］［］［ 00 ］初始化为］初始化为 44 ，其他取默认，其他取默认值值 00 。。

说明：把说明：把 ii ［［ 00 ］［］［ 00 ］初始化为］初始化为11 ，， ii ［［ 00 ］［］［ 11 ］初始化为］初始化为 22 ，，ii ［［ 00 ］［］［ 22 ］初始化为］初始化为 33 ，， ii［［ 11 ］［］［ 00 ］初始化为］初始化为 44 ，， ii ［［ 11］［］［ 11 ］初始化为］初始化为 55 ，， ii ［［ 11 ］］［［ 22 ］初始化为］初始化为 66 。。

多维数组的初始化与一维数组相似，多维数组的初始化与一维数组相似，需要注意需要注意的是必须按照前面所讲的是必须按照前面所讲的存储顺序列出数组元素的值。的存储顺序列出数组元素的值。

须注意须注意在赋初值时，初始值表中的数据个数不能多于数据元素的个数。例如：在赋初值时，初始值表中的数据个数不能多于数据元素的个数。例如：

int iint i ［［ 55 ］］ ={1,2,3,4,5,6};={1,2,3,4,5,6};

就是错误的，程序在编译时，系统会报错。就是错误的，程序在编译时，系统会报错。

int iint i ［［ 33 ］］ ={1,2,3 };={1,2,3 };

等价等价

int iint i ［［ 33 ］；］；ii ［［ 00 ］］ =1;=1;ii ［［ 11 ］］ =2;=2;ii ［［ 22 ］］ =3;=3;

数组元素可以是数组元素可以是 C++C++ 语言中的任一合法数据类型，自然也就可以是语言中的任一合法数据类型，自然也就可以是 charchar 型，型，即即字符型字符型。。不过由于不过由于 C++C++ 语言中没有字符串类型，我们通常采用字符数组来存放和处理语言中没有字符串类型，我们通常采用字符数组来存放和处理字符串，因此，它又有一些特殊的地方。字符串，因此，它又有一些特殊的地方。

注注 在给数组元素赋值时，在给数组元素赋值时，一定要注意数组越界问题。一定要注意数组越界问题。

与数组元素的初始化不同，在给数组元素赋值时，必须逐一进行。与数组元素的初始化不同，在给数组元素赋值时，必须逐一进行。例如：对于下述的数组初始化： 例如：对于下述的数组初始化：

例如：对于字符串：″例如：对于字符串：″ abcd″abcd″ ，，可以声明和初始化为： 可以声明和初始化为：

char strchar str ［［ 55 ］］ ={ ′a′, ′b′, ′c′, ′d′, ′={ ′a′, ′b′, ′c′, ′d′, ′ ＼＼ 0′};0′};

等价等价

char strchar str ［［ 55 ］］ = ″abcd″;= ″abcd″;

char strchar str ［［ 44 ］］ = ″abcd″;= ″abcd″;

说明：因为声明的数组只有说明：因为声明的数组只有 44 个元素，而初始化时有个元素，而初始化时有 55 个字个字符作为数据项：′符作为数据项：′ a′a′ 、′、′ b′b′ 、′、′ c′c′ 、′、′ d′d′ 、′＼、′＼ 0′0′ 。其中字符′。其中字符′＼＼ 0′0′ 是字符串的结束符，在用字符串方法初始化时，系统是字符串的结束符，在用字符串方法初始化时，系统会自动加上。会自动加上。

C++C++ 语言中，一个字符串是用一个以′＼语言中，一个字符串是用一个以′＼ 0′0′结尾的一维字符数组来表示的，结尾的一维字符数组来表示的，这个字符数组的声明和初始化可以采用和其他数组相同的方式。这个字符数组的声明和初始化可以采用和其他数组相同的方式。

例如：对于字符串″例如：对于字符串″ abcd″abcd″ 、″、″ hijk″hijk″ 、″、″ opqr″ opqr″ 可以声明和初始化为：可以声明和初始化为： char strchar str ［［ 33 ］［］［ 55 ］］ ={{ ′a′, ′b′, ′c′, ′d′, ′={{ ′a′, ′b′, ′c′, ′d′, ′ ＼＼ 0′}0′} ，， {′h′, ′ i′, ′j′, ′k′, ′{′h′, ′ i′, ′j′, ′k′, ′ ＼＼ 0′},{′o′,0′},{′o′, ′p′, ′q′, ′r′, ′ ′p′, ′q′, ′r′, ′ ＼＼ 0′}};0′}};

等价等价

char strchar str ［［ 33 ］［］［ 55 ］］ ={ ″abcd″,″hijk″,″opqr″ };={ ″abcd″,″hijk″,″opqr″ };

等价等价

char strchar str ［］［［］［ 55 ］］ ={ ″abcd″,″hijk″,″opqr″ };={ ″abcd″,″hijk″,″opqr″ };

字符数组的赋值规则与其他类型数组一样，必须逐个元素赋值。字符数组的赋值规则与其他类型数组一样，必须逐个元素赋值。注注

多维字符数组可以用来表示多个字符串，其初始化同样有两种方法。多维字符数组可以用来表示多个字符串，其初始化同样有两种方法。

来由来由：在使用：在使用 C++C++ 语言的某些数据类型（如：语言的某些数据类型（如： unsigned long intunsigned long int ）声明变）声明变量时，如果需多次键入该类型，非常繁琐，且容易出错。为此，量时，如果需多次键入该类型，非常繁琐，且容易出错。为此， C++C++ 语言语言提供了关键字提供了关键字 typedeftypedef ，它可以为这样的类型建立一个或多个别名。，它可以为这样的类型建立一个或多个别名。

形式如下： 形式如下：

typedef typedef 已有类型 别名已有类型 别名 11 ，别名，别名 22 ，…，别名，…，别名

n;n;

建立别名后，就可以利用这个别名来声明这种类型的变量。建立别名后，就可以利用这个别名来声明这种类型的变量。如：如： ULONG iULONG i ；；

与前面建立新类型不同，这里利用关键字与前面建立新类型不同，这里利用关键字 typedeftypedef 仅仅是为一个仅仅是为一个类型的名字起了别名。类型的名字起了别名。

注注

例如： 例如： typedef unsigned long int ULONG;typedef unsigned long int ULONG;

【【 2.7 2.7 关键字关键字 typedetypedeff 】】

运算是指对数据的求值计算，如：加、减运算等。运算符给出了计算的运算是指对数据的求值计算，如：加、减运算等。运算符给出了计算的类型，而参与运算的数据叫操作数（变量、常量）。类型，而参与运算的数据叫操作数（变量、常量）。

运运算算符符的的分分类类

按所要求的操作数的多少按所要求的操作数的多少一元运算符一元运算符二元运算符二元运算符三元运算符三元运算符

需要需要 11 个操作数个操作数需要需要 22 个操作数个操作数需要需要 33 个操作数个操作数

运算性质分运算性质分

算术运算符算术运算符

关系运算符关系运算符

逻辑运算符 …逻辑运算符 …

【【 2.8 2.8 运算符运算符】】

运算符具有优先级与结合性。运算符具有优先级与结合性。

当一个表达式中含有多个运算符时，先进行优先级高的运算，后作优先当一个表达式中含有多个运算符时，先进行优先级高的运算，后作优先级低的运算。如果表达式中出现了多个相同优先级的运算时，运算的顺级低的运算。如果表达式中出现了多个相同优先级的运算时，运算的顺序就要看运算符的结合性了。序就要看运算符的结合性了。

结合性结合性是指当一个操作数左右两边的运算符优先级相同时，按什么顺序是指当一个操作数左右两边的运算符优先级相同时，按什么顺序进行运算，是自左向右，还是自右向左。进行运算，是自左向右，还是自右向左。

优 先 级优 先 级 运 算 符运 算 符 功 能 说 明功 能 说 明 结 合 性结 合 性( )( ) 改变优先级改变优先级: :: : 作用域运算符作用域运算符［ ］［ ］ 数组下标数组下标. ->. -> 成员选择符成员选择符.* ->*.* ->* 成员指针选择符成员指针选择符** 间接访问间接访问&& 取地址取地址new deletenew delete 动态内存分配动态内存分配

11

22

从左至右

从左至右

从右至左

从右至左

【【 2.8 2.8 运算符运算符】】

优 先 级优 先 级 运 算 符运 算 符 功 能 说 明功 能 说 明 结 合 性结 合 性sizeofsizeof 求所占内存字节数求所占内存字节数!! 逻辑求反逻辑求反～～ 按位求反按位求反++ --++ -- 增增 11 、减、减 11 运算符运算符+ -+ - 取正 、 取负取正 、 取负（ ）（ ） 强制类型强制类型* / %* / % 乘法、除法、求余乘法、除法、求余+ -+ - 加法、减法加法、减法

22

33

从右至左

从右至左

44

55

66

77

从左到右从左到右从左到右从左到右从左到右从左到右

从左到右从左到右

从左到右从左到右从左到右从左到右88

99

1010

<< >><< >> 左移位、右移位左移位、右移位< > <= >=< > <= >= 小于、大于、小于等 小于、大于、小于等

于、 于、 大于等于大于等于== !=== != 等于、不等于等于、不等于&& 按位与按位与^̂ 按位异或按位异或|| 按位或按位或

从左到右从左到右从左到右从左到右

(( 续续 ))

优 先 级优 先 级 运 算 符运 算 符 功 能 说 明功 能 说 明 结 合 性结 合 性

| || | 逻辑或逻辑或? :? : 条件运算符条件运算符

1212

1313

1414

1515

从左到右从左到右从右到左从右到左

从左到右从左到右

= += -= *= /== += -= *= /= %= & =^= |=%= & =^= |= 赋值运算符赋值运算符 <<= >>=<<= >>=

,, 逗号运算符逗号运算符

1111 &&&& 逻辑与逻辑与 从左到右从左到右

从右到左从右到左

表 表 C++C++ 中常用运算符的功能、优先级和结合性中常用运算符的功能、优先级和结合性

1. 1. 算术运算符算术运算符

（（ 11 ）基本算术运算符）基本算术运算符

C++C++ 语言中的算术运算符包括语言中的算术运算符包括基本算术运算符基本算术运算符和和增增 11 、减、减 11 运算符运算符。。

一元运算符：一元运算符：

二元运算符：二元运算符：

++ （取正）、（取正）、 -- （取负）（取负）

++ （加）、（加）、 -- （减）、（减）、 ** （乘）、（乘）、 // （除）、（除）、 %% （取余）（取余）

(( 续续 ))

%% 运算符运算符要求它的两个操作数必须是整数或字符型数据，其优先级与要求它的两个操作数必须是整数或字符型数据，其优先级与结合性和“结合性和“ /”/” 运算符相同。求两个数的余数的表达式如下： 运算符相同。求两个数的余数的表达式如下：

操作数操作数 1%1% 操作数操作数 22

其计算结果是操作数其计算结果是操作数 11 被操作数被操作数 22 除的余数，即除的余数，即余数余数 ==操作数操作数 1-1- 操作操作数数 2*2* 整商整商（整商为操作数（整商为操作数 11 除以操作数除以操作数 22 所得的整数商）。例如： 所得的整数商）。例如： 10%4 //10%4 // 结果是结果是 22

对于对于““ /”/” 运算符运算符，当它的两个操作数都是整数时，其计算结果应是，当它的两个操作数都是整数时，其计算结果应是除法运算后所得的商的整数部分。例如 除法运算后所得的商的整数部分。例如 5/25/2 的结果是的结果是 22 。。

注注

增增 11 、减、减 11 运算符都是一元运算符，这两个运算符都有前置和后置两种形式。运算符都是一元运算符，这两个运算符都有前置和后置两种形式。

前置形式是指运算符在操作数的前面，后置是指运算符在操作数的后面。前置形式是指运算符在操作数的前面，后置是指运算符在操作数的后面。

例如： 例如： I++I++ ； ； //++//++ 后置后置--J--J ； ； //--//-- 前置前置

（（ 22 ）增）增 11 、减、减 11 运算运算符符

关系运算符都是二元运算符，共有关系运算符都是二元运算符，共有 66 个：个： << （小于）、 （小于）、 >> （大于）、（大于）、 <=<= （小（小于或等于）、于或等于）、 >= >= （大于或等于）、（大于或等于）、 == == （等于）、（等于）、 !=!= （不等于）。（不等于）。

前置形式是先计算操作数的值（增前置形式是先计算操作数的值（增11 或减或减 11 ），后把操作数的值作为），后把操作数的值作为表达式的结果。表达式的结果。

后置形式是先将操作数的值作为表后置形式是先将操作数的值作为表达式的结果，然后把操作数的值增达式的结果，然后把操作数的值增 11或减或减 11 。。

无论是前置还是后置，这两个运算符的作用都是使操作数的值增无论是前置还是后置，这两个运算符的作用都是使操作数的值增 11 或减或减 11 。。但操作数和运算符组成的表达式的但操作数和运算符组成的表达式的值值并不相同。假设并不相同。假设 I=2I=2 ，， J=3J=3 ，看下面的，看下面的两个例子：两个例子：

I++I++ ；； ++J++J ；；

经过计算后经过计算后 :: 表达式的值为表达式的值为 22 ，， II 值为值为 33 表达式值为表达式值为 33 ，， JJ 值为值为 33

在进行算术运算时，还需注意计算中的溢出问题。计算机中，在进行算术运算时，还需注意计算中的溢出问题。计算机中，每种基每种基本数据类型本数据类型都有一定的取值范围。对于都有一定的取值范围。对于实数实数，如果运算结果超出范围，程，如果运算结果超出范围，程序将被异常中止。另外，序将被异常中止。另外，整数整数或或实数实数被零除也会导致程序异常中止。被零除也会导致程序异常中止。

注注

2. 2. 关系运算符关系运算符

关系运算符用于比较两个操作数的大小，其比较的结果是一个关系运算符用于比较两个操作数的大小，其比较的结果是一个 boolbool 型的型的值。值。当两个操作数当两个操作数满足满足关系运算符指定的关系时，关系运算符指定的关系时，表达式的值表达式的值为为 truetrue ，否则，否则为为 falsefalse 。。 truetrue 等于等于 11 ，， falsefalse 等于等于 00 ，所以，关系运算符的比较结果可以作，所以，关系运算符的比较结果可以作为算术运算中的操作数。为算术运算中的操作数。

一元运算符：一元运算符：

二元运算符二元运算符

！（逻辑求反）！（逻辑求反）

&&&& （逻辑与）（逻辑与）

| || | （逻辑或）（逻辑或）

若其操作数为若其操作数为 00 （（ falsefalse ），运算结），运算结果为果为 true(1)true(1) ，否则为，否则为 false(0)false(0) 。。

只要两个操作数中有一个为只要两个操作数中有一个为 00 （（ falsefalse ），），运算结果就为运算结果就为 false(0)false(0) ，否则为，否则为 true(1)true(1) 。。

只要两个操作数中有一个不为只要两个操作数中有一个不为 00 （（ falsfalsee ），运算结果为），运算结果为 ture(1)ture(1) ，否则为，否则为 falsefalse(0)(0) 。。4. sizeof4. sizeof 运算符运算符

sizeofsizeof 运算符用于计算其操作数在内存中所占的字节数。它是一个一元运算符用于计算其操作数在内存中所占的字节数。它是一个一元运算符，操作数可以是运算符，操作数可以是 C++C++ 语言中任一合法的数据类型。语言中任一合法的数据类型。

该运算符的使用形式如下： 该运算符的使用形式如下： sizeofsizeof （数据类型）；（数据类型）；

3. 3. 逻辑运算符逻辑运算符

（（ 11 ）按位求反（～））按位求反（～）

一元运算符：一元运算符：

二元运算符二元运算符

～（按位求反）～（按位求反）

&& （按位与）（按位与） | | （按位或）（按位或）

^̂ （按位异或）（按位异或） <<<< （左移位）（左移位）>>>> （右移位）（右移位）

位运算符是对其操作数按其二进制形式逐位进行运算，参与运算的操作位运算符是对其操作数按其二进制形式逐位进行运算，参与运算的操作数应为整数。数应为整数。

按位求反的作用是对一个二进制数的每一位求反。按位求反的作用是对一个二进制数的每一位求反。

例如：例如： 计算～计算～ 025 025 025: 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1025: 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 ～～ 025: 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0025: 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0

5. 5. 位运算符位运算符

按位或操作的作用是将两个操作数对应的每一位分别进行逻辑或操作。按位或操作的作用是将两个操作数对应的每一位分别进行逻辑或操作。

按位与操作的作用是将两个操作数对应的每一位分别进行逻辑与操作。按位与操作的作用是将两个操作数对应的每一位分别进行逻辑与操作。

例如：例如： 计算计算 3&53&533 ： ： 0 0 0 0 0 0 1 10 0 0 0 0 0 1 155 ：（：（ && ） ） 0 0 0 0 0 1 0 10 0 0 0 0 1 0 1

3&53&5 ： ： 0 0 0 0 0 0 0 10 0 0 0 0 0 0 1

（（ 33 ）按位或（）按位或（ || ））

例如：例如： 计算 计算 3|53|533 ： ： 0 0 0 0 0 0 1 10 0 0 0 0 0 1 155 ：（：（ || ） ） 0 0 0 0 0 1 0 10 0 0 0 0 1 0 1

3|53|5 ： ： 0 0 0 0 0 1 1 10 0 0 0 0 1 1 1

（（ 22 ）按位与）按位与（（ && ））

例如：例如： 计算 计算 071^052071^052 ：：071071 ： ： 0 0 1 1 1 0 0 10 0 1 1 1 0 0 1052052 ：（：（ ^̂ ） ） 0 0 1 0 1 0 1 00 0 1 0 1 0 1 0

071^052071^052 ： ： 0 0 0 1 0 0 1 1 0 0 0 1 0 0 1 1

（（ 55 ）移位）移位

移位运算符左边的操作数指定了移位运算符左边的操作数指定了需要作移位操作的数需要作移位操作的数。右边的操作数。右边的操作数指定了指定了需要移动的位数需要移动的位数，因而必须是一个整数表达式。，因而必须是一个整数表达式。

左移位（左移位（ <<<< ））右移位（右移位（ >>>> ））

右移位是将左操作数的二进制值向右移动指定的位右移位是将左操作数的二进制值向右移动指定的位数。右移后，移出的低位舍弃。如果是无符号数则数。右移后，移出的低位舍弃。如果是无符号数则高位补高位补 00 ；如果是有符号数，则高位补符号位或补；如果是有符号数，则高位补符号位或补 00 。。

是将左操作数的二进制值向左移动指定的位数。是将左操作数的二进制值向左移动指定的位数。左左移后，低位补移后，低位补 00 ，移出的高位舍弃。，移出的高位舍弃。

位异或操作的作用是将两个操作数对应的每一位进行异或，具体位异或操作的作用是将两个操作数对应的每一位进行异或，具体运算规则运算规则是：若对应位值相同，则该位运算结果为是：若对应位值相同，则该位运算结果为 00 ；否则为；否则为 11 。。

（（ 44 ）按位异或）按位异或（（ ^̂ ））

0 0 0 0 0 1 0 00 0 0 0 0 1 0 0

左移位举例：表达式左移位举例：表达式 4<<14<<1 ，结果为，结果为 88

舍弃舍弃 00

1 1 1 1 1 0 0 01 1 1 1 1 0 0 0 舍弃舍弃 舍弃舍弃1111

图 图 4<<14<<1 的移位操作过程的移位操作过程

右移位举例：表达式右移位举例：表达式 A>>2A>>2 ，结果为，结果为 -2-2

图 图 A>>2A>>2 的移位操作过程的移位操作过程

有有 charchar 型变量型变量 AA ，其值为，其值为 -8-8 ，则，则 AA 的二进制补码是的二进制补码是 1111100111110000

移位运算的结果移位运算的结果就是位运算表达式的值，参与运算的两个操作数的就是位运算表达式的值，参与运算的两个操作数的值值并没有变化并没有变化。。

注注

移位运算可替代乘或除以移位运算可替代乘或除以 22 或或 22 的的 nn 次方运算。次方运算。

举例举例

表达式表达式是由运算符和操作数组成的、用于计算的式子。是由运算符和操作数组成的、用于计算的式子。

常见表达式分类常见表达式分类

算术表达式算术表达式

关系表达式关系表达式

逻辑表达式逻辑表达式条件表达式条件表达式逗号表达式逗号表达式

赋值表达式赋值表达式

书写表达式时书写表达式时，必须注意运算符的优先级与结合性，确保列出的表达式实际，必须注意运算符的优先级与结合性，确保列出的表达式实际求值顺序与自己求值顺序与自己所要求的一致所要求的一致。必要时可加括号以便于理解，甚至改 变优先。必要时可加括号以便于理解，甚至改 变优先级。括号的使用可以嵌套。在计算时，级。括号的使用可以嵌套。在计算时，先做内括号，再做外括号先做内括号，再做外括号。。

在表达式中，在表达式中，连续出现连续出现两个运算符时，最好用两个运算符时，最好用空白符分隔空白符分隔。。注注

例如： 例如： i+ ++ji+ ++j i++ +ji++ +j

【【 2.9 2.9 表达表达式式】】

1. 1. 算术表达式算术表达式

算术表达式算术表达式是由算术运算符或位运算符与操作数组成的表达式。是由算术运算符或位运算符与操作数组成的表达式。

表达式的值和类型表达式的值和类型由运算符和参与运算的操作数由运算符和参与运算的操作数决定决定：当各操作数的数据类：当各操作数的数据类型型相同相同时，表达式的类型就是时，表达式的类型就是操作数的类型操作数的类型；当类型；当类型不同时不同时，表达式的类型，表达式的类型是是操作数中类型最高的操作数的类型操作数中类型最高的操作数的类型。。

#include<iostream.h>#include<iostream.h>int main()int main(){{

int I(1),J(1);int I(1),J(1);cout<<I++<<'\t'<<++J<<endl;cout<<I++<<'\t'<<++J<<endl;

int A,B;int A,B;A=3;A=3;B=5;B=5;cout<<(A&B)<<endl;cout<<(A&B)<<endl;

算术表达式算术表达式例 例 2-62-6

1 21 211-18.5-18.5

2. 2. 关系表达式与逻辑表达式关系表达式与逻辑表达式

关系表达式关系表达式是由关系运算符和操作数组成的，是由关系运算符和操作数组成的，逻辑表达式逻辑表达式由逻辑运算符与操由逻辑运算符与操作数组成。这两种表达式的值都应是作数组成。这两种表达式的值都应是 11 （（ truetrue ））或或 00 （（ falsefalse ））。。

在进行由在进行由““ &&”&&” 或或““ ||”||” 和和操作数组成的逻辑表达式操作数组成的逻辑表达式运算时，只对从运算时，只对从左开始能够确定整个表达式值所需的左开始能够确定整个表达式值所需的最少数目最少数目的子表达式，即操作数的子表达式，即操作数进行计算，后面的表达式就进行计算，后面的表达式就不再计算不再计算了。了。

注注

double X(2.5);double X(2.5);cout<<X-(X+0.5)*(A|B); //cout<<X-(X+0.5)*(A|B); // 参与运算的操作数类型不相同参与运算的操作数类型不相同cout<<endl;cout<<endl;return 0;return 0;

}}

算术表达式算术表达式例 例 2-62-6

#include<iostream.h>#include<iostream.h>int main(){int main(){

int i(1),j(1),k(3);int i(1),j(1),k(3);--i&&j++&&k--;--i&&j++&&k--;cout<<i<<'\t'<<j<<'\t'<<k<<endl;cout<<i<<'\t'<<j<<'\t'<<k<<endl;++ i ||j--||--k;++ i ||j--||--k;cout<<i<<'\t'<<j<<'\t'<<k<<endl;cout<<i<<'\t'<<j<<'\t'<<k<<endl;return 0;}return 0;}

逻辑表达式逻辑表达式

3. 3. 条件表达式条件表达式

唯一的一个三元运算符：条件运算符“唯一的一个三元运算符：条件运算符“？：？：”。条件运算符的结合性是”。条件运算符的结合性是自右自右向左向左。由条件运算符和。由条件运算符和 33 个操作数组成的式子叫个操作数组成的式子叫条件表达式条件表达式。。

条件表达式的一般形式如下： 条件表达式的一般形式如下： 表达式表达式 11 ？表达式？表达式 22 ：表达式：表达式 33

运算顺序运算顺序是：是：先先计算表达式计算表达式 11 的值，若表达式的值，若表达式 11 的值的值不为零不为零，则计算表达式，则计算表达式22 ，并把它的值作为条件表达式的值；，并把它的值作为条件表达式的值；否则否则计算条件表达式计算条件表达式 33 ，并把它的值，并把它的值作为条件表达式的值。作为条件表达式的值。类型类型为表达式为表达式 22 和表达式和表达式 33 中中类型高的表达式的类型类型高的表达式的类型。。

例 例 2-72-7

#include<iostream.h>#include<iostream.h>int main(){int main(){

int i(3),j(4),k;int i(3),j(4),k;k=(i>j)?++i:++j;k=(i>j)?++i:++j;cout<<i<<'\t'<<j<<'\t'<<k<<endl;cout<<i<<'\t'<<j<<'\t'<<k<<endl;k=i-j?i+j:i-3?j:i;k=i-j?i+j:i-3?j:i;cout<<i<<'\t'<<j<<'\t'<<k<<endl;cout<<i<<'\t'<<j<<'\t'<<k<<endl;return 0;return 0;

}}

条件表达式条件表达式

3 5 53 5 53 5 83 5 8

4. 4. 逗号运算符逗号运算符

逗号也是一个运算符。使用逗号运算符可以将多个表达式组成一个表达式。逗号也是一个运算符。使用逗号运算符可以将多个表达式组成一个表达式。

它的使用形式如下： 它的使用形式如下： 表达式表达式 11 ，表达式，表达式 22 ，…，表达式，…，表达式 nn

例 例 2-82-8

计算计算逗号表达式的值逗号表达式的值时，从左到右时，从左到右先计算先计算第第 11 个表达式的值，个表达式的值，再计算再计算第第 22个表达式的值，…，个表达式的值，…，最后计算最后计算的表达式的值和数据类型便是整个表达式的的表达式的值和数据类型便是整个表达式的值和类型。值和类型。

例如： 例如： int i;int i; i=(10-2,8/2);i=(10-2,8/2); 44

ii 的值的值

5. 5. 赋值表达式赋值表达式

分类分类

基本赋值运算符基本赋值运算符 ::

复合赋值运算符复合赋值运算符

+=+=-=-=*=*=/+/+%=%=<<=<<=>>=>>=&=&=^=^=|=|=

==

由赋值运算符与操作数组成的表达式就叫由赋值运算符与操作数组成的表达式就叫赋值表达式赋值表达式。。

4. 4. 逗号运算符逗号运算符

在在 C++C++ 中还可以连续赋值。中还可以连续赋值。

变量变量 == 表达式表达式说明：可以是说明：可以是 C++C++ 语言中语言中任一合法的表达式。任一合法的表达式。

赋值表达式的赋值表达式的作用作用就是把赋值运算符右边表达式的值赋给左边的变量。就是把赋值运算符右边表达式的值赋给左边的变量。赋值表达式的赋值表达式的类型类型为左边变量的类型，其值为赋值后左边变量的值。为左边变量的类型，其值为赋值后左边变量的值。

例如： 例如： X=2.6 //X=2.6 // 表达式的值为表达式的值为 2.62.6

例如： 例如： X=Y=Z=2.6 X=Y=Z=2.6

说明：首先将说明：首先将 ZZ赋值为赋值为 2.62.6 ，表达式，表达式 Z=2.6Z=2.6 的值也为的值也为2.62.6 ，接着表达式，接着表达式 Z=2.6Z=2.6 的值赋给的值赋给 YY ，使，使 YY 的值为的值为 2.2.66 ，最后，最后 XX 被赋值为被赋值为 2.62.6 ，整个表达式的值也为，整个表达式的值也为 2.62.6 。。

复合赋值运算符复合赋值运算符是由基本赋值运算符和二元算术运算符或位运算符结合在是由基本赋值运算符和二元算术运算符或位运算符结合在一起构成的。一起构成的。

对于基本赋值运算符组成的表达式，它的一般形式是： 对于基本赋值运算符组成的表达式，它的一般形式是：

这些复合运算符组成表达式的一般形式为： 这些复合运算符组成表达式的一般形式为：

变量 复合赋值运算符 表达式变量 复合赋值运算符 表达式

等价等价

变量 变量 = = 变量 算术运算符（或位运算符） 表达式 变量 算术运算符（或位运算符） 表达式

分解为分解为

变量 算术运算符（或位运算符）变量 算术运算符（或位运算符） = = 表达式表达式

例如： 例如： X*=2 //X*=2 // 等价于等价于 X=X*2X=X*2 X*=X+2 //X*=X+2 // 等价于等价于 X=X*X=X* （（ X+2X+2 ））

C++C++ 语言支持不同数据类型的数据之间的语言支持不同数据类型的数据之间的混合运算混合运算。在对这样的表达式。在对这样的表达式求求值时值时，， C++C++ 语言需要对其中的一些操作数进行语言需要对其中的一些操作数进行类型转换类型转换

【【 2.10 2.10 数据类型转数据类型转换换】】

如果两个操作数的类型不同，系统将自动地把其中操作数类型低的转换成如果两个操作数的类型不同，系统将自动地把其中操作数类型低的转换成和另一个相同。和另一个相同。

表达式中的类型转换方式表达式中的类型转换方式隐含转换隐含转换强制转换强制转换

各种类型的高低顺序如下：各种类型的高低顺序如下：intint unsignedunsigned longlong unsigned longunsigned long doubledouble

charchar 、、 shortshort floatfloat

隐含转换的具体规则如下：隐含转换的具体规则如下：

●● charchar 、、 shortshort 类型自动转换成类型自动转换成 intint ，， floatfloat 类型自动转换成类型自动转换成 doubledouble 型。型。

●● 两个操作数中有一个为两个操作数中有一个为 long doublelong double 类型，另一个将也转换成类型，另一个将也转换成 long doubllong doublee 类型；否则，如果其中有一个为类型；否则，如果其中有一个为 doubledouble 类型，另一个将也转换成类型，另一个将也转换成 doubledouble型；…，如上顺序从低向高转换。型；…，如上顺序从低向高转换。

1. 1. 隐含转换隐含转换

long doublelong double

隐式转换的方向隐式转换的方向就是将一个取值范围较小的类型向取值范围较大的类型转就是将一个取值范围较小的类型向取值范围较大的类型转换。它能确保在转换过程中数据不受损失。换。它能确保在转换过程中数据不受损失。

注注 类型的转换类型的转换并不实际改变并不实际改变操作数的数据类型。它只是在计算表达式操作数的数据类型。它只是在计算表达式值的时候，将操作数的值临时做了转换。计算后，操作数仍值的时候，将操作数的值临时做了转换。计算后，操作数仍保持原有保持原有的的数据类型。数据类型。

强制类型转换的强制类型转换的作用作用是将某种类型强制地转换成指定的类型。是将某种类型强制地转换成指定的类型。

强制类型转换是通过强制转换运算符来实现的，具体表示形式如下： 强制类型转换是通过强制转换运算符来实现的，具体表示形式如下： 类型说明符（表达式）类型说明符（表达式）或 或 （类型说明符）表达式（类型说明符）表达式

说明：第说明：第 22 种是种是 CC 语言所采用的风语言所采用的风格，在格，在 C++C++ 中中一般选用第一般选用第 11 种方式种方式。。

意义为把表达式的数据类型强制转换成类型说明符所指定的类型。意义为把表达式的数据类型强制转换成类型说明符所指定的类型。

2. 2. 强制类型转换强制类型转换

例如： 例如： int i;int i; float x(4.5f),yfloat x(4.5f),y ；； y=x-int(x); //y=x-int(x); // 将将 floatfloat 类型转换成类型转换成 intint 类型，类型， int(x)int(x) 值为值为 44 ，后隐，后隐

式转 式转 换继续计算得换继续计算得 yy 值为值为 0.5 0.5

强制类型转换并不改变操作数的数据类型。强制类型转换并不改变操作数的数据类型。

在表达式的类型转换中，赋值表达式是在表达式的类型转换中，赋值表达式是一个特例一个特例。。

当出现把高类型转换成低类型时有可能造成数据精度的损失，是当出现把高类型转换成低类型时有可能造成数据精度的损失，是一种不安全的转换一种不安全的转换。。

注注

(( 续续 ))

语句可用于计算表达式的值、控制程序执行的顺序，有时语句也可能不作语句可用于计算表达式的值、控制程序执行的顺序，有时语句也可能不作任何操作（空语句）。任何操作（空语句）。

分类分类

● ● 表达式语句表达式语句

● ● 块语句块语句

● ● 选择语句选择语句● ● 循环语句循环语句● ● 转移语句转移语句

由表达式在最后加上分号组成。由表达式在最后加上分号组成。例如： 例如： int i; // int i; // 将将 ii声明为整型的语句声明为整型的语句仅由分号组成，在程序中不作任何操作。仅由分号组成，在程序中不作任何操作。例如： 例如： ; // ; // 空语句空语句如果把多条语句用“｛｝”括起来，就组如果把多条语句用“｛｝”括起来，就组成了一个复合语句。复合语句也称块语句。成了一个复合语句。复合语句也称块语句。在块语句的右括号后不再需要分号。在块语句的右括号后不再需要分号。

空语句空语句

【【 2.11 2.11 控制语句控制语句 】】

1. if 1. if 语句语句

选择语句控制程序执行流程的选择语句控制程序执行流程的方式方式是：根据给定的条件，决定执行哪些语是：根据给定的条件，决定执行哪些语句，不执行哪些语句。句，不执行哪些语句。

选择语句分类选择语句分类ifif 语句语句

switchswitch 语句语句

ifif 语句又称条件语句，它的最简单的形式是：语句又称条件语句，它的最简单的形式是： ifif （表达式）（表达式）

语句语句

ifif 语句的语句的意义意义是：如果表达式的值为是：如果表达式的值为 00 ，程序将不执行后面的语句，否则，，程序将不执行后面的语句，否则，执行后面的语句。执行后面的语句。

一般是关系表达式，不过事实上，它可是任何表达式。一般是关系表达式，不过事实上，它可是任何表达式。

可以是单一语句，也可以是块语句。可以是单一语句，也可以是块语句。

【【 2.11 2.11 选择语句选择语句】】

ifif 语句语句

#include<iostream.h>#include<iostream.h>int main()int main(){{

float score;float score;cout<<"Please enter your score:";cout<<"Please enter your score:";cin>>score;cin>>score;if(score>=60)if(score>=60)

cout<< "Passed! "<<endl;cout<< "Passed! "<<endl;if(score <60)if(score <60)

cout<<"No passed!"<<endl;cout<<"No passed!"<<endl;return 0;return 0;

}}

说明：是先测试变量说明：是先测试变量 scorescore是否大于等于是否大于等于 6060 ，然后又，然后又测试其是否小于测试其是否小于 6060 。。

例 例 2-92-9

Please enter your score: 70Please enter your score: 70Passed!Passed!

同一变量不是大于等于某个值就是小于它。同一变量不是大于等于某个值就是小于它。对于这种情况，可用关键字对于这种情况，可用关键字 elseelse 来扩展来扩展 ifif 语句。语句。

使用形式如下： 使用形式如下：

if(if( 表达式表达式 )) 语句语句 11elseelse 语句语句 22

意义：意义：使得程序在表达式值不为使得程序在表达式值不为 00 时，执行语句时，执行语句 11 而不执行语句而不执行语句 22 ；否；否则不执行语句则不执行语句 11 而直接执行语句而直接执行语句 22 。。

(( 续续 ))

关键字关键字 elseelse

//// 利用关键字利用关键字 elseelse改写【例改写【例 2-92-9 】】#include<iostream.h>#include<iostream.h>int main()int main(){{

float score;float score;cout<<"Please enter your score:";cout<<"Please enter your score:";cin>>score;cin>>score;if(score>=60)if(score>=60)

cout<< "Passed! "<<endl;cout<< "Passed! "<<endl;elseelse

{{cout<<"No passed!"<<endl;cout<<"No passed!"<<endl;}}

return 0;return 0;}}

例 例 2-112-11

如果将另一个如果将另一个 ifif 语句完整地嵌入语句完整地嵌入 ifif 语句的语句的 ifif 分支或分支或 elseelse 分支中，就形成分支中，就形成了了 ifif 语句的嵌套语句的嵌套。。

////比较两个数的大小比较两个数的大小#include<iostream.h>#include<iostream.h>int main()int main(){{

int a,b;int a,b;cout<<"Enter a and bcout<<"Enter a and b（（ integerinteger）） :";:";cin>>a;cin>>a;cin>>b;cin>>b;if(a>b)if(a>b)

cout<<"a>b"<<endl;cout<<"a>b"<<endl;elseelse

if(a==b)if(a==b)cout<<"a=b"<<endl;cout<<"a=b"<<endl;

elseelsecout<<"a<b"<<endl;cout<<"a<b"<<endl;

return 0;return 0;}}

ifif 语句的嵌套使用语句的嵌套使用例 例 2-112-11

ifif 语句嵌套使用时语句嵌套使用时，在一个，在一个 ifif 语句中可以有许多的语句中可以有许多的 ifif 和和 elseelse ，这些，这些 ifif 和和 elselsee 如何配对是一个问题。如何配对是一个问题。C++C++ 语言中采用的原则是“就近”语言中采用的原则是“就近”，即一个，即一个 elseelse 和离它最近的那个和离它最近的那个 ifif 配对。配对。在实际编程时，为提高程序的可读性，减少错误，常常有意识地加一些括在实际编程时，为提高程序的可读性，减少错误，常常有意识地加一些括号，把嵌套的号，把嵌套的 ifif 语句表示成块语句。语句表示成块语句。

Enter a and bEnter a and b （（ integerinteger ）） :1 :1 2 2a<b a<b

(( 续续 ))

////找出三个数中的最大者，并输出找出三个数中的最大者，并输出#include<iostream.h>#include<iostream.h>int main()int main(){{

int a,b,c;int a,b,c;

cout<<"Please enter three integers:";cout<<"Please enter three integers:";cin>>a>>b>>c;cin>>a>>b>>c;if(a>=b)if(a>=b)

if(a>=c)if(a>=c)cout<<a<<endl;cout<<a<<endl;

elseelsecout<<c<<endl;cout<<c<<endl;

elseelseif(b>=c)if(b>=c)

cout<<b<<endl;cout<<b<<endl;elseelse

cout<<c<<endl;cout<<c<<endl;return 0;return 0;

}}

ifif 和和 elseelse 的配对问题的配对问题例 例 2-122-12

#include<iostream.h>#include<iostream.h>int main()int main(){{

int a,b,c;int a,b,c;

cout<<"Please enter three integers:";cout<<"Please enter three integers:";cin>>a>>b>>c;cin>>a>>b>>c;if(a>=b)if(a>=b){{

if(a>=c)if(a>=c)cout<<a<<endl;cout<<a<<endl;

elseelsecout<<c<<endl;cout<<c<<endl;

}}else{else{

if(b>=c)if(b>=c)cout<<b<<endl;cout<<b<<endl;

elseelsecout<<c<<endl;cout<<c<<endl;

}}return 0;return 0;

}}

改写成改写成

它的一般形式如下： 它的一般形式如下：

switchswitch （表达式）（表达式） {{ case case 常量表达式常量表达式 11 ：语句：语句 11 ；； case case 常量表达式常量表达式 22 ：语句：语句 22 ；； … … ；； case case 常量表达式常量表达式 nn ：语句：语句 nn ； ； default: default: 语句语句 n+1;n+1; }}

ifif 语句嵌套使用时，如果嵌套得太深，程序将难于理解。为此，对应语句嵌套使用时，如果嵌套得太深，程序将难于理解。为此，对应于用于用 ifif 语句嵌套多次测试同一表达式值的情况，语句嵌套多次测试同一表达式值的情况， C++C++ 语言提供了语言提供了 switchswitch语句。语句。 switchswitch 语句又称语句又称开关语句开关语句。。

switchswitch 语句的执行顺序是：语句的执行顺序是：首先首先计算计算 switchswitch 语句中表达式的值，然后语句中表达式的值，然后按先后顺序按先后顺序将得到的结果与将得到的结果与 casecase 中常量表达式的值比较，如果两者中常量表达式的值比较，如果两者相等相等，，程序就转到此处，由此开始顺序执行。如果程序就转到此处，由此开始顺序执行。如果没有相等没有相等的，则从的，则从 defaultdefault 处开处开始执行。在没有始执行。在没有 defaultdefault 部分的情况下，执行就结束，开始执行后面的语句。部分的情况下，执行就结束，开始执行后面的语句。

可是任何合法的语句或多个语句，如可是任何合法的语句或多个语句，如果是多个语句，它们可以不用括号括果是多个语句，它们可以不用括号括起来形成块语句。起来形成块语句。

括号中可是任一合法的括号中可是任一合法的 C++C++ 语言表达式。语言表达式。

可没有。可没有。

2. switch 2. switch 语句语句

在大多数情况下，在大多数情况下， switchswitch 语句在语句在执行完执行完某一某一 casecase 后面的语句后，后面的语句后，不再执行不再执行其他的其他的 casecase 和和 defaultdefault 分支，直接开始执行分支，直接开始执行 switchswitch 语句语句后面的语句后面的语句。需要。需要这个这个 casecase 分支中的最后一条语句是分支中的最后一条语句是 breakbreak 语句语句。如果没有。如果没有 breakbreak 语句，程语句，程序将继续执行下一个序将继续执行下一个 casecase 或或 defaultdefault 分支。分支。

#include<iostream.h>#include<iostream.h>

int main()int main(){ {

char choice;char choice;

cout<<"--------------M E N U------------------"<<endl;cout<<"--------------M E N U------------------"<<endl;cout<<" N(ew) O(pen) S(ave) D(elete) "<<endl;cout<<" N(ew) O(pen) S(ave) D(elete) "<<endl;cout<<"cout<<"Please select one:";Please select one:";cin>>choice;cin>>choice;switch(choice) switch(choice) {{

case 'N':case 'N':cout<<"cout<<" 新建文件新建文件 "<<endl;"<<endl;break;break;

switchswitch 语句语句例 例 2-132-13

case 'O': case 'O': cout<<"cout<<" 打开文件打开文件 "<<endl;"<<endl;break;break;

case 'S': case 'S': cout<<"cout<<" 保存文件保存文件 "<<endl;"<<endl;break;break;

case 'D':case 'D':cout<<"cout<<" 删除文件删除文件 "<<endl;"<<endl;break;break;

default:default: cout<<"cout<<" 对不起，选择错误！对不起，选择错误！ "<<endl;"<<endl;

}}return 0;return 0;

}}

(( 续续 ))

--------------M E N U--------------------------M E N U------------N(ew) O(pen) S(ave) D(elete) N(ew) O(pen) S(ave) D(elete) Please select one: Please select one: S S保存文件保存文件

循环语句使得程序在给定条件满足时，重复地执行一些操作。循环语句使得程序在给定条件满足时，重复地执行一些操作。

do-whiledo-while 语句语句循环语句分类循环语句分类whilewhile 语句语句

forfor 语句语句

1. while1. while 语句语句

一般形式为： 一般形式为： whilewhile （表达式） 语句（表达式） 语句

whilewhile 语句的语句的执行顺序执行顺序是：是：先先计算表达式的值，若其值为计算表达式的值，若其值为 falsefalse （（ 00 ）），则，则不执行不执行 whilewhile 语句中的循环体，直接转移去语句中的循环体，直接转移去执行执行 whilewhile 语句后语句后的语句；若的语句；若其值为其值为 truetrue （（ 11 ））或或其他非其他非 00 值值，则，则执行循环体执行循环体；之后再次；之后再次计算计算表达式表达式的的值值，按上述原则处理其值为零或非零两种情况，直至表达式值为零。，按上述原则处理其值为零或非零两种情况，直至表达式值为零。

可是可是 C++C++ 语言中任何合法的表达式，语言中任何合法的表达式，它是确定其后语句是否执行的条件。它是确定其后语句是否执行的条件。

又称循环体，可以是单一又称循环体，可以是单一语句或块语句。语句或块语句。

【【 2.11.2 2.11.2 循环语循环语句句】】

#include<iostream.h>#include<iostream.h>int main()int main(){{

int a(1),total(0);int a(1),total(0);while(a<=100)while(a<=100)

{{total+=a;total+=a;++a;++a;}}

cout<<"total="<<total<<endl;cout<<"total="<<total<<endl;return 0;return 0;

}}

whilewhile 语句语句

total=5050total=5050

使用循环语句时，一定要确保循环最终会终止，也即不会出现死循环。使用循环语句时，一定要确保循环最终会终止，也即不会出现死循环。因此，循环体内常常包含有改变循环条件表达式值的语句。因此，循环体内常常包含有改变循环条件表达式值的语句。

也可在循环体内使用也可在循环体内使用 breakbreak 等转移语句来中止循环语句。等转移语句来中止循环语句。

例 例 2-142-14

while(1)while(1) 语句语句

#include<iostream.h>#include<iostream.h>int main()int main(){ {

char choice;char choice;while(1)while(1){{

cout<<"--------------M E N U------------------"<<endl;cout<<"--------------M E N U------------------"<<endl;cout<<" N(ew) O(pen) S(ave) D(elete) Q(uit) "<<endl;cout<<" N(ew) O(pen) S(ave) D(elete) Q(uit) "<<endl;cout<<"cout<<"Please select one:";Please select one:";cin>>choice;cin>>choice;switch(choice)switch(choice){{

case 'N':case 'N':cout<<"cout<<"新建文件新建文件 "<<endl;"<<endl;break;break;

case 'O':case 'O':cout<<"cout<<"打开文件打开文件 "<<endl;"<<endl;break;break;

例 例 2-152-15

2. do-while2. do-while 语句语句

do-whiledo-while 语句的一般形式如下： 语句的一般形式如下： do do 语句语句while while （表达式）；（表达式）；

do-whiledo-while 语句最后的分号语句最后的分号不可缺少不可缺少。。注注

(( 续续 ))case 'S': case 'S':

cout<<"cout<<"保存文件保存文件 "<<endl;"<<endl;break;break;

case 'D': cout<<"case 'D': cout<<"删除文件删除文件 "<<endl;"<<endl;}}

if(choice=='Q') break;if(choice=='Q') break;}}return 0;return 0;

}}

do-whiledo-while

首先执行循环体，再求表达式的值，如其值非首先执行循环体，再求表达式的值，如其值非00 ，则再次执行循环体，直至表达式的值为零；，则再次执行循环体，直至表达式的值为零；循环体至少 执行一次。循环体至少 执行一次。

whilewhile

do-whiledo-while 语句与语句与 whilewhile 语句的差别语句的差别

首先求表达式的值，再按首先求表达式的值，再按其值为零或非零决定是否其值为零或非零决定是否执行循环体。执行循环体。

#include<iostream.h>#include<iostream.h>int main()int main(){{

int a(1),total(0);int a(1),total(0);dodo{{

total+=a;total+=a;++a;++a;

} while(a<=100);} while(a<=100);cout<<"total="<<total<<endl;cout<<"total="<<total<<endl;return 0;return 0;

}}

do-whiledo-while 语句语句

total=5050total=5050

例 例 2-162-16

执行顺序是：执行顺序是：首先首先计算计算表达式表达式 11 的值，的值，再再计算计算表达式表达式 22 的值，并根据表达的值，并根据表达式式 22 的值的值决定决定是否执行循环体。如果表达式是否执行循环体。如果表达式 22 的值为的值为 truetrue 或或其他非其他非 00 值值，，则则执行执行循环体，否则循环体，否则退出退出循环。每执行完一次循环体后，先计算循环。每执行完一次循环体后，先计算表达式表达式 33的值，然后再计算表达式的值，然后再计算表达式 22 的值，并根据表达式的值，并根据表达式 22 的值决定是否继续执行的值决定是否继续执行循环体。循环体。

3. for3. for 语句语句

forfor 语句的语法形式如下： 语句的语法形式如下：

forfor （表达式（表达式 11 ；表达式；表达式 22 ；表达式；表达式33 ））

语句语句

////求自然数求自然数 1~1001~100 的和的和#include<iostream.h>#include<iostream.h>int main()int main(){{

forfor 语句语句

可是任一合法的表达式，该表达式用来设置可是任一合法的表达式，该表达式用来设置循环的条件，其循环的条件，其值值为为 truetrue 或或其他非其他非 00 值值时，时，则则执行执行循环体中的语句，否则循环体中的语句，否则退出退出循环。循环。

可是任一合法的表达式，但一可是任一合法的表达式，但一般用来给循环变量般用来给循环变量赋初值赋初值。。

用来修改循环变量的值，也可用来修改循环变量的值，也可是其他任一合法的表达式。是其他任一合法的表达式。

例 例 2-172-17

int a,total(0);int a,total(0);for(a=1;a<=100;a++)for(a=1;a<=100;a++)

total+=a;total+=a;cout<<"total="<<total<<endl;cout<<"total="<<total<<endl;return 0;return 0;

}}

注意事

注意事

项项

●● forfor 语句中的语句中的 33 个表达式并个表达式并不一定不一定需要存在。但是每个表达式后的分需要存在。但是每个表达式后的分号不能省略。如果号不能省略。如果 33 个表达式都省略，个表达式都省略， forfor 语句的形式如下： 语句的形式如下：

forfor （；；） 语句（；；） 语句在循环体内必须有其他控制循环执行的语句，否则会形成在循环体内必须有其他控制循环执行的语句，否则会形成死循环死循环。。● ● 表达式表达式 11 如果省略或不是用来给循环变量赋初值，则应在如果省略或不是用来给循环变量赋初值，则应在 forfor 语语句前句前给循环变量赋初值。给循环变量赋初值。

● ● 表达式表达式 22 如果省略，则在如果省略，则在 forfor 语句循环体内必须有其他控制循环执语句循环体内必须有其他控制循环执行的语句，否则会形成行的语句，否则会形成死循环死循环。。

● ● 表达式表达式 33 如果省略或不是用来修改循环变量的值，则应在如果省略或不是用来修改循环变量的值，则应在 forfor 语语句循环体内设置相应的语句。句循环体内设置相应的语句。

total=5050total=5050

(( 续续))

////输出整数输出整数 1~10 1~10 #include<iostream.h>#include<iostream.h>

int main()int main(){{

int i(1);int i(1);for(;i<=10;)for(;i<=10;)

cout<<i++<<'\t';cout<<i++<<'\t';cout<<endl;cout<<endl;return 0;return 0;

}}

省略省略 forfor 语句的语句的一些表达式一些表达式

1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 10

循环也可以循环也可以嵌套使用嵌套使用，即在一个循环的循环体内又可包含另一个完整的循，即在一个循环的循环体内又可包含另一个完整的循环，构成多重循环。环，构成多重循环。 whilewhile 语句、语句、 do-whiledo-while 语句、语句、 forfor 语句语句可以相互嵌套。可以相互嵌套。

例 例 2-182-18

////给数组的每个元素赋值并按顺序输出给数组的每个元素赋值并按顺序输出#include<iostream.h>#include<iostream.h>

int main()int main(){{

int i,j;int i,j;int b(1);int b(1);int a[5][10];int a[5][10];for(i=0;i<5;++i)for(i=0;i<5;++i)

for(j=0;j<10;j++)for(j=0;j<10;j++)a[i][j]=b++;a[i][j]=b++;

i=0;i=0;while(i<5)while(i<5){{

j=0;j=0;dodo

循环语句的嵌套使用循环语句的嵌套使用

循环语句也可以和选择语句相互嵌套使用。选择语句中的任一分循环语句也可以和选择语句相互嵌套使用。选择语句中的任一分支语句都可以包含一个完整的循环语句，循环语句中的循环体内支语句都可以包含一个完整的循环语句，循环语句中的循环体内也可以包含一个完整的选择语句。也可以包含一个完整的选择语句。

注注

例 例 2-192-19

cout<<a[i][j]<<'\t';cout<<a[i][j]<<'\t';while(++j<10);while(++j<10);cout<<endl;cout<<endl;i++;i++;

}}return 0;return 0;

}}

1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 10

11 12 13 14 15 16 17 18 19 2011 12 13 14 15 16 17 18 19 20

21 22 23 24 25 26 27 28 29 3021 22 23 24 25 26 27 28 29 30

31 32 33 34 35 36 37 38 39 4031 32 33 34 35 36 37 38 39 40

41 42 43 44 45 46 47 48 49 5041 42 43 44 45 46 47 48 49 50

(( 续续 ))

C++C++ 语言还提供了一些转移语句，它们主要用于改变程序中语句的执行顺语言还提供了一些转移语句，它们主要用于改变程序中语句的执行顺序，使程序从某一语句有目的地转移到另一语句继续执行。序，使程序从某一语句有目的地转移到另一语句继续执行。

转移语句分类转移语句分类breakbreak 语句语句continuecontinue 语句语句gotogoto 语句语句

1. break1. break 语句语句

breakbreak 语句的格式： 语句的格式： breakbreak ；；

continuecontinue 语句的格式是： 语句的格式是： continuecontinue ；；

2. continue2. continue 语语句句

用在用在 switchswitch 语句中。语句中。

用在循环语句的循环体内，对于多重循环，用在循环语句的循环体内，对于多重循环， breakbreak语句的执行将导致其所在的那重循环执行的结束，语句的执行将导致其所在的那重循环执行的结束，开始执行该重循环后面的语句。开始执行该重循环后面的语句。

breakbreak 语句的限制语句的限制（（仅用的情况仅用的情况））

【【 2.11.3 2.11.3 转移语转移语句句】】

continuecontinue 语句语句出现在循环语句出现在循环语句的循环体内。在循环执行的过程中，如果的循环体内。在循环执行的过程中，如果遇到遇到 continuecontinue 语句，程序将语句，程序将结束本次循环结束本次循环，接着开始下一次的循环。，接着开始下一次的循环。

#include<iostream.h>#include<iostream.h>int main()int main(){{

int a,total(0);int a,total(0);cout<<"cout<<" 请输入需要求和的正整数请输入需要求和的正整数 (( 以以 0 0 结束结束 ): ";): ";for(;;)for(;;)

{{cin>>a;cin>>a;if(a==0) break;if(a==0) break;if(a<0) continue;if(a<0) continue;total+=a;total+=a;}}

cout<<"total="<<total<<endl;cout<<"total="<<total<<endl;return 0;return 0;

}}

continuecontinue 语句语句

说明：确保不把用户输入的负数说明：确保不把用户输入的负数计入总和。计入总和。

例 例 2-212-21

gotogoto 语句的语句的作用作用是使程序转移到语句标号所标识的语句处继续执行。是使程序转移到语句标号所标识的语句处继续执行。

3. goto3. goto 语句语句

goto goto 语句标号；语句标号；

语句标号标识语句的形式如下： 语句标号标识语句的形式如下： 语句标号：语句；语句标号：语句；或 或 语句标号：语句标号： 语句；语句；

gotogoto 语句的使用语句的使用被限制在一个函数体内被限制在一个函数体内，即，即 gotogoto 语句只能在一个函数范围语句只能在一个函数范围内进行语句转移。在同一函数中，语句标号内进行语句转移。在同一函数中，语句标号应该是唯一的应该是唯一的。。

使用使用 gotogoto 语句不是一个好的习惯。由于语句不是一个好的习惯。由于 gotogoto 语句的使用会破坏程语句的使用会破坏程序的结构，编程时，应尽量少用或不用它。序的结构，编程时，应尽量少用或不用它。

注注

gotogoto 语句的使用形式如下： 语句的使用形式如下：

#include<iostream.h>#include<iostream.h>int main()int main(){{

int i,j;int i,j;int a[2][5];int a[2][5];

input:input: cout<<"Please input 10 integers(not equal zero):";cout<<"Please input 10 integers(not equal zero):";for(i=0;i<2;++i)for(i=0;i<2;++i)

for(j=0;j<5;j++)for(j=0;j<5;j++)cin>>a[i][j];cin>>a[i][j];

for(i=0;i<2;++i)for(i=0;i<2;++i)for(j=0;j<5;j++)for(j=0;j<5;j++)

if(a[i][j]==0)if(a[i][j]==0){{

cout<<"Have zero,Please input again!"<<endl;cout<<"Have zero,Please input again!"<<endl;goto input;goto input;

}}return 0;return 0;

}}

gotogoto 语句语句

说明：确保数组说明：确保数组 aa 元素的值元素的值不为不为 00

例 例 2-222-22

小 结小 结

11 、字符是、字符是 C++C++ 语言的基本要素，是程序中可以区分的最小符语言的基本要素，是程序中可以区分的最小符 号。词法记号是号。词法记号是 C++C++ 语言的最小语法单位。语言的最小语法单位。 C++C++ 语言中，语言中，共共 有有 55 种词法记号：关键字、标识符、文字常量、运算符和分种词法记号：关键字、标识符、文字常量、运算符和分 隔符。隔符。22 、数据是程序处理的对象，它们都应该属于某种数据类型。、数据是程序处理的对象，它们都应该属于某种数据类型。 C++C++ 语言的基本数据类型有语言的基本数据类型有 44 种：布尔型（种：布尔型（ boolbool ）、字符）、字符型型 （（ charchar ）、整型（）、整型（ intint ）、浮点型（）、浮点型（ floatfloat 、、 doubledouble ）。此）。此外，外， C++C++ 语言还提供了语言还提供了 44 个关键字：个关键字： signedsigned （表示有符号）、（表示有符号）、 unsignedunsigned （表示无符号）、（表示无符号）、 shortshort （表示短型）、（表示短型）、 longlong （表（表示示 长型），用来作为前缀修饰字符型、整型、浮点型。长型），用来作为前缀修饰字符型、整型、浮点型。33 、、 CC ＋＋程序中，数据有变量与常量之分。其中，变量的值＋＋程序中，数据有变量与常量之分。其中，变量的值在在 程序运行时，是可以改变的，而常量的值不允许改变的。程序运行时，是可以改变的，而常量的值不允许改变的。

小 结（续）小 结（续）

44 、枚举类型和数组类型是、枚举类型和数组类型是 CC ＋＋类型语言的自定义数据类型。＋＋类型语言的自定义数据类型。 数组是类型相同、数目一定的变量的有序集合。在内存分配数组是类型相同、数目一定的变量的有序集合。在内存分配 时，数组对应着一组顺序排放的存储单元，数组的每个元素时，数组对应着一组顺序排放的存储单元，数组的每个元素 按照声明时的次序在其中存放。按照声明时的次序在其中存放。55 、运算是指对数据的求值计算，参与运算的数据叫操作数（变、运算是指对数据的求值计算，参与运算的数据叫操作数（变 量、常量）。量、常量）。 C++C++ 语言定义了丰富的运算符。这些运算符语言定义了丰富的运算符。这些运算符按按 所要求的操作数的多少，分可为一元运算符、二元运算符、所要求的操作数的多少，分可为一元运算符、二元运算符、 三元运算符。按运算符的运算性质又可分为算术运算符、关三元运算符。按运算符的运算性质又可分为算术运算符、关 系运算符、逻辑运算符等。运算符具有优先级与结合性。系运算符、逻辑运算符等。运算符具有优先级与结合性。66 、变量、常量（操作数）通过运算符组合成表达式。表达式是、变量、常量（操作数）通过运算符组合成表达式。表达式是 计算求值的基本单位。计算求值的基本单位。 C++C++ 语言中，常见的表达式有：算语言中，常见的表达式有：算术术 表达式、关系表达式、逻辑表达式、条件表达式、逗号表达表达式、关系表达式、逻辑表达式、条件表达式、逗号表达 式、赋值表达式等。式、赋值表达式等。

小 结（续）小 结（续）

77 、、 C++C++ 语言支持混合运算。混合运算时，需要对其中的一些语言支持混合运算。混合运算时，需要对其中的一些操操 作数进行类型转换。表达式中的类型转换方式有两种：隐含作数进行类型转换。表达式中的类型转换方式有两种：隐含 转换和强制转换。其中，强制类型是一种不安全的转换。转换和强制转换。其中，强制类型是一种不安全的转换。88 、、 C++C++ 语言提供了选择语句、循环语句、转移语句。它们能语言提供了选择语句、循环语句、转移语句。它们能控控 制程序的执行流程。制程序的执行流程。