《Visual C++ 6.0程序设计》课件第2章

第2章C++语言基础2.1编码基础2.2数据类型2.3常量与变量2.4运算符和表达式2.5基本语句2.6构造类型2.7函数2.8指针思考题

2.1编码基础

C++语言是在C语言的基础上增加了对面向对象程序设计的支持发展起来的，而VisualC++6.0又是以C++为基础的。因此，学习VisualC++6.0语言编程，首先要掌握C++程序设计的基础知识，对C++的基本组成、基本符号、保留字和标识符有一定的了解，它们是阅读和编写程序的基础。2.1.1基本组成

一个C++程序通常由预处理命令、函数、语句、变量、输入输出以及注释等几个部分组成。例如：

#include<iostream.h> //预处理命令

voidmain(void) //主函数

{

charmyname[10]; //变量

cout<<''请输入姓名：''; //输出

cin>>myname[10]; //输入

cout<<''欢迎使用VisualC++6.0''<<endl; //输出

}其中#include<iostream.h>是预处理命令。voidmain(void)是函数，main是主函数名。每条语句用分号结束。charmyname[10]表示定义字符串变量，myname是变量名。cin>>myname[10]表示通过键盘输入变量myname的值。cout<<"欢迎使用VisualC++6.0"<<endl表示在屏幕上显示双引号里的内容，endl表示显示后换行。“//”表示其右边的内容为该语句的注释。

1．预处理命令

在C++程序中，预处理命令以“#”开始，其作用是在编译之前将系统定义的头文件“iostream.h”包含到当前程序中。该头文件设置了C++的输入输出环境，如cin、cout就是在iostream.h中定义的标准输入、输出设备标识符。C++提供三种预处理命令:宏定义命令、文件包含命令以及条件编译命令。

2．函数

一个C++程序通常由若干个函数组成，这些函数有C++系统提供的库函数，也有用户根据需要编写的自定义函数。在C++程序的这些函数中，必须有且仅有一个主函数main，函数体用大括号{}括起来，不论主函数位于什么位置，该程序都是从主函数开始执行的。

3．变量

在C++程序中，需要将数据存放于内存单元中，而变量就是用来存储和访问内存单元中数据的标识符。变量有整型、字符型、浮点型等基本数据类型。

4．语句

语句是组成程序的基本单元，如顺序语句、选择语句、循环语句等。所有的语句以分号结束，最简单的语句是空语句，它仅包括一个分号。

5．输入和输出

在C++程序中常有输入和输出语句，特别是通过键盘输入以及屏幕输出的功能，几乎每个程序都要用到。

6．注释

一个高质量、有价值的C++源程序应加上必要的注释，这可以提高程序的可读性。注释并不参加程序的运行。

注释有两种方式：“//”表示的是单行注释，“/*…*/”表示的是多行注释。2.1.2基本符号

C++程序中的基本符号有以下三类：

1．字母

大小写英文字母：A～Z，a～z，共52个符号。

2．数字

数字字符：0～9，共10个符号。

3．特殊字符

空格 ! # % ^ & * _(下划线) + = － ~ < > / \

'

" ; . , () [] {}等，共33个符号。2.1.3关键字

在C++程序中关键字又称为保留字，是有特定的专门含义的单词，在编程时不能用于其他用途。下面列出常用的关键字，如表2-1所示，其含义和用法在相关的章节中再加以介绍。

需要注意的是，记住这些常用的关键字，可以避免用户在定义标识符时与关键字重名而产生错误。

表2-1C++常用的关键字2.1.4标识符

标识符是程序员声明的单词，用于命名程序正文中的一些实体，如变量、常量、函数和其他用户自定义对象等。为了增加程序的可读性，在定义标识符时，注意做到“见名知意”。在C++中，命名标识符的规则如下：

(1)必须以字母或下划线“_”开头，由字母、数字或下划线组成，如：Abc、n1、_s_2等都是合法的标识符，而3abc、A*B、&Num都是不合法的，标识符中间不允许有空格。

(2)不能使用C++中的关键词，如if、for、int等都不能用作标识符。

(3)标识符中字母区分大小写，如Abc和abc认为是不同的标识符。

(4)标识符的有效长度为32，也就是说前32个字符相同的两个不同的标识符认为是同一个标识符。

2.2数据类型

在各种程序设计语言中，数据类型的规定和处理方法是各不相同的。C++的数据类型可以大致分为基本数据类型和自定义数据类型。

2.2.1基本数据类型

基本数据类型由系统定义和提供，常用的有int(整型)、float(单精度浮点型)、double(双精度浮点型)、char(字符型)、void(无值型)、bool(逻辑型)等。在基本类型前面加上类型修饰符就形成了基本类型的派生类型。类型修饰符有signed(有符号的)、unsigned(无符号的)、short(短型的)、long(长型的)四种。

各种基本数据类型及其常用的派生类型的描述及表示范围如表2-2所示。

表2-2C++的基本数据类型注：出现[int]可以省略，即在int之前有类型修饰符signed、unsigned、short、long时，可以省略关键字int。2.2.2自定义数据类型

自定义数据类型是由用户根据所需构造的数据类型，包括数组、指针、结构、枚举以及类等。

以下仅介绍枚举类型,其他类型将在后面章节中陆续介绍。

枚举是将变量的值一一列举出来，使变量的值限于列举的范围内。

枚举的一般形式是：

enum<类型名>{<枚举值表>}<枚举变量表>；

每个枚举值均有一个固定的整数值。如果没有显式赋值，则第一个枚举值为0，后续枚举值依次递增1。如果有显式赋值，则可以设置1个或多个特定值，其未赋值的后续枚举值依次递增1。例如：

