C++讲义.docx

C++讲义.docx

《C++讲义.docx》由会员分享，可在线阅读，更多相关《C++讲义.docx（54页珍藏版）》请在冰豆网上搜索。

C++讲义

5．复合赋值操作符:

这是一种赋值运算与数学运算组合的操作符。

P28

+=（加赋值）、-=（减赋值）、*=、/=、%=

例：

intmyAge=5,temp;

temp=myAge+2;

myAge=temp;

上述程序（2—3行）可改写为：

myAge+=2;表示将右值与左值相加，并将结果重新赋给左值。

6．增1减1操作符（自加与自减）

增1运算符（++）便变量的值增加1；

减1运算符（--）使变量的值减少1；

如c++;相当于c=c+1;也相当于c+=1;

（1）前增（前减）：

++i或--i,又称为前置，是提取变量的值前先对变量增1（或减1），然后在参与表达式的计算，如：

intx=5;

inta=++x;

先将x的值增1，再赋给a，其结果x与a的值均为6。

（2）后增（后减）又称为后置，如c++或c--，是先取值参与表达是的运算，然后再增1或减1，如：

intx=5;inta=x++;先取x的值赋给a，然后x增1结果为a的值是5，x的值是6。

P34练习

7．Sizeof操作符：

用于获得数据类型所占空间的字节数。

格式：

sizeof（类型修饰符）或（表达式）

实P201-1

8．逻辑型数据与逻辑表达式：

逻辑型数据用于表达条件判断的结果，其值为“真”或“假”true或false，在内存中占1字节。

（1）关系操作符和关系表达式：

==等于、！

=不等于、>、<、>=、<=；

关系表达式的结果是true或false；

、>、<、>=、<=优先级高

==等于、！

=不等于优先级低

（2）逻辑操作符与逻辑表达式：

！

逻辑非、&&逻辑与、||逻辑或

（x==5）&&（y==5）两边的xy均为5时表达式的结果为真；

（x==5）||（y==5）x、y有一个为5时表达式的结果为真

非真为假，非假为真；

（3）等价条件：

如!

（x==y）和x!

=y当x和y相等时，如同为5，则x==y的值为真，!

（x==y）的值为假，而x!

=y的值也为假。

（4）有关真和假的进一步讨论：

a）在C++中，0代表假，其他所有值都代表真，如

if（x）相当于if（x!

=0）,当x=0时表示假，否则为真；

if（!

x）相当于if（x==0）,当x=0时表示真，否则为假；实P30

（2）

b）逻辑型与其他数据类型的关系：

false转换成0，true转换成1；

在用数值数据对逻辑变量进行初始化时或赋值时，任何非0都被转换成1。

（5）条件运算符（三目运算符）

格式：

条件？

表达式1：

表达式2

功能：

实现简单的选择，如条件成立即为ture，返回表达式1的值，否则返回表达式2的值。

例:

max=（a>b）?

a:

b;

表达式1或表达式2本身也可以是表达式,即条件表达式可以嵌套。

例：

x>0?

1:

（x<0?

-1:

0）

在用于简单判断时，条件表达式比if语句要简洁。

9．运算符的优先级：

！

非高

算术运算符

关系运算符

&&和||

条件运算符（三目运算符）

赋值运算符低

10．表达式的副作用：

C++中有意识地引入副用用机机制，在使用带有副作用的运算符时，不但要提取变量的值，还可以改变他们的值。

如k+=2

逗号操作符与逗号表达式：

格式：

表达式1，表达式2

其值为表达式2的值。

如x=（k++,j），结果为j的值，表达式中的括号不能省略，逗号表达式常用于for语句中。

P48练习

第三章C++程序的流程控制

一、流程控制与程序结构

1．顺序结构：

2．条件分支结构：

3．循环结构：

二、条件分支结构

1．If语句

格式：

if（条件）语句1[else语句2]

a）如果“条件”成立就执行语句1，否则执行else后的语句。

b）if语句中的条件可以是一个逻辑表达式，如果不是逻辑表达式，则0值转换成false，非0值将转换成ture。

c）if语句中的语句1和语句2可以是复合语句（多于一条语句），如果是复合语句要包括在{}中，而且{}中的每条语句的结尾都要有“；”但{}本身不需要“；”。