enumday1{Sun,Mon,Tue,Wed,Thu,Fri,Sat};

enumday2{Mon=1,Tue,Wed,Thu,Fri,Sat,Sun};

由此可以看出，枚举类型day1没有显式赋值，它的7个值为Sun=0,Mon=1,Tue=2,Wed=3,Thu=4,Fri=5,Sat=6。枚举类型day2有显式赋值，它的7个值为Mon=1,Tue=2,Wed=3,Thu=4,Fri=5,Sat=6,Sun=7。

2.3常 量 与 变 量

根据程序中数据的可变性，数据可以分为常量与变量两大类。常量是在程序运行过程中不变的量，变量是在程序运行过程中可以发生变化的值。在编程时，常量和变量必须遵循“先声明，后使用”的原则，即所有常量和变量必须在使用前用说明语句进行说明，否则编译器就会产生错误。

2.3.1常量

在程序运行过程中，其值不变的量称为常量。根据不同的数据类型，常量可以有以下表示方法。

1．整型常量

整型常量可以用十进制、八进制和十六进制表示。

1)十进制整型常量

十进制整型常量即十进制整数，如12，345等。

2)八进制整型常量

以0开头的数是八进制整数，它由0～7的数字组成。如065，表示八进制数65，相当于十进制数53；如－017，表示八进制数－17，相当于十进制数－15。

3)十六进制整型常量

以0x或0X开头的数是十六进制整数，它由0～9、a～f或A～F组成。如0x7b，表示十六进制数0x7b，相当于十进制数123；如－0x2f，表示十六进制数－0x2f,相当于十进制数－47。

2．浮点型常量

浮点型常量即实数，它有十进制和指数两种表示形式。

1)十进制形式

它由整数部分和小数部分组成，如0.12、.12、1.2、12.0、0.0等。需要注意的是这些数都必须包含小数点。

2)指数形式

指数形式采用科学记数法，它可以表示出很大或很小的浮点数。如1.2e8或1.2E8，表示1.2×108。需要注意的是，字母e或E前必须有数字，且字母e或E后面的指数必须是整数。

3．字符常量

字符常量是用一对单引号括起来的一个字符，如‘A’、‘b’、‘&’等都是字符常量。注意‘A’和‘a’是两个不同的字符常量。

4．字符串常量

字符串常量是用一对双引号括起来的一个字符序列。如“Hello!”、“abcd”等都是字符串常量。注意：字符串常量可以包括空格、转义序列符或其他字符。由于双引号是字符串的分界符，因此如果需要在字符串中出现双引号则必须用“|”表示。字符串常量必须写在同一行，若要换行，则需要用“\”连接。

5．符号常量

在C++语言中，也可以用一个标识符表示一个常量，根据定义方法区分，又分为const常量和宏常量。

1) const常量

用const定义的常量，即正规常量，其说明语句的一般形式是：

const<类型名><常量名>=<表达式>；

例如：

constfloatpi=3.14；//定义常量pi的值为3.14使用规则如下：

(1)必须以const开头；

(2)类型名为基本类型及其派生类型；

(3)常量名为标识符；

(4)表达式应与常量类型一致。

在程序中用pi代替3.14，可以提高程序的可读性和可维护性。

2)宏常量

用#define定义的常量，即宏常量，其说明语句的一般形式是：

#define<宏名><常量>

例如：

#definePI3.14；//定义宏常量pi的值为3.14

使用规则如下：

(1)宏名可以是简单的字符名,也可是带有参数的函数名；

(2)常量可以是数值、字符串和函数等。

由于宏替换是在编译时把出现的所有的宏名PI都用3.14来替换，相当于两个字符串的替换，所以容易产生错误，因此在大多数情况下建议使用const常量。2.3.2变量

变量是指在程序运行过程中其值可以发生变化的量，它可以用来存储程序中需要处理的数据，可以放在程序的任何位置。但需要注意的是：在使用变量前，必须要用说明语句对变量进行说明。

1．变量说明

变量说明语句的一般形式是：

[<存储类>]<类型名或类型定义><变量名表>；

其中各部分的功能及使用规则如下：

1)存储类

(1) auto属于一次性存储，其存储空间可以被若干变量多次覆盖使用；

(2)

register存放在通用寄存器中；

(3) extern在所有函数和程序段中都可引用；

(4) static在内存中是以固定地址存放的，在整个程序运行期间都有效。

其中，[<存储类>]的方括号表示可以缺省，作为auto变量。

2)类型名或类型定义

在任何变量说明语句中，数据类型定义不可缺省。

3)变量名表

其格式为以下几种：

<变量名>

<变量名>=<表达式>

<变量名1>=[<表达式1>],<变量名2>=[<表达式2>],…

其中表达式就是变量的初始化值。

例如：

inti; //定义整型变量i

charch1=‘A’; //定义字符型变量ch1，并赋值为字符A

floatnum1=1.2,num2,num3=29.6; //定义单精度浮点型变量num1，

//num2，num3；并将num1赋值

//为1.2,将num2赋值为29.62．变量作用范围

在C++语言中，变量说明语句可以出现在程序的任何位置。在不同的位置声明，其作用域不同。它主要分为全局变量和局部变量。

(1)全局变量：其说明语句不在任何一个类定义、函数定义和复合语句(程序块)中的变量。全局变量所占用的空间在内存的数据区，在程序运行的整个过程中位置保持不变。

(2)局部变量：其说明语句在某一个类定义、函数定义或复合语句(程序块)中的变量。局部变量所占用的空间在为程序运行时设置的临时工作区中，以堆栈的形式允许反复占用和释放。

【例2-1】通过变量的位置认识全局变量和局部变量的作用域。

程序如下：

#include“stdafx.h”

#include<iostream.h>

intmain(intargc,char*argv[])

{

intnum1=0,num2=0; //定义全局变量num1，num2，并赋初值

num1++;

num2++;

//将num1加1后赋给num1，将num2加1后

//赋给num2

cout<<“num1=”<<num1<<“,”<<“num2=”<<num2<<endl；

//输出num1，num2的值

{

floatnum1=7.7;

//定义局部变量num1

num1++; num2++;

cout<<"num1="<<num1<<","<<"num2="<<num2<<endl;

}

num1++; num2++;

cout<<“num1=”<<num1<<“,”<<“num2=”<<num2<<endl;

return0;

}

上例中全局变量int型num1的作用域为5～7行和13～16行，int型num2的作用域为5～16行；局部变量float型num1的作用域为8～12行。

程序运行结果如图2-1所示。图2-1变量的作用域运行结果

2.4运算符和表达式

C++语言中运算符是表示实现某种运算的符号，表达式是运算符和操作数的组合，通过运算符和表达式可以实现程序编制中所需的大量操作。下面将介绍C++的运算符、运算符的优先级和结合规则以及表达式等基本内容。

2.4.1算术运算符

C++的算术运算符包含单目运算符和双目运算符，其中单目运算符有减、增量、减量运算符，双目运算符有加、减、乘、除和模运算符。表2-3列出了各算术运算符(设整型变量a=12，b=5)。

1．单目减

单目减相当于取负号运算。例如：-a的值为-12。

2．增量运算

增量运算有前缀增量和后缀增量两种形式。

前缀增量：++<运算分量>；//使用运算分量前其值加1

后缀增量：<运算分量>++；//使用运算分量后其值加1

例如：

++a；//相当于a=a+1，即把a加1的值赋给a

b=++a；//相当于a=a+1，b=a，即先把a加1的值赋给a，再把a的值赋给b

a++；//相当于a=a+1，即把a加1的值赋给a

b=a++；//相当于a=a+1，b=a，即先把a的值赋给b，再把a加1的值赋给a

3．减量运算

减量运算除了将加法改为减法外，其余和增量运算完全相同。

4．优先级和结合性

优先级是指多种运算之间的先后关系。在算术运算符中，单目运算的优先级最高，其次是 * (乘)、/ (除)和％(求余)，最后是+(加)、－(减)。

运算符的结合性是指运算符和操作数的结合方式，它有“从左到右”和“从右到左”两种。对于优先级相同的运算符，按照它们的结合性进行处理。在算术运算符中，除单目运算符外，其余双目运算符的结合性都是从左到右的。2.4.2赋值运算符

赋值运算符是程序设计中最基本的运算符，利用赋值运算符可以给一个变量赋值。其一般形式为：

<变量名>=<表达式>；

其中，各部分的作用如下：

(1)表达式：一般要求其类型与变量名的类型一致。

(2)“=”为赋值运算符，它不同于数学上的等号。赋值运算的作用是：先计算右边表达式的值，然后将值赋给左边的变量。例如：

sum=num1+num2;

s=s+n;

在程序中经常出现类似于s=s+n这样的赋值语句，C++还允许采用更为简洁的形式写为s+=n。于是构成了复合赋值运算符，如表2-4所示。

在赋值运算符中，复合赋值运算符和赋值运算符的优先级是一样的。赋值运算符的优先级仅高于后面要讲到的逗号运算符。

赋值运算符的结合性是从右到左的。下面的例子用来解释表2-4中逐位与、逐位或及逐位异或的含义。

例如：a的值为3，对应的二进制数是011；b的值为5，对应的二进制数是101。

a&=b，即二进制数011和101逐位与，得到001，相当于十进制数1，所以运行后a的结果是1。

a|=b，即二进制数011和101逐位或，得到111，相当于十进制数7，所以运行后a的结果是7。

a^=b，即二进制数011和101逐位异或，得到110，相当于十进制数6，所以运行后a的结果是6。2.4.3关系运算符

关系运算符是双目运算符，作用是将两个运算分量进行大小比较，其结果类型为bool。若关系成立，则值为true，否则为false。

表2-5列出了C++提供的6种关系运算符。上表中的前4种即 < (小于)、<= (小于等于)、> (大于)、>= (大于等于)优先级相同，并高于后面的2种即 == (等于)、!= (不等于)。关系运算符的优先级低于算术运算符，它的结合性是从左到右的。2.4.4逻辑运算符

C++提供3种逻辑运算符，单目运算符有逻辑非，双目运算符有逻辑与和逻辑或。其结果类型为bool，其值只能为true或false。

在C++语言中，bool型和int型都属于整数类型，bool值true和false同时分别对应于int型的值1和0，而整型也可以转换成bool型，非零整数转换为true，而0转换成false。

这3种逻辑运算符如表2-6所示。上表中的!(逻辑非)、&&(逻辑与)、||(逻辑或)优先级依次从高到低。!(逻辑非)的优先级比算术运算符和关系运算符高，而&&(逻辑与)、||(逻辑或)的优先级低于关系运算符。

逻辑运算符的结合性是从左到右的。2.4.5条件运算符

条件运算符是三目运算符，其一般形式为：

<表达式1>？<表达式2>：<表达式3>

该表达式的使用规则如下：

(1)表达式1必须是bool类型。

(2)执行顺序及结果。先求解表达式1。若表达式1的值为true，则求解表达式2，表达式2的值为最终结果；若表达式1的值为false，则求解表达式3，表达式3的值为最终结果。例如：

x=a>b?a:b;//作用是将a，b中大的数赋值给x