P55例3-1

if语句可以嵌套：

if语句中的语句1和语句2本身也可以是if语句。

Else总是和它最近的if对应。

P563-2、P573-4、P583-5

P573-4练习3-5

#include

voidmain（）

{

inta,b,c,d,t;

cout<<"input4:

";

cin>>a>>b>>c>>d;

if（a>b）{t=a;a=b;b=t;}

if（a>c）{t=a;a=c;c=t;}

if（a>d）{t=a;a=d;d=t;}

if（b>c）{t=b;b=c;c=t;}

if（b>d）{t=b;b=d;d=t;}

if（c>d）{t=c;c=d;d=t;}

cout<

";

cout<

}

P583-5实验3-4

#include

voidmain（）

{

floata,b,c;

cout<<"请输入工作时间和每小时工资数:

";

cin>>a>>b;

if（a>50）

cout<<40*b+10*1.5*b+（a-50）*3*b;

else

if（a>40）

cout<<40*b+（a-40）*1.5*b;

else

cout<

}

d）多分支结构：

if多分支结构是特指一种通过规范化的if嵌套所构成的条件分支结构，在这样的结构中if语句嵌套在else之后。

P613-6

2．用switch实现多分支结构

格式：

switch（整型表达式）

case整型表达式1：

语句序列1

case整型表达式n：

语句序列n

default语句序列n+1

功能：

逐个判定表达式的值是否与整型常量表达式的值相等（这种比较只能是相等的情况，而不是相当于关系运算或逻辑运算的比较），如果相等即执行后面的语句序列，遇到break跳出switch语句。

如果都不相等则执行default后面的语句序列。

P633-7P643-8

a）整型表达式如果不是整型将被自动转成整型（通常是一个整型常量）；

b）按顺序执行；

c）语句序列可以是空语句；

d）break的作用是跳出switch语句；

三、循环结构

1．for循环

格式：

for（循环初始化；循环条件；循环参数调整）循环体

功能：

先对循环变量赋初值，如果其值满足循环条件就执行循环体，然后循环条件比较，如果仍然满足，则继续执行循环体，然后再调整，直到不满足循环条件为止。

P683-9

a）循环初始化和循环参调整应当是具有副作用的表达式；

b）其中循环参数的调整应能趋向于循环结束，否则将形成死循环；

c）循环条件应是一个逻辑表达式；

d）应注意for语句中各部分执行顺序；

for（inta=1;a<=10;a++）

;

cout<

e）循环体可以是单语句也可是复合语句，如果是复合语句要加{}

例P683-9、P693-10、P703-11

2．While循环

格式：

while（循环条件）循环体

功能：

先判断循环条件是否成立，如果成立则执行循环体P71图3-11，一切用for实现的语句也可以用while语句实现。

将例3-9改为用while语句实现

例3-12、3-12

（2）、例3-13、3-14

3．do----while循环

格式：

do循环体while（循环条件）

功能：

先执行循环体，然后判断循环条件，如果判断结果为真，则继续执行循环体，因此循环至少被执行一次。

P75例3-15

4．Break和continue的使用：

是在循环体中使用的控制语句。

Break语句的功能是强制退出循环。

Continue是结束本次循环，返回循环的开始部分，进入下一次循环。

（注意二者的区别）例3-16

5．Goto语句

功能：

转移到指定标号。

格式：

goto标号；

标号定义格式：

标号：

语句（标号的第一个字母必须是字母或下划线）

例：

计算1到100的和：

#inclue

voidmain（）

{

inta=1,sum=0;

loop:

if（a<=100）

{sum=sum+a;

gotoloop;}

cout<

}

第四章

数组

数组类型是一种构造型（组合型）的数据类型。

数组是由一组具有相同数据类型的元素组成的集合。

数组的类型就是这组元素的数据类型。

构成数组的这组元素在内存中占用一组连续的存储单元。

可以用一个统一的数组名标识这一组数据，而用下标来指明数组中各元素的序号。

根据数组的维数，分为一维数组、二维数组和多维数组，常用的是一维和二维数组。

一、一维数组

1．一维数组的定义和初始化

格式：

类型数组名[常量表达式]；

其中，类型是数组类型，即数组中各元素的数据类型，可以是整型、浮点型、字符型等基本类型。