(3)优先级和结合性。条件运算符优先级高于赋值运算符，低于逻辑运算符。条件运算符的结合性是从右到左的。2.4.6逗号运算符

逗号运算符可以使多个表达式写在一行上，从而大大简化了程序，其一般形式为：

<表达式1>，<表达式2>

该表达式的使用规则如下：

(1)执行顺序及结果。先求解表达式1，再求解表达式2，最终结果为表达式2的值。

例如：

a=2*4,a*6//最终结果为48

(2)优先级和结合性。逗号运算符是优先级最低的运算符。逗号运算符的结合性是从左到右的。2.4.7sizeof运算符

字长提取符sizeof运算符实际上是系统提供的一个函数，其一般形式为：

sizeof(<运算分量>)

该表达式的使用规则如下：

(1)运算分量可以是类型名，也可以是表达式。

(2)结果值为“类型名”所指定的类型或“表达式”的结果类型所占的字节数。

例如：

inta

sizeof(short)//返回值是2

sizeof(a)//返回值是4

C++提供了对数据进行位运算的功能，其运算符如表2-7所示。其中，左移运算(<<)指左移后，低位补0，高位舍弃。右移运算(>>)指右移后，低位舍弃；高位无符号数补0，有符号数补“符号位”。

位运算符的优先级低于算术运算符，高于逻辑运算符&&(逻辑与)，||(逻辑或)。

位运算符的结合性除单目运算符按位取反是从右到左，其余双目位运算符都是从左到右的。

注意：在编程时，如果对于运算符的优先级不确定时，可以添加括号保证结果正确，因为有括号的部分优先计算。

2.5基本语句

C++提供了顺序语句、选择语句、循环语句来实现结构化程序设计的三种结构，即顺序结构、选择结构和循环结构。

2.5.1顺序语句

顺序语句就是所有语句按照出现的顺序先后执行。顺序语句包括表达式、空语句和复合语句。

1．表达式语句

表达式语句是最简单的语句，任何一个表达式加上分号就是一个表达式语句，其一般形式为：

表达式；

例如：

a+b;

num1=num2;

表达式语句与表达式的区别：表达式可以包含在其他表达式中，而语句不可。

例如：

if((a=b)>0)t=a;

不可写为

if((a=b;)>0)t=a;

2．空语句

空语句就是什么都不做的语句，相当于一个空表达式，其一般形式为：

：

3．复合语句

复合语句是由两条以上的语句组成，并用一对大括号{}括起来。它又称为块语句或块程序，其一般形式为：

{

<语句1>

<语句2>

…

<语句n>

}

例如：

{

sum=sum+i;

i++;

}

4．基本输入和输出语句

在前面的章节中，用到cin和cout分别实现从键盘输入和在显示器上输出。绝大多数C++程序都使用了系统提供的I/O流，以实现基本的输入和输出操作。在I/O流类的定义中，把C++语言中的左、右移位运算符“<<”和“>>”，通过运算符重载的方法定义为插入(输出)和提取(输入)运算符。cin和cout是预先定义的流的对象，分别为标准输入流和标准输出流，一般代表标准输入设备(键盘)和标准输出设备(显示器)。例如：

cin>>a;

//表示从键盘输入变量a的值

cout<<a; //表示在显示器上输出变量a的值

为了更好地调整输入输出格式，C++提供了格式控制函数和格式控制符。

1) flags

flags函数的形式一般有以下两种：

longflags(long1Flags)；

longflags()；

第一种形式是通过参数1Flags重新设置标志字并返回原来的标志字；另一种形式是无参的flags函数用来返回当前的标志字。

2) setf

setf函数的形式一般有以下两种：

longsetf(long1Flags)；

longsetf(long1Flags,long1Mask)；

第一种形式是通过参数1Flags来设置指定的格式控制标志位；另一种形式是用来设置指定的格式控制标志位的值。

3) unsetf

unsetf函数的一般形式为：

longunsetf(long1Flags)；

这种形式是通过参数1Flags来清除指定的格式控制标志位(使那些位的值为“0”)。

4) fill

fill函数的形式一般有以下两种：

charfill(charcFill)；

charfill()；

第一种形式是将填充字符设置为cFill，并返回原填充字符；另一种形式是无参数的fill函数将返回当前的填充字符。

5) precision

precision函数的形式一般有以下两种：

intprecision(intnp)；

intprecision()；

第一种形式是设置浮点数精度为np，并返回原精度；另一种形式是无参数的precision函数将返回当前的浮点数精度。

6) width

width函数的形式一般有以下两种：

intwidth(intnw)；

intwidth()；

第一种形式设置当前显示数据的域宽nw，并返回原域宽；另一种形式是无参的width函数将返回当前显示数据的域宽。

定义在iostream.h文件中的无参I/O控制符有：

(1) endl：输出时插入换行符并刷新流。

(2) ends：输出时在字符串后插入NULL作为结束符。

(3) flush：刷新流，将缓冲区中的当前信息立即输出到目标设备。

(4) ws：输入时略去前导的空白字符(空格、Tab键、换行)。

(5) dec：令I/O数据按十进制格式(默认数制)。

(6) hex：令I/O数据按十六进制格式。

(7) oct：令I/O数据按八进制格式。

【例2-2】

使用格式控制函数和格式控制符显示不同输出格式的数据。

程序如下：

#include"stdafx.h" //头文件

#include<iostream.h>

#include<iomanip.h>

intmain(intargc,char*argv[])

{ constfloatNum=3.1415926;

cout<<"1234567890"<<endl; //定位

cout.flags(ios::right); //设置对齐的标志位是右

cout<<setw(10)<<Num<<endl; //显示数据的域宽是10

cout.fill(‘*’); //填充字符'*'

cout.width(12); //显示数据的域宽是12

cout<<Num<<endl;

cout.precision(4);

//浮点数的有效个数为4

cout<<Num<<endl;

cout.setf(ios::showpos); //显示正号

cout.precision(3); //浮点数的有效个数为3

cout<<Num<<endl;

cout.unsetf(ios::showpos); //显示正号

intn; cout<<''输入一个八进制整数：'';

cin>>oct>>n;

//输入一个八进制数

cout<<''八进制数n是：''<<oct<<n<<endl;

cout<<''对应的十进制数是：''<<dec<<n<<endl;

cout<<''对应的十六进制数是：''<<hex<<n<<endl;

return0;

}程序运行结果如图2-2所示。图2-2格式控制运行结果2.5.2选择语句

选择语句用来判断所给定的条件是否满足，根据判断结果，选择执行不同的分支语句。常用的选择语句有：if语句、if-else语句、多重if-else语句和switch语句。

1．if语句

if语句为单分支条件语句，其一般形式为：

if(<表达式>)<语句>；

该表达式可以是int型、long型、char型和enum型，其值等于0为假，非0为真。语句可以是任何类型的语句，也可以是语句块。该语句的作用是：如果表达式的值为真，则执行后面的语句；否则跳过后面的语句。单分支结构流程如图2-3所示。图2-3单分支结构流程

【例2-3】

已知两个变量x和y，比较它们的大小。当x小于y时，交换这两个变量的值，使x的值大于y。

程序如下：

#include"stdafx.h"

#include<iostream.h>

intmain(intargc,char*argv[])

{

intx,y,t; //定义变量x，y，t，其中t为中间变量

cout<<"Pleaseenterxandy:"<<endl;

cin>>x>>y;

if(x<y) //单分支结构，判断x，y的大小

{

t=x;x=y;y=t;

}

cout<<"x="<<x<<","<<"y="<<y<<endl;

return0;

}

程序运行结果如图2-4所示。图2-4比较两个数大小运行结果

2．if-else语句

if-else语句为双分支条件语句，其一般形式为：

if(<表达式>)<语句1>；else<语句2>；

该语句的作用是：如果表达式的值为真，则执行后面的语句1；否则执行语句2。双分支结构流程如图2-5所示。

【例2-4】

计算分段函数：图2-5双分支结构流程输入x，得到相应的y值。用双分支条件语句来实现该程序。

程序如下：

#include“stdafx.h”

#include<iostream.h>

#include<math.h> //包含数学函数头文件

intmain(intargc,char*argv[])

{

floatx,y; //定义x,y

cout<<“输入x:”<<endl;

cin>>x;

if(x!=0)

//双分支结构

y=sin(x)+sqrt(x*x+2);

else

y=cos(x)-3*x;

cout<<“y=”<<y<<endl;

return0;

}

程序运行结果如图2-6所示。图2-6计算分段函数运行结果

3．多重if-else语句

多重if-else语句为多分支条件语句，其一般形式为：

if(<表达式1>)<语句1>；

elseif(<表达式2>)<语句2>；

elseif(<表达式n>)<语句n>；

else<语句n+1>；

该语句为if语句的嵌套，在嵌套时，C++语言规定每个else只与其前面最近的未配对的if配对，也可以用{}确定层次关系。该语句的作用是根据不同的表达式值确定执行哪个语句块，依次测试表达式1、表达式2、…，一旦遇到表达式的值为真，则执行该条件下的语句块。多分支结构流程如图2-7所示。图2-7多分支结构流程

【例2-5】

输入学生的百分制成绩，判断该学生的等级。

等级评定条件为：程序如下：#include"stdafx.h"#include<iostream.h>intmain(intargc,char*argv[]){floatscore; //定义学生分数scorecout<<"输入学生分数:"<<endl;cin>>score;

if(score>=90) //多分支结构

cout<<"优"<<endl;

elseif(score>=80)

cout<<"良"<<endl;

elseif(score>=70)

cout<<"中"<<endl;

elseif(score>=60)

cout<<"及格"<<endl;

else

cout<<"不及格"<<endl;

return0;

}程序也可以写成：

#include"stdafx.h"

#include<iostream.h>

intmain(intargc,char*argv[])

{

floatscore; //定义学生分数score

cout<<"输入学生分数:"<<endl;

cin>>score;

if(score>=90) //多分支结构

cout<<"优"<<endl;

else

{

if(score>=80)

cout<<"良"<<endl;

else {

if(score>=70)

cout<<“中”<<endl;

else

{

if(score>=60)

cout<<“及格”<<endl;

else

cout<<“不及格”<<endl;

}

}

}

return0;

}

程序运行结果如图2-8所示。图2-8判断学生成绩的等级运行结果

4．switch语句

switch语句也称情况语句，它是多分支语句的另一种表示形式，这种语句条件表示直观，但必须符合其规定的语法规则书写。其一般形式为：

switch(<表达式>)

{

case<常量表达式1>：<语句1>；break;

case<常量表达式2>：<语句2>；break;

…

case<常量表达式n>：<语句n>；break;

default：<语句n>；break;

}该语句的作用是：首先计算switch表达式后的值，然后将其结果与case后面的各常量表达式进行比较。若匹配，则执行该分支后的语句。执行完该分支后， 遇到break语句， 则退出switch语句。若其结果与case后面的各常量表达式都不匹配，则执行default后面的语句。其流程如图2-9所示。

在使用switch语句时应注意以下几点：

(1)若case后面没有break语句，则程序顺序执行后续的语句，直到switch语句结束。这样就不能实现多分支选择。