数组名是一个标识符，代表着数组元素在内存中的起始地址，它的命名规则与变量名的命名一样。

常量表达式又称下标表达式，表示一维数组中元素的个数，即数组长度（也称为数组大小），用一对方括号“[]”括起来。

方括号“[]”的个数代表数组的维数，一个方括号表示一维数组。

例如：

下面分别定义了一个具有5个元素的字符型数组a和一个具有10个元素的整型数组b：

chara[5];

intb[10];

对上面定义的数组b，也可以采用下面这种定义方法：

constintsize=10;

intb[size];

又如#definef100

inta[]={f,f+1,f+2,f+3};

注意：

在定义数组时，不能用变量来描述数组定义中的元素个数。

例如，下面的定义方式是不合法的：

intb[n];

下标指明了数组中每个元素的序号，下标值为整数，用数组名加下标值就可以访问数组中对应的某个元素。

下标值从0开始，因此对于一个具有n个元素的一维数组来说，它的下标值是0~n-1。

例如，对上例中定义的数组b来说，b[0]是数组中的第一个元素，b[1]是数组中的第二个元素，…，b[9]是数组中的最后一个元素，而不包含b[10]。

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

对于一维数组，就是简单地按下标顺序存储。

例如，对上面定义的整型数组b，在内存中的存放顺序如图所示：

一维数组的初始化：

在定义数组时对其中的全部或部分指定初始值，这称为数组的初始化。

只有存储类别为静态的或外部的数组才可以进行初始化。

初始化的语法格式为：

类型数组名[数组范围]={值1，值2，…，值n}

例如：

对定义的数组a进行初始化。

chara[5]={’a’,’b’,’c’,’d’,’e’};

或：

chara[]={’a’,’b’,’c’,’d’,’e’};

在对数组初始化时，也可以只对数组中的部分元素指定初始值。

也即，初始化值的个数可以少于或等于数组定义的元素的个数，但不可以多于数组元素的个数，否则会引起编译错误。

当初始化值的个数少于数组元素个数时，前面的元素按顺序初始化相应的值，后面不足的部分由系统自动初始化为零（对数值数组）或空字符‘\0’（对字符数组）。

例如：

intc[5]={1,2};

定义整型数组c有5个元素，但只初始化前两个元素：

c[0]=1，c[1]=2。

对于后面的三个元素没有定义初始值，此时由系统自动给它们赋0。

当数组长度与初始化元素的个数不相等时，数组长度不能省去不写，如上例不能写为：

intc[]={1，2}；

否则编译器会认为数组c只有2个元素而不是5个元素。

对于字符型数组的初始化，除了上面介绍的将数组中的元素一个一个赋值为字符的方式外，还可以有另外一种方式，即将整个字符型数组一次性赋值为一个字符串，此时花括号可以省略。

例如，下面三种初始化赋值方式是等价的：

chard[6]={’h’,’e’,’l’,’l’,’o’,’\0’};

chard[6]={”hello”};

chard[6]=”hello”;

后两种方法比较符合用户的习惯。

要注意的是：

单个字符用单括号括起来，而字符串用双括号括起来，组成字符串的字符除显示给出的外，还包括结尾处标识字符串结束的符号‘\0’。

所以上例中的字符串“hello”实际上包含6个字符：

‘h’，‘e’，‘l’，‘l’，‘o’，‘\0’。

如果将上例定义成如下形式就错了：

chard[5]=”hello”;

或

chard[5]={”hello”};

此时，最后一个字符‘\0’未能放入d数组中，而是存放到d数组之后的存储单元中。

这种错误编译器检查不出来，但由于改写了数组空间以外的内存单元，就可能会破坏其他数据区或程序本身。

在用户编写程序时，一定要注意避免这样的情况发生。

实P395-1

2．数组的赋值

（1）用“=”赋值

与数组元素的初始化不同，在给数组元素进行赋值时，必须逐一赋值。

例如：

对于下述的数组初始化：

inta[3]={1,2,3};

其等价的赋值形式如下：

inta[3];

a[0]=1;

a[1]=2;

a[2]=3;

若要在数组之间进行赋值，也只能一个一个元素地赋值。

例如：