(2) switch语句只能对表达式的结果为固定的值进行判断，而不能对其结果是否在某区域进行判断，这与多重if-else语句有所不同。

(3)每个常量表达式的值不能相同，case的次序不影响执行结果。图2-9switch语句流程

【例2-6】

输入两个整数，再输入运算符，并将运算符转换成对应的四则运算。

程序如下：

#include"stdafx.h"

#include<iostream.h>

intmain(intargc,char*argv[])

{

intx,y;

charopr;

cout<<"输入两个整数:";

cin>>x>>y;

cout<<"输入运算符:";

cin>>opr;

switch(opr)

{

case‘+’:cout<<x+y<<endl;break;

 case‘-’:cout<<x－y<<endl;break;

 case‘*’:cout<<x*y<<endl;break;

 case‘/’:cout<<x/y<<endl;break;

 case‘%':cout<<x%y<<endl;break;

}

return0;

}

程序运行结果如图2-10所示。图2-10swtich用法运行结果2.5.3循环语句

循环语句用来在指定的条件下多次重复执行一组语句。常用的形式有for语句、while语句和do-while语句。

1．for语句

for语句是最常见的、功能最强的循环语句。它既可以用于循环次数确定的情况，也可以用于循环次数不确定而只给出循环结束条件的情况。其一般形式为：

for(<表达式1>;<表达式2>;<表达式3>)<语句>；其中，for是关键字，语句可以是单条语句，也可以是语句块，它是要被循环重复执行的程序段，故又称为循环体。表达式1是对循环控制变量进行初始化，表达式2是循环条件，当判断条件为非0时，开始执行循环体，然后计算表达式3，表达式3对循环控制变量进行递增或递减， 再判断表达式2的值是否为非0，若是，继续执行循环体，再计算表达式3，如此反复，直到表达式2等于0为止。for循环结构的流程如图2-11所示。需要注意的是：这三个表达式都可以缺省，但分号“；”不能省略。在使用循环结构编程时应保证循环一定会终止，否则，循环可能永不结束。图2-11for循环结构的流程【例2-7】

计算1～100的奇数和。

程序如下：

#include"stdafx.h"

#include<iostream.h>

intmain(intargc,char*argv[])

{

ints=0;

for(inti=1;i<=100;i=i+2)s+=i;

cout<<"1～100的奇数和是："<<s<<endl;

return0;

}

程序运行结果如图2-12所示。图2-12for语句求1～100的奇数和运行结果

2．while语句

while语句是最简单的循环语句，它实际上是for语句在表达式1和表达式3为空时的特殊情形。其一般形式为：

while(<表达式>)<语句>；

其中，表达式用来判定循环是否继续，当表达式条件成立时，执行循环体。while语句要求能够在循环体内改变表达式的值，以使表达式条件不成立时退出循环体。语句为循环体。while循环结构的流程如图2-13所示。图2-13while循环结构的流程

【例2-8】用辗转相除法求两个自然数m，n的最大公约数。

求最大公约数的算法思想：

(1) m除以n得余数r；

(2)若r≠0，则将m←n，n←r，重复执行步骤(1)；

(3)若r=0，则n为求得的最大公约数，算法结束，否则重复执行步骤(1)。

程序如下：

#include"stdafx.h"

#include<iostream.h>

intmain(intargc,char*argv[])

{

intm,n,r; cout<<"输入正整数m:";

cin>>m;

cout<<"输入正整数n:";

cin>>n;

r=m%n;//求余

while(r!=0)

{

m=n;

n=r;

r=m%n;

}

cout<<"最大公约数是:"<<n<<endl;

return0;

}

程序运行结果如图2-14所示。图2-14求最大公约数运行结果

3．do-while语句

do-while语句是while语句的一种变化形式。 其一般形式为：

do<语句>while(<表达式>)；

do-while先执行循环体，然后判断表达式是否成立， 若成立则重复执行循环体，否则退出循环。do-while循环结构的流程如图2-15所示。

do-while语句与while语句的主要区别是：do-while语句的循环体至少被执行一次，而while语句先判断条件，有可能一次也不执行。

【例2-9】

输入一个正整数，求出它的所有因子并输出。图2-15do-while循环结构的流程程序如下：

#include"stdafx.h"

#include<iostream.h>

intmain(intargc,char*argv[])

{

unsignedintn,f=1;

cout<<"输入一个正整数:";

cin>>n;

cout<<"整数"<<n<<"的因子有";

do

{

if(n%f==0)cout<<f<<"";//判断是否为因子，并输出每一个因子

f++;

}while(f<=n);

cout<<endl;

return0;

}程序运行结果如图2-16所示。图2-16do-while语句求数的因子运行结果

4．循环的嵌套

在一个循环体内又包含了一个完整的循环结构称为循环的嵌套。

【例2-10】

编程求“水仙花数”。所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身。例如，153是水仙花数，因为153=13+53+33。

方法1：利用三重循环编写程序。因为“水仙花数”是三位数，所以一定都在100~999范围内。外循环变量i控制百位数字从1变化到9，中层循环变量j控制十位数字从0变化到9，内循环变量k控制个位数字从0变化到9。程序如下：

#include''stdafx.h''

#include<iostream.h>

intmain(intargc,char*argv[])

{

inti,j,k,m,n;

cout<<''水仙花数是：''<<endl;

for(i=1;i<=9;i++) //外循环

for(j=0;j<=9;j++) //中层循环

for(k=0;k<=9;k++) //内循环

{

m=i*i*i+j*j*j+k*k*k; //立方和

n=100*i+10*j+k; //该数

if(m==n)cout<<m<<endl;

}

return0;

}