将上述数组a的值赋给另一个同样大小的数组b，可以利用下面的循环完成赋值操作：

for（i=0;i<3;i++）b[i]=a[i];

（2）用流命令赋值

其语法格式为：

cin>>数组名；

或

cin>>数组名[下标]；

例如：

对一个大小为5的字符型数组a赋值，可以用下列两种方式：

chara[5];

cin>>a;

（3）strcpy（数组名1，数组名2）；包含在中

//将数组2中的字符串赋值到数组1中

例如：

strcyp（str1,str2）;

注意，上例不能写为：

str1=str2;//不合法

3.数组元素的引用

数组在定义后即可引用。

其引用形式为：

数组名[下标]

指明了引用数组名的数组中下标所标识的元素。

下标可以是整常数或整型表达式（如果不是整型将强制转换成整型）。

例如a[2+1]、a[i+j]等（i和j为整型变量）。

例如：

a[2]=10;//将10赋给数组中的a[2]元素。

a[5]=a[2];//将a[2]元素的值赋给a[5]元素

cout<

注意区分定义与引用形式上的相似与含义上的区分，定义时是指数组的大小空间；引用时是指引用下标标识的元素。

数组越界：

在给数组元素赋值或对数组元素进行引用时，一定要注意下标的值不要超过数组的范围，否则会产生数组越界问题。

因为当数组下标越界时，编译器并不认为它是一个错误，但这往往会带来非常严重的后果。

例如：

定义了一个整型数组a：

inta[10];

数组a的合法下标为0~9。

如果程序要求给a[10]赋值，将可能导致程序出错，甚至系统崩溃。

常用下面的式子确定数组的大小，预防数组越界情况的发生。

假定对于一个整型数组a，它的大小为：

sizeof（a）/sizeof（a[0]）

sizeof（a）表示求数组a在内存中所占字节数，使用上面这个式子，可以使数组大小计算在16位机器和32位机器之间移植。

例4-1、4-1

（2）、例4-2、4-3、4-4

二、二维数组

1．二维数组的定义：

二维数组也称为矩阵，需要两个下标才能标识某个元素的位置，通常称第一个下标为行下标，称第二个下标为列下标。

定义二维数组的语法格式为：

类型数组名[常量表达式1][常量表达式2]；

定义二维数组的格式与定义一维数组的格式相同，只是必须指定两个常量表达式，第一个常量表达式标识数组的行数，第二个常量表达式标识数组的列数。

例如：

inta[2][3]；

上面定义了一个a数组，它在逻辑上的空间形式为2行3列，每一个数组元素都是整型数据，因此a数组的各元素如下：

a[0][0]a[0][1]a[0][2]a[1][0]a[1][1]a[1][2]

//每一维的下标都是从0开始

二维数组中每个元素都是用下列方式标识：

数组名[行下标][列下标]

二维数组在内存中的排列顺序是“先行后列”，即在内存中先存第一行的元素，然后再存第二行的元素。

从数组下标变化来看，先变第二个下标，第一个下标先不变化（即i[0][0]，i[0][1]，i[0][2]），待第二个下标变到最大值时，才改变第一个下标，第二个下标又从0开始变化。

对于二维数组，可以把它看成是由多个一维数组构成的。

例如上例：

inta[2][3]；就可以看成是由两个形如inta[3]；的一维数组构成的。

由于二维数组在内存中是线性排列的，引用一维数组和引用二维数组都是引用相应存储地址的内容，因此可以计算出一个二维数组元素在对应一维数组中的顺序号，从而将对二维数组元素的引用转变为对一维数组元素的引用，这个过程称为“降维处理”（经常在向函数传递数组时用到）。

假设有一个mxn的二维数组a，其中第i行第j列元素a[i][j]在数组中的位置公式为：

i*n+j+1

例如有一个3*4的矩阵a：

 a[0][0]a[0][1]a[0][2]a[0][3]

a=a[1][0]a[1][1]a[1][2]a[1][3]

a[2][0]a[2][1]a[2][2]a[2][3]

a[2][1]元素在数组中的位置是2*4+1+1=10。

即它在数组中是第10个元素。

对一个a[i][j]元素，在它前面有i行（对a[2][1]来说它前面有两个整行），这i行共有i*n个元素。

在a[i][j]所在行中，a[i][j]前面还有j个元素，因此在数组a中a[i][j]前面共有（i*n+j）个元素。

那么a[i][j]就是第（i*n+j）+1个元素。

如果顺序号从0算起，那么a[i][j]在a数组中的顺序号计算公式为i*n+j。

a[2][1]的顺序号为2*4+1=9。

即按从0算起的话，它的顺序号为9，或者说它前面有9个元素。

2．二维数组初始化:

和一维数组一样，二维数组也能在定义时被初始化，只是要注意必须按照前面所讲的存储顺序列出数组元素的值。

常见有如下一些初始化方式：

（1）分别对各元素赋值，每一行的初始值用一对花括号括起来。

例如：

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

123

456

将第一对花括号内的三个初始值分别赋给a数组第一行三个元素，第二对花括号内的三个初始值赋给第二行元素。

数组中各元素为：

（2）将各初始值全部连续地写在一个花括号内，在程序编译时会按内存中排列的顺序将各初始值分别赋给数组元素。

例如

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

数组中各元素为：

123

456

（3）只对数组的部分元素赋值。

例如：

inta[2][3]={1,2,3,4};

数组共有6个元素，但只对前面4个元素赋初值，后面两个未赋初值，其值为0。

数组中各元素为：

123

400

（4）可以在分行赋初值时，只对该行中一部分元素赋初值，例如：

inta[2][3]={{1,2},{1}};

对第一行中的第一、二列元素赋初值，而第三个元素未赋初值。

第二行中只有第一列元素赋初值。

数组中各元素为：

120

100

（5）二维数组定义的其它形式：

若在定义数组时给出了全部数组元素的初值，则数组的第一维下标可以省略，但第二维下标不能省略。

例如：

下面两种定义方式等价：

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

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

编译器会根据元素的总个数分配空间，每行3列，共6个元素，故该数组行数为6/3=2行。

但上例不能写成：

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

在分行定义时，也可以只对部分元素赋初值而省略第一维的下标。

例如：

inta[][4]={{1,2},{},{3,4,5}}

该数组表示3行4列的整型数组，等价于下面的定义：

inta[3][4]={{1,2,0,0},{0,0,0,0},{3,4,5,0}}

P99练习例4-5，4-6

三、多维数组的定义

类型数组名[常量表达式1][常量表达式2]…[常量表达式n]；

由于大于三维的数组基本上不常用，所以在此以三维数组为例介绍多维数组。

例如：

定义一个整型三维数组：

inta[2][3][4];

数组有24个元素，它们在内存中排列顺序跟二维数组类似：

先变化第三个下标，然后变化第二个下标，最后变化第一个下标。

对于三维数组，可以把它看成是由多个二维数组构成的。

依此类推，一个n维数组可以看成是由多个n-1维数组构成的。

多维数组初始化

以三维数组初始化为例：

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

{{13,14,15,16},{17,18,19,20},{21,22,23,24}}};

由于第一维的大小为2，可以认为a数组有两个二维数组组成，每个二维数组为3行4列。

因此初始化时，按每个二维数组按行给初值的方法，分别用花括号把各行元素值括起来，并且将三行的初值再用花括号括起来。

例如：

{{1,2,3,4},{5,6,7,8},{9,10,11,12}}是第一个二维数组的初值；

同样，{{13,14,15,16},{17,18,19,20},{21,22,23,24}}是第二个二维数组的初值。

当然也可以不必用这么多的花括号，而把三维数组中全部元素连续写在一个花括号内，按元素在内存中排列顺序依次赋初值。

例如：

staticinta[2][3][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,

17,18,19,20,21,22,23,24};

5.3.3省略第一维大小

多维数组也可以省写第一维的大小，以上面定义的三维数组a为例，定义也可改写为：

inta[][3][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,

17,18,19,20,21,22,23,24};

系统会根据初值个数，算出第一维的大小为：

24/（3*4）=2。

在分行定义时，也可以只对部分元素赋初值而省略第一维的下标。

例如：

inta[][3][2]={{{1,2},{3},{5}},{{0,7},{8},{10}}};

显然这是一个三维数组，大小为2*3*2。

等价于下面的定义：

inta[2][3][2]={{{1,2},{3,0},{5,0}},{{0,7}