程序运行结果如图2-17所示。图2-17循环嵌套求水仙花数运行结果方法2：不使用循环嵌套，只用一个for语句编写程序。

程序如下：

#include''stdafx.h''

#include<iostream.h>

intmain(intargc,char*argv[])

{

inti,j,k,n;

cout<<''水仙花数是：''<<endl;

for(n=100;n<=999;n++)

{

i=n/100;//i为百位数字

j=n/10-i*10//j为十位数字

k=n%10//k为个位数字

if(i*i*i+j*j*j+k*k*k==n)

cout<<n<<endl;

}

return0;

}2.5.4转向语句

转向语句是用来实现无条件转移的语句。常用的语句形式有：break语句、continue语句、goto语句和return语句。

1．break语句

break语句又称跳出语句，用来结束循环结构，然后执行循环体后面的语句。其一般形式为：

break;

break语句也可以作为switch语句的出口,用于退出case结构。

【例2-11】

输出100以内所有的素数。

素数，也称质数，就是一个大于2且只能被1和本身整除的整数。判断素数的常用算法是：对于i，只要能被2到i－1中任何一个数整除，i就不是素数，否则i是素数。程序如下：

#include''stdafx.h''

#include<iostream.h>

intmain(intargc,char*argv[])

{

constn=100;

cout<<''100以内的素数有：''<<endl;

for(inti=2;i<=n;i++)

{

intflag=1;

//flag相当于一个判断标志，首先用来

//假设m为素数

for(intj=2;j<i;j++)

//判断i是否是素数，也可以将j<i改为j<=sqrt(i)

{

if(i%j==0){flag=0;break;}

//如果i能被j整除,该i不是素

//数，退出本次循环

}

if(flag==1)cout<<i<<‘,’;

//依次显示判断出的素数

}

cout<<endl;

return0;

}

程序运行结果如图2-18所示。图2-18break语句求素数运行结果

2．continue语句

continue语句又称继续语句，可以用来跳出本次循环而进入下一次循环。其一般形式为：

continue;

continue语句与break语句的主要区别是：continue语句是根据条件判断只结束本次循环，不结束整个循环结构，而break语句则结束整个循环结构，不再进行判断，然后执行循环体后面的语句。【例2-12】

输出100以内所有能被7整除的数。

程序如下：

#include"stdafx.h"

#include<iostream.h>

intmain(intargc,char*argv[])

{

intn=100,i;

cout<<"100以内能被7整除的数有："<<endl;

for(i=1;i<=n;i++)

{

if(i%7!=0)continue; //如果i不能被7整除，则开始下

//一次循环

cout<<i<<‘,’; //如果i能被7整除，则输出

}

cout<<endl;

return0;

}

程序运行结果如图2-19所示。图2-19continue语句运行结果

3．goto语句

goto语句又称转向语句，用来将程序无条件跳转到指定的标号语句处。其一般形式为：

goto<标号>;

其中标号是一个标志符，其定义出现在标号语句中；它的一般形式为：

<标号>:<语句>

需要注意的是：goto语句的使用会使程序结构不清晰，可读性差。在结构化程序设计中要求尽量少用或不用goto语句。

【例2-13】

通过键盘输入一个数，如果该数不是两位数，即小于10或大于99就用goto语句转到标号位置，要求重新输入。程序如下：

#include''stdafx.h''

#include<iostream.h>

intmain(intargc,char*argv[])

{

intnum;

L1:cout<<''输入一个两位数：''<<endl;

cin>>num;

cout<<num<<endl;

if(num<10||num>99)gotoL1;//如果输入的数num不是两位数，则重新输入

return0;

}

程序运行结果如图2-20所示。图2-20goto语句举例运行结果

4．return语句

return语句又称返回语句，可以用来停止执行当前函数，转而执行调用该函数后面的语句。其一般形式为：

return<表达式>;

表达式可以是任何类型的变量，也可以是void型。需要注意的是所返回的表达式的类型必须与函数的类型一致。

【例2-14】

编写一函数返回两个数的最小值。

程序如下：

#include''stdafx.h''

#include<iostream.h>

intmax(intx,inty){ return(x<y?x:y);}//返回x,y的最小值

intmain(intargc,char*argv[])

{

inta,b;

cout<<"输入两个数，求出最小值："<<endl;

cin>>a>>b;

cout<<"最小值为："<<max(a,b)<<endl;

return0;

}

程序运行结果如图2-21所示。图2-21return语句举例运行结果

2.6构造类型

在前面讲到由用户构造的自定义数据类型，其中对枚举类型已经作了相应介绍，本节就对属于构造类型的数组、结构、联合以及typedef等类型进行一一介绍。

2.6.1数组

数组并不是一种数据类型，而是一组相同类型的变量的集合。在程序中使用数组的好处是可以用一个统一的数组名代表逻辑上相关的一组数据，并用下标表示各元素在数组中的位置。

1．数组的声明

一维数组的声明，其一般形式为：

<类型名><数组名>[<元素个数>]={<初值表>};

多维数组的声明，其一般形式为：

<类型名><数组名>[<下标表达式1>][<下标表达式2>]…

各部分的含义如下。

(1)类型名：可以是基本类型名，也可以是基本类型的派生类型名、类名、枚举类型名、结构、联合类型名。

(2)数组名：是标志符，表示数组元素在内存中的起始位置，是常量，不能赋值。

(3)元素个数：是一个正整数，表示数组的元素个数或数组的大小。元素个数要用方括号“[]”括起来。方括号不可缺省，元素个数则可缺省，但必须赋初值，系统会根据所赋的初值个数来确定数组的大小。

(4)初值表：可以缺省，用大括号“{}”括起来，并用逗号“，”分开每个初值。

例如：

charch[10]; //定义长度为10的一维字符型数组

inta[]={3,6,9}; //定义一维整型数组a并给数组第0到第2个元素依次赋值为3，6，9

floatb[3][5]; //定义二维单精度浮点型数组b，该数组有3行5列

2．数组元素的引用

定义数组时用数组名表示该数组的整体，但C++语言没有提供对数组进行整体操作的运算符和运算，而是在数组的具体操作时针对每个数组元素进行，即通过下标变量进行。

数组元素引用的一般形式为：

<数组名>[<下标>]…

下标表达式的个数应与维数相同。注意下标表达式的值从0开始，并且不允许改变，所以数组的有效下标为从0到表达式的值(元素个数)减1。

例如：

inta[5];

共有5个数组元素，分别为a[0],a[1],a[2],a[3],a[4]。数组定义后，系统会根据数组的大小开辟相应的内存，并依次存放。

例如：

intb[3,5];

其存放次序为：

b[0][0],b[0][1],b[0][2],b[0][3],b[0][4],

b[1][0],b[1][1],b[1][2],b[1][3],b[1][4],

b[2][0],b[2][1],b[2][2],b[2][3],b[2][4].

需要注意的是：为了提高程序的执行速度，C++语言对于数组的越界使用不作检查，所以编程时要注意在数组元素的引用时不要超过所定义的长度。

3．数组的赋值

给数组元素赋值，有初始化、赋值语句、输入语句三种方式。

1)初始化

即在定义时，便给数组元素指定相应的值。例如：

inta[5]＝{1,2,3,4};

相当于给a[0],a[1],a[2],a[3]分别赋值为1、2、3、4，而a[4]没有赋初值。

inta[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};

相当于分行给二维数组赋初值。

2)赋值语句

例如：

a[4]＝2*a[3];

相当于把2×4＝8赋值给a[4]。

3)输入语句

例如：

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

相当于通过循环语句和键盘操作，给数组的5个元素依次赋值。

【例2-15】

矩阵的转置。

例如a矩阵为：转置后的矩阵b为：矩阵转置的方法是将a数组第i行第j列的元素赋值给b数组第j行第i列。程序如下：

#include"stdafx.h"

#include<iostream.h>

intmain(intargc,char*argv[])

{

inta[3][5],n=1; //定义一个3行5列的矩阵a

intb[5][3]; //定义一个5行3列的矩阵b

inti,j;

cout<<"a矩阵为："<<endl;

for(i=0;i<3;i++)

{

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

{ a[i][j]=n++; //依次给元素赋值为1，2，3…

b[j][i]=a[i][j]; //将a转置后赋值给b

cout.width(5); //控制输出格式，输出宽度为5

cout<<a[i][j];

}

cout<<endl;

}

cout<<''a矩阵的转置b矩阵为：''<<endl;

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

{

for(j=0;j<3;j++)

{

cout.width(5); //控制输出格式，输出宽度为5

cout<<b[i][j];

}

cout<<endl;

}

return0;

}

程序运行结果如图2-22所示。图2-22矩阵的转置运行结果

4．字符数组

从表面上看，一个字符串就是一个字符数组，但在C++语言中，它们是不完全相同的。

字符串是一个以空字符‘\0’作为结束符的字符型数组。从下面的例子可以看出其区别：

charch1[]={"Hello"};

//ch1的字符长度为6，由5个字符和‘\0’组成

charch2[7]={"Hello"};

//ch2的字符长度为7，前6个元素已赋初值并

//分别为'H','e','l','l','o'和'

\0'

charch3[5]={'H','e','l','l','o'};

//ch3的字符长度为5，其5个元素已赋

//初值并分别为'H','e','l','l','o'

5．数组的应用

数组在程序设计中使用频繁，为了熟练地掌握数组的使用，下面介绍一些常用算法。

1)数组排序

排序是将一组数按递增或递减的次序排列。排序有很多种方法，常用的有比较交换法、选择法、冒泡法以及插入法等，最简单的是选择法。

【例2-16】

用选择法对数组a进行递增排序。

思路：

①从n个数中，逐个比较，从中选出最小(递增)的数及所在的下标，与第1个数交换位置。

②除第1个数，其余n－1个数按①方法。

排序进行的过程如图2-23所示。图2-23选择法排序过程示意图程序如下：

#include"stdafx.h"

#include<iostream.h>

intmain(intargc,char*argv[])

{

inti,j,k,t;

inta[6]={7,6,9,4,2,8};

intn=6;

cout<<"排序前的数组：";

for(i=0;i<n;i++)

cout<<a[i]<<"";

cout<<endl;

for(i=0;i<n-1;i++) //进行n-1轮比较

{

k=i; //对第i轮比较时，初始假定第i个元素最小

for(j=i+1;j<n;j++)

if(a[j]<a[k])k=j;//在i～n个元素中选出最小元素的下标

t=a[k];a[k]=a[i];a[i]=t;//在i～n个元素中选出最小元素与第i个

//元素交换

}

cout<<“排序后的数组：”;

for(i=0;i<n;i++)

cout<<a[i]<<“”;

cout<<endl;

return0;

}

程序运行结果如图2-24所示。图2-24选择法排序运行结果

2)分类统计

分类统计是经常遇到的运算，是将一批数据按分类的条件统计每一类中包含的个数。

【例2-17】

随机产生20位同学的成绩，统计各个分数段人数，即0～59、60～69、70～79、80～89、90～100，并显示结果。

程序如下：

#include"stdafx.h"

#include<ios