C++ 是一门混合型面向对象程序设计语言，它兼容了 C...

第第 22 章章 C++C++ 语言基础语言基础

1

概述概述

C++ 是一门混合型面向对象程序设计语言，它兼容了 C语言并弥补了其缺陷，增加了面身对象的能力。其中，改造后的 C 语言是面向对象部分的基础。

一般语法的改进指针和引用函数的改进类和对象构造函数和析构函数


2

2.1 C++2.1 C++ 程序的开发过程程序的开发过程

C++ 语言是一种高级程序设计语言，它的开发过程与其他高级语言程序开发过程类似，一般要经过四个步骤：

执行

编辑

编译

链接


3

编辑是指把按照 C++ 语法规则编写的程序代码通过

编辑器（ Borland C++, Visual C++, Turbo C++ 等）输入计算机，并存盘。在存盘时， C++ 源文件的扩展名为 .CPP 。编译

将编辑好的 C++ 源程序通过编译器转换为目标文件（ OBJ 文件）。即生成该源文件的目标代码。



4

链接将用户程序生成的多个目标代码文件（ .ob

j ）和系统提供的库文件（ .lib ）中的某些代码连接在一起，生成一个可执行文件（ .exe ）。执行

把生成的可执行文件运行，在屏幕上显示运行结果。用户可以根据运行结果来判断程序是否出错。



5



6

书写格式C++ 语言程序的书写格式自由度高，灵活性强，随意性大，

如一行内可写一条语句，也可写几条语句；一个语句也可分写在多行内。不过应采用适当的格式书写，便于人们阅读和理解。

为了增加程序的可读性和利于理解，编写程序时按如下要点书写：

（ 1 ）一般情况下每个语句占用一行。（ 2 ）不同结构层次的语句，从不同的起始位置开始，即

在同一结构层次中的语句，缩进同样的字数。（ 3 ）表示结构层次的大括号，写在该结构化语句第一个

字母的下方，与结构化语句对齐，并占用一行。（ 4 ）适当加些空格和空行。



7

C++ 语言程序由以下基本部分组成。1. 函数

一个 C++ 程序是由若干个函数构成的。函数分为库函数（标准函数）和自定义函数。库函数一般是由系统提供的。一个完整的 C++ 语言程序只有一个主函数。

2. 预处理命令预处理命令以位于行首的符号“ #” 开始， C++提供的预处理有文件包含命令、宏定义命令和条件编译命令三种。



8

#include 文件包含指令

#include 文件包含指令指示编译器将一个源文件嵌入到当前源文件中该指令处。 #include 包含指令有以下两种使用形式： #include < 文件名 > #include " 文件名 " 第一种形式，嵌入的源文件用尖括号括起来，告诉编译预处理程序在编译器自带的或外部库的头文件中搜索要嵌入的文件，它们一般是系统提供的公共头文件，存放在系统目录中的 Include 子目录下；第二种形式，嵌入的源文件用双引号括起来，这种形式的 #include 指令告诉编译预处理指令先在当前子目录搜索要嵌入的文件，如果没有找到文件，再去搜索编译器自带的或外部库的头文件。



9

为什么要使用 #include 指令？

函数调用出现在函数定义之前，或者调用在其它文件中（如系统库）定义的函数，必须先进行函数声明。系统函数按其功能被分成几大类，对应每类函数有一个头文件，其中给出了这一类函数的原型声明，所以，我们只需在程序中使用 #include 指令包含相应的头文件，而不必在程序中直接进行函数的声明。

以多文件方式组织的程序常常需要在各文件之间共享一些常量声明、变量声明、结构声明、函数声明和宏定义，可以将这些语句放在一个 C++ 头文件中（以 h 作扩展名），然后利用 #include 指令将该头文件包含到需要这些内容的源文件中。



10

#define宏定义指令

宏是一个表示特定内容的标识符，宏定义就是定义一个代表一个字符串或一段代码串的宏，被代表的内容称为宏体。在源程序中每遇到一个宏，编译程序均以定义的宏体替代之，这种替代过程称之为宏替换。

C++ 使用 #define 宏定义指令定义一个宏，其一般形式为：#define < 宏名 > < 宏体 >

宏名是一个用户自命名的、具有特定含义的标识符，宏体是由任意字符组成的字符序列。



11

例如，编程时可以首先将一个数组的最大长度定义成一个宏：

编译器对源程序进行编译时，每遇到一个宏 MAXLENGTH 时，都将其替换为 100 。对程序员而言，采用宏定义增加了程序的可读性，并有利于以后程序的修改。

#define MAXLENGTH 100. . . . . .

int nArray[MAXLENGTH];for(int i=0; i< MAXLENGTH; i++). . . . . .



12

带参数的宏定义：

利用 #define 指令还可定义带参数的宏。当编译器对这样的宏进行宏替换时，除了用宏体替代宏，还须用实际参数替代宏体中的参数。带参数的宏定义的一般形式为： #define < 宏名 >( 参数 1 ，参数 2 ，…，参数 n) <( 宏体 )>

例如：#define MAX(a , b) ( (a)>(b) ? (a):(b) ) main(){

cout<<MAX(10 , 11)<<endl;}



13

宏与内联函数的区别：

带参数的宏功能上与内联函数类似，但两者有本质的区别。宏替换是在正式编译之前，不进行参数的传递。函数调用是发生在程序实际执行时，要进行实参与形参的传递。使用宏的好处是它不需要调用及返回时的开销，但宏有一些不安全因素，可能带来副作用。对于不带参数的宏，使用 const 常量类型取代宏会更安全。

宏定义的取消： #undef < 宏名 >



14

3. 程序语句一条完整的语句必须以分号“；”结束。程序语句有如下几类：（ 1 ）说明语句

用来说明变量的类型和初值。如下面语句是把变量说明为浮点数。

float a, b, c;又如下面语句是把变量 sum说明为整型变量，并赋

初值为零。int sum = 0;



15

（ 2 ）表达式语句由一个表达式构成一个语句，用以描述算术运算、逻辑运算、或

产生某种特定动作，在任何表达式最后加一个分号就构成了一个语句。如上例由赋值表达式加“；”就构成一个赋值表达式语句。

（ 3 ）程序控制语句用来描述语句的执行条件与执行顺序的语句， C++ 语言的控制语

句有 9种，如下页所示。其语句中的括号（）表示其中是条件， ~表示内嵌的语句。



16

if （） ~ else 条件语句for （） ~ 循环语句while （） ~ 循环语句do ~ while （）循环语句continue 结束本次循环语句break 中止循环式 (switch语句 )switch 多分支选择语句goto 转移语句return 从函数返回语句



17

（ 4 ）复合语句复合语句是一种十分重要的语句，由大括号 {和 }把

一些说明语句和表达式组合在一起，使它们在语法上等价于一个简单语句；可由若干简单语句或复合语句组成。

例如： if ( a>b ) { c = a - b; d = c * a; } else { c = a + b; d = c * b; }



18

C＋＋的输入和输出

C

C++

2.2 2.2 一般语法的改进一般语法的改进


19

C 语言程序：/* 这是一个简单的 C 程序 : simple.c */#include <stdio.h>void main(void){

printf( " Hello World !\n " ) ; // 输出字符串} 用 C++ 语言编写同样功能的程序


20

C++ 语言程序：

// 这是一个简单的 C++ 程序： simple.cpp#include <iostream.h>void main(void){

cout<<" Hello World !\n "; // 输出字符串}

程序运行后在屏幕上输出：Hello World !


21

注释



22

变量初始化 C++支持两种形式的初始化第一种形式是使用赋值操作符的显式语法形式 int Bval = 1024;

string project = " BeiJing2008 ";

在隐式语法形式中初始值被放在圆括号中 int Bval( 1024 );

string project(" BeiJing2008 " );

在这两种情况中 ival 都被初始化为 1024 而 project 的初始值为 BeiJing2008



23

变量定义可以位于程序中的任何地方



24

符号常量的定义

C

C++



25

强制转换类型

•C 的强制类型转换法

（类型名）表达式

•函数表示法 (仅限简单类型 )

类型名（表达式）


int x;float y;y=(float)x;

int i=int(1.35);


26

结构体与枚举类型的用户标识名enum traffic {red,green,yellow};struct student{ int num; char name[20];};traffic Light;student stu1;

! 不必在一个结构体名之前加 struct ，不用在一个枚举类型名之前加关键字 enum 。



27

结构（ structure ）属于构造类型，它是由多种类型的数据成分组成的数据类型。例如，一个职员的信息由 ID号、姓名、性别、出生日期和工资等数据项组成，可采用结构类型来表示。

区别以前所介绍过的数据类型，结构的具体构成需要用户自己定义，即定义一个结构类型。

结构中的每个数据项称为成员，成员的类型可以是基本数据类型，也可以是一个诸如结构这样的构造类型。

结构类型的定义形式：

结构体


28

结构类型定义的一般形式为：

struct < 结构类型名 > { < 数据类型 > < 成员 1> ；

< 数据类型 > < 成员 2> ；. . . . . .< 数据类型 > < 成员 n> ；

}；例


29

下面定义职员结构类型：struct staffer {

int ID;char name[20];bool sex;float salary;

};

定义了结构（类型），就可以用结构声明结构变量，结构变量的声明形式如下：

< 结构类型名 > < 变量名 > ；

例如 . . .


30

例如，利用定义的职员结构 staffer 声明一个职员结构变量： staffer employee1;

注意：

不能在定义结构时对成员进行初始化，因为结构是一种数据类型，而不是一个变量。只有在声明一个结构变量时才可以对该结构变量的成员进行初始化。如下所示： staffer employee1= {110105, "LiMing", 1, 3809.80 };


31

结构变量是一种组合类型的变量，结构变量的引用包括整个变量的引用和其成员的引用。作为变量，整个结构变量可以进行赋值、作为函数参数和返回值。结构变量成员的使用与同类型的普通变量完全一样，但必须使用成员运算符“ .”说明是哪一个结构变量的成员。结构成员引用的形式为：

< 结构变量名 >.< 成员名 > 例如 . . .

结构变量的引用


32

employee1=employee2; // 引用整个结构变量employee1.ID=110108; // 引用结构成员strcpy(employee1.name, "WangPing"); // 结构成员

结构变量及其成员的引用：

指向结构变量的指针：结构变量的指针的声明、赋值和使用规则同普通指针一样。可以通过使用指向运算符“ ->” 引用结构成员。引用的形式如下：

< 结构变量指针 > -> < 成员名 > 例如 . . .


33

staffer* pStaff=&employee1; // 声明结构变量的指针pStaff ->ID=110115; // 引用结构成员strcpy(pStaff ->name, "WangPing"); // 引用结构成员

通过指向运算符“ ->” 引用结构成员：

#include <iostream.h>struct student{ // 定义结构

char name[20];int score[4];int average;

};

例利用结构编程，计算一个学生 4 门课的平均分数。


34

void main(void){

student stu; // 声明结构变量int i, sum=0;cout<<"Enter name:";cin>>stu.name; // 输入姓名cout<<"Enter four scores :";for(i=0; i<4; i++)

cin>>stu.score[i]; // 输入 4门课分数for(i=0; i<4; i++)

sum+=stu.score[i]; // 计算平均分数stu.average=sum/4;cout<<"The average score of "<<stu.name

<<" is:"<<stu.average<<'\n'; // 输出结果}


35

枚举类型（ enum）也是程序员定义的类型，它是一种允许用符号常量代表数据的数据类型。

在定义枚举类型时必须指定一组被命名的符号常量的集合，该集合决定了该枚举类型的变量可以具有的合法值。

枚举类型定义的一般形式为：enum <枚举类型名 > { < 常量 1> ， < 常量 2> ，

…， < 常量 n> }；枚举常量是 C++ 标识符，每一个枚举常量对应一个整数值，

第 1 个常量值为 0 ，第 2 个常量值为 1 ，依此类推。

使用举例：

枚举


36

使用举例：

以下定义了一个表示颜色的枚举类型： enum Color{Red, Green, Blue};

定义好的枚举类型可作为数据类型用于声明枚举型变量，例如：

[enum] Color MyColor ; 声明了枚举型变量，就可以将定义枚举类型时所列举的枚举常量集合中的任何一个常量赋值给枚举型变量。例如：

MyColor = Green; 在定义枚举类型时，可以为枚举常量指定其对应的整型值，

例如： enum Color{Red = -1, Green, Blue =3};


37

用 typedef语句定义类型是指对原有的数据类型定义一个新的名称，而不是真正定义一个新的数据类型。 typedef 语句的使用形式为：

typedef < 数据类型 > <新的类型名 > ；其中的数据类型可以是简单的数据类型，如 int 、 float 和 char等，也可以是诸如结构、枚举等组合数据类型。使用 typedef 的目的有两个：移植程序，增加程序的可读性。

使用举例：

用 typedef 定义类型


38

typedef int INTEGER;typedef unsigned char BYTE;typedef struct tagDate {

int year;int month;int day;

} DATE; 新定义数据类型如 INTEGER( 一般用大小字母 ) 与 int完全一样，可以用它进行变量的声明。如：

INTEGER i ;

例如：


39

基本数据类型是 C++ 预定义的数据类型， C++ 的基本数据类型包括字符型、整数型、实型（单精度和双精度）和无值型。

每种基本数据类型都使用一个关键字来表示，如 char 、 int 、 float 、 double 和 void等，见下表。

数组、指针和类等派生数据类型是程序员按照 C++ 的语法要求在基本数据类型基础之上建立起来的。

除 void 数据类型以外，其它基本数据类型加类型修饰符 signed 、 unsigned 、 short 和 long。

2.3 2.3 数据类型和表达式数据类型和表达式


40

C++ 基本数据类型

数据类型说明长度 ( 位 )

char 字符型 8

int 整型 32

float 单精度实型 32

double 双精度实型 64

void 无值型 0

unsigned [int] 无符号整型 16

short [int] 短整型 16

long [int] 长整型 32


41

例： int num, total; float v, r, h; int a=3; // 等价于： int a(3); char c=‘A’; long lx=12345678; unsigned int nWidth;

可以使用运算符“ ( )” 进行强制类型转换： float x=123.56;

int i=(int)x; // i=123


42

C++ has a set of fundamental types corresponding

to the most common basic storage units of a computer

and the most common ways of using them to hold data:

A Boolean type (bool )

Character types (such as char )

Integer types (such as int )

Floating point types (such as float )

Bjarne Stroustrup AT&T Labs



43

In addition, a user can define

Enumeration types for representing specific sets of

values (enum )

There also is a type, void , used to signify the absence

of information




44

From these types, we can construct other types:

Pointer types (such as int *)

Array types (such as char [])

Reference types (such as double &)

Data structures and classes


For most applications, one could simply use For most applications, one could simply use boolbool for logical values, for logical values, charchar for characters, for characters, intint for integer values, and for integer values, and doubledouble for floating point values. Tfor floating point values. The remaining fundamental types are variations for optimizations and special he remaining fundamental types are variations for optimizations and special needs that are best ignored until such needs arise.needs that are best ignored until such needs arise.



45

Specifiers modify the meanings of the basic built-in types a

nd expand them to a much larger set. There are four specifiers:

long, short, signed, and unsigned.

long and short modify the maximum and minimum values

that a data type will hold. A plain int must be at least the size of

a short. The size hierarchy for integral types is: short int, int, lo

ng int.

The size hierarchy for floating point numbers is: float, dou

ble, and long double. “Long float” is not a legal type. There are

no short floating-point

SpecifiersSpecifiers

Thinking in C++



46

The signed and unsigned specifiers tell the compiler how to

use the sign bit with integral types and characters (floating-poin

t numbers always contain a sign). An unsigned number does not

keep track of the sign and thus has an extra bit available, so it c

an store positive numbers twice as large as the positive number

s that can be stored in a signed number. signed is the default an

d is only necessary with char; char may or may not default to si

gned. By specifying signed char, you force the sign bit to be use

d.

SpecifiersSpecifiers

Thinking in C++



47

数组属于构造类型，它是一组具有相同类型数据的有序集合，其中每个数据称为数组的元素。数组按其下标的个数分为一维数组、二维数组和多维数组。一维数组的声明方式如下：< 数据类型 > < 数组名 >[ 常量表达式 ] ；二维数组的声明方式如下：< 数据类型 > < 数组名 >[ 常量表达式 ] [ 常量表达式 ] ；数组名后括号中的常量表达式表示数组的长度，即数组所包含元素的数量。例如 . . .

数组数组


48

数组的使用：数组声明后，可以引用数组每个元素，但不能一次引用整个数组。数组元素作为一个简单的变量对待。数组元素的引用方式如下：

< 数组名 >[ 下标表达式 ]< 数组名 >[ 下标表达式 ] [ 下标表达式 ]

数组声明语句： float score[30];

// 数组 score 有 30 个元素，其数据类型是 float 型 int Array[12][4];

// 数组 Array 有 12×4 个元素，其数据类型是 int 型


49

注意：数组元素的下标从 0开始，直到数组长度减 1 ，如： sc

ore[0] ， score[1] ，…， score[29] 。在编译 C++ 源程序时，为了保证程序编译和运行的效率，

C++ 编译系统不对数组下标进行越界检查，程序运行时系统也不会提出越界警告。因此在对数组元素进行操作时应格外注意，以免破坏其它存储单元的数据，否则可能造成不可预料的后果。


50

数组的初始化声明数组时可以用一个用花括号括起的常量列表对数组进行初始化，

例如： float grade[3]={90.0, 75.0, 85.0}; 二维数组和多维数组的初始化可以按照数组的排列顺序或分行赋初始值的方法。例如：

int a[2][3]={2, 4, 6, 8, 10, 12}; // 按数组的排列顺序 int a[2][3]={{2, 4, 6},{8, 10, 12}};// 分行赋初始值

其中， 2 、 4 、 6 分别为 a[0] 的元素 a[0][0] 、 a[0][1] 和 a[0][2]的初始值。


51

数组的初始化初始值的个数可以比数组元素的个数少，这时未提供初始值的元素被置为 0 。例如：

int a[2][3]={2, 4, 6}; 当提供全部的初始值时，数组第一维的长度可以省略。

例如： float grade[ ] = {90.0, 75.0, 85.0};

int a[ ][3] = {{2, 4, 6},{8, 10, 12}};

数组使用举例


52

例输入 10 个学生某门课的成绩，然后按与输入次序相反的顺序输出成绩。


53

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

int i;float score[10];cout<<"Please enter 10 scores: ";for(i=0; i<10; i++)

cin>>score[i]; // 输入数据 cout<<"The scores in reverse order are: ";for(i=9; i>=0; i--)

cout<<score[i]<<' '; // 逆向输出结果cout<<'\n';

}


54

任何变量都有一个内存地址，这种地址称为指针，而指针变量是一种存放内存地址的变量。每一个指针变量都有相应的数据类型，该类型用以说明指针所指内存单元中存放的数据的类型。指针变量声明的一般形式为：

< 数据类型 > * < 指针名 > ；符号“ *”是指针类型说明符，声明变量是一个指针型变量。例如： int* pointer ; int *pointer ; // 两条语句功能相同

指针指针 (Pointer)(Pointer)



55

有两个与指针有关的运算符：取地址运算符“＆”和指针运算符“ *”；

运算符“＆”用于取一个变量的地址；运算符“ *”以一个指针作为其操作数，其运算结果表示所指向的变量；

“＆”运算和“ *”运算互为逆运算。

指针使用举例

与指针有关的运算符


56


int a, b, *pa, *pb;a=10; b=20;pa=&a; pb=&b;cout<<*pa<<','<<*pb<<'\n';pa=&b; pb=&a; cou

t<<*pa<<','<<*pb<<'\n';*pa=100; *pb=200; cou

t<<a<<','<<b<<'\n'; }

例指针的使用

// 使 pa 指向 a ， pb指向b

// 使 pa 指向 b ， pb指向 a// 分别对 b和 a赋值

运行结果


57

程序运行结果： 10， 2020， 10200， 100

如果先声明了变量，就可以在声明指针变量时对指针进行初始化。如下所示： int a, b;

int *pa=&a, *pb=&b;


58

指针与数组

指针与数组关系密切，编程时可以用指针代替下标引用数组元素，指针使数组的使用更为灵活、有效；

当声明一个数组后，编译程序会按照数组的类型和长度为它分配内存空间，数组名表示数组在内存中的首地址；

当用一个指针变量存储数组首地址时，该指针就指向这个数组，就可以通过指针运算间接访问数组的元素。

例


59

例利用指针引用数组的方法求一个数组中所有元素之和。int a[ ]={2, 4, 6, 8, 10};


60


int a[ ]={2, 4, 6, 8, 10};int* pa=a; // 或 pa=&a[0]int result=0;for(int i=0; i<5; i++){

result+=*pa; // 通过指针访问数组元素

pa++; // 指针运算}cout<<"result="<<result<<'\n';

}


61

指针也是一种变量，指针变量专门用来存放其它数据在内存的地址。是一种间接访问变量或对象的方法。

引用是某个变量或对象的别名，是另一种访问变量或对象的方法。

< 类型 >* < 变量>;

< 类型 >& < 引用名 >=< 变量名或对象名 >;

指针和引用指针和引用 (Pointer&Reference)(Pointer&Reference)



62

引用类型的概念引用类型的概念 (Reference)(Reference)

引用是指给对象的地址取个别名，对引用的改动则是对目标的改动。

int int1;

int &rint=int1;引用不是值，不占有存储空间



63

引用描述一种特殊的数据类型，用于声明两个以上的变量名，指向同一地址 . 引用运算符 &，声明引用的形式为 :数据类型 & 引用变量名 =变量名 ;如 :int b; int &a=b; 则 a 为 b 的一个引用， b 为被引用对象， a、 b指向同一地址空间， a相当于 b 的一个别名，绰号。对 a 的操作，就会 b 引起操作，反之亦然。


64


int ival = 1024;int &refVal = ival;refVal += 2;

All operations on the reference are actually applied to the object to which the reference refers, including the address-of operator. For example:

C++ Primer

adds 2 to ival, the object referred to by refVal.



65



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

int num=50;int& ref=num;ref+=10;cout<<"num="<<num<<endl;cout<<"ref="<<ref<<endl;num+=40;cout<<"num="<<num<<endl;cout<<"ref="<<ref<<endl;

}


66

说明 1 ）声明多个引用型变量，每个变量名前都冠以 &。 2 ）引用不是变量，本身不能被修改，对引用的存取都是对它所引用的变量存取。 3 ）声明引用时必须要进行初始化，除非引用做参数或返回值。 4 ）不能声明引用的引用，也不能声明数组元素类型为引用数组，或指向引用的指针。


67



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

int num;int& ref=num;num=5;cout<<"num="<<num<<endl;cout<<"ref="<<ref<<endl;cout<<"&num="<<&num<<endl;cout<<"&ref="<<&ref<<endl;

}


68


int ival = 1024;// ok: refVal is a reference to ivalint &refVal = ival;// error: a reference must be //initialized to an objectint &refVal2;



69


int &a[5];int &*p; //错误

int *a;int *&p=a;int b;p=&b;



70

5) 指针与引用区别指针的值是某一变量的内存单元地址，引用则与初始化它的变量具有相同的内存单元地址。指针是个变量，可以重新赋值，引用必须要初始化并且只能跟被引用对象相同的地址，不能指向其他地址。


71

2.10 引用

6) 引用运算符和地址运算符的区别 int num=50; int &ref=num; int *p=&ref;7) 可以用另外一个引用初始化另外一个引用 int num=50; int &ref1=num; int &ref2=ref1; ref2=100;


72

2.10 引用

8)可以把函数的参数声明成引用，以建立函数参数的引用传递方式。

void swap(int & rx,int & ry){

int temp=rx;rx=ry;ry=temp;

}


73



#include<iostream>using namespace std;void swap(int & x,int & y);void main(){

int x=5,y=6;cout<<"before swap,x:"<<x<<",y:"<<y<<endl;swap(x,y);cout<<"after swap,x:"<<x<<",y:"<<y;

}


74

2.10 引用

9) 有空指针 ,无空引用 int *p=null; int num=10; int &ref=null; // 错误 int &ref=num;


75

2.10 引用

10) 函数调用引用可以作为左值若一个函数返回了引用，那么该函数的调用也可以被赋值。函数作为左值，一般用在对函数的返回值重新赋值的时候。

见 : P27 例 2.8、例 2.9


76

运算符：运算是对数据进行加工的过程，表示各种不同运算的符

号称为运算符，而参与运算的数据称为操作数。运算符实质上是系统预定义的函数名，而进行运算就是

调用一个函数。按运算符和操作数的运算性质，运算符可分为算术运算

符、逻辑运算符、关系运算符和其它运算符，见下表。常用： + 、 - 、 * 、 / 、 % 、 ++ 、 () 、 = 、 +

= 、 -> 、 &&、 < 、 <= 、 new 、 delete



77

优先级运算符功能说明结合性1 . ， ->

::

成员运算符作用域限定符

右结合

22

*

&

new ， delete

!

++ ， --

( )

sizeof

指针运算，取内容求变量的地址动态内存分配和释放逻辑非自增和自减运算强制类型转换求所占内存字节数

左结合

3 * ， / ， % 乘、除和求余右结合4 + ， - 加和减右结合



78

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

5 < ， <= ， > ， >

=

小于、小于等于、… 右结合6 == ， != 等于和不等于右结合7 && 逻辑与右结合8 | | 逻辑或右结合9 ? : 条件运算，三目运算左结合

10 = ， += ， -= ， *

= ， /=

赋值运算和复合赋值运算

左结合


11 , 顺序求值运算左结合


79

例如： x+y ， area=PI*radius*radius ， (a>b) && (x<=y)

表达式：一个表达式由常量、变量、函数调用和运算符组成，每

个表达式都将产生一个值，并且具有某种类型（称为该表达式的类型）。

表达式隐含的数据类型取决于组成表达式的操作数的类型。

当表达式中的操作数都是常量时，称这个表达式是常量表达式。

在对一个表达式求值时，优先级高的运算符先运算，优先级低的运算符后运算。

运算符的结合性：右结合性和左结合性


80


char x,y;int n;x='a';y='b';n=x<y;cout<<n<<endl;n=y==x+1;cout<<n<<endl;n=(x<y)&&(y==x+1)+5;cout<<n<<endl;

}

例 1 ：


81


int x,y;x=3;y=6;x+=3;y*=x;cout<<"x="<<x<<" y="<<y<<endl;

}

例 2 ：


82

#include <iostream.h>

void main()

{int a=0,m=3,n=9,k=15,b=5,c=9;a-=!b||++m>n||c++;cout<<"\ta="<<a<<"\tb="<<b<<"\tc="<<c<<endl;cout<<"\tm="<<m<<"\tn="<<n<<"\

tk="<<k<<endl;}

例 3 ：


83


int x,y,n;x=y=1;n=--x&&++y;cout<<" n="<<n<<" x="<<x<<" y="<<y<<endl;n=(--x)||(++y);cout<<" n="<<n<<endl;cout<<" x="<<x<<" y="<<y<<endl;

}

例 4 ：


84

#include <iostream.h>

void main()

{

int a=1,b=3,c=2,x;

x=(a++,b+=a,c=b+2);

cout<<"x="<<x<<endl;

}

例 5 ：


85

const 修饰符

C 语言中常量定义 #define PI 3.1415926C++里 ,用 const 修饰符定义常量 const float PI =3.1415926; 该常量有类型，有地址，可以用指针指向这个值，但不能修改。


86

注意 1 ）使用 const 修饰符定义常量时，必须初始化 2 ）常量被定义后，程序其他地方不能再修改 3 ）定义整型常量， int 可省略。 4 ） C++ 编译程序会对常量进行类型检查。 5 ）函数参数也可声明为常量，保证实参在函数内部不被改动


87

常量与指针结合使用 1 指向常量的指针。例如： const char * pc=“abcd”; 2 常指针。 char *const pc=“abcd”; 不能改变 pc 的值。 pc[3]=‘x’; pc=“dfasdfa”


88

指向常量的常指针 const char * const pc=“abcd”;

pc 指向的地址和该地址空间的值都不能变动


89

string

C++ 提供 string 类型存放字符串。


90

作用域运算符 (::)

作用运算符指定作用域


91

#include <iostream>

using namespace std;

float a=2.4; //全局变量

void main()

{

int a=8; //局部变量

cout<<a<<endl;

}

例：


92

#include <iostream>

using namespace std;

float a=2.4; //全局变量

void main()

{

int a=8; //局部变量

cout<<a<<endl;

cout<<::a<<endl;

}

例：


93

名字空间

C++里引入 namespace 的目的就是为了避免污染全局名字空间，简单地说，就是为了避免和减少命名冲突。一旦一个程序写大了，就很难避免重名，特别是多人合作的情况下。解决相同的函数名，或变量名，或者两个不同的库里面有相同的函数名，相当于一个文件域．


94

名字空间定义

namespace ns1{ float a, b, c; fun1(){….}}使用域内成员，需要使用域操作符号“ ::”　　 ns1::a ; ns1::fun1();


95

名字空间分层嵌套定义

namespace ns1{ namespace ns2 { class matrix{…} }} 访问matrix，可写成 n1::n2::matrix。

全局名字空间


96

名字空间使用

使用关键字 using　 using ns1::ns2::martix 以后在再次使用martix, 可以直接使用使用 using namespace 名字空间名　空间所有成员都可以被直接使用using namespace std c++ 所有组件都在 std 中，通过该语句则可以使用标准Ｃ ++ 库所有成员，注意此时若使用 include 包含头文件，要去掉头文件扩展名。


97

动态内存分配 (Dynamic memory allocation)静态与动态内存分配的两个主要区别是静态对象是有名字的变量，直接对其进行操作。而动态对象是没有名字的变量，通过指针间接地对它进行操作。静态对象的分配与释放由编译器自动处理，程序员需要理解这一点，但不需要做任何事情。相反，动态对象的分配与释放必须由程序员显式地管理，相对来说比较容易出错它通过 new 和 delete 两个运算符来完成。

2.4 2.4 动态内存分配动态内存分配


98

动态内存分配 (Dynamic memory allocation)malloc(), calloc()malloc(), calloc() 和和 free(). free(). C

C++

2.4 2.4 动态内存分配动态内存分配


99

new 运算符动态分配堆内存

使用形式：指针变量 = new 类型（常量）；指针变量 = new 类型 [ 表达式 ] ；作用：从堆分配一块“类型”大小的存储空间，返回首地址

其中：“常量”是初始化值，可缺省创建数组对象时，不能为对象指定初始值

delete 运算符释放已分配的内存空间

使用形式： delete 指针变量；delete [ ] 指针变量；

其中：“指针变量”必须是一个 new 返回的指针

2.4.1 new 和 delete操作符


100

int * p1 = new int ;

char * p2 = new char ;

float * p3 = new float ;

int * p4 = new int [4] ;

……

delete p1 ;

delete p2 ;

delete p3 ;

delete [] p4 ;



101





……

delete p1 ;

delete p2 ;

delete p3 ;

delete [] p4 ;

p1



102





……

delete p1 ;

delete p2 ;

delete p3 ;

delete [] p4 ;

p1

p2



103





……

delete p1 ;

delete p2 ;

delete p3 ;

delete [] p4 ;

p1

p2

p3

4.5.1 new 和 delete 操作符



104





……

delete p1 ;

delete p2 ;

delete p3 ;

delete [] p4 ;

p1

p2

p3

p4




105





……

delete p1 ;

delete p2 ;

delete p3 ;

delete [] p4 ;

p2

p3

p4

p1




106





……

delete p1 ;

delete p2 ;

delete p3 ;

delete [] p4 ;

p2

p3

p4

p1




107





……

delete p1 ;

delete p2 ;

delete p3 ;

delete [] p4 ;

p2

p3

p4

p1




108





……

delete p1 ;

delete p2 ;

delete p3 ;

delete [] p4 ;

p3

p4

p2

p1



109





……

delete p1 ;

delete p2 ;

delete p3 ;

delete [] p4 ;

p3

p4

p2

p1



110





……

delete p1 ;

delete p2 ;

delete p3 ;

delete [] p4 ;

p4

p2

p1

p3



111





……

delete p1 ;

delete p2 ;

delete p3 ;

delete [] p4 ;

p4

p2

p1

p3



112





……

delete p1 ;

delete p2 ;

delete p3 ;

delete [] p4 ;

p2

p1

p3

p4



113





……

delete p1 ;

delete p2 ;

delete p3 ;

delete [] p4 ;

p2

p1

p3

p4



114

#include<iostream.h>

void main()

{ int * p = NULL ;

p = new int ( 89 ) ; //初始化存储区 if ( p == NULL )

{ cout << "allocation failure\n"; return ; }

cout << *p ;

delete p ;

}

例用 new 算符建立简单对象



115


void main()

{ int * p = NULL ;



cout << *p ;

delete p ;

}

p




116


void main()

{ int * p = NULL ;



cout << *p ;

delete p ;

}

p89




117


void main()

{ int * p = NULL ;



cout << *p ;

delete p ;

}

p89



118


void main()

{ int * p = NULL ;



cout << *p ;

delete p ;

}89

对象无名对象无名只能通过指针访问只能通过指针访问

例用 new 算符建立简单对象 p

8989



119


void main()

{ int * p = NULL ;



cout << *p ;

delete p ;

}

p89

89




120


void main()

{ int * p = NULL ;



cout << *p ;

delete p ;

}

89

89

例用 new 算符建立简单对象 p



121


void main()

{ int * p = NULL , * t ; int i ;

p = new int [10] ;

if ( p == NULL )

{ cout << "allocation failure\n" ; return ; }

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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}

例用 new 算符建立动态数组



122


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}

例用 new 算符建立动态数组 p

t

i2.4.1 new 和 delete操作符


123


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


t



124


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


t



125


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


t

i

100100

101101

102102

103103

104104

105105

106106

107107

108108

109109



126


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


t

10i

100100

101101

102102

103103

104104

105105

106106

107107

108108

109109

|



127


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


t100100

101101

102102

103103

104104

105105

106106

107107

108108

109109

|

10i


128


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


t100100

101101

102102

103103

104104

105105

106106

107107

108108

109109

|

10i2.4.1 new 和 delete操作符


129


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


t100100

101101

102102

103103

104104

105105

106106

107107

108108

109109

100 |



130


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


t100100

101101

102102

103103

104104

105105

106106

107107

108108

109109

100 |



131


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


t100100

101101

102102

103103

104104

105105

106106

107107

108108

109109

100 |



132


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


t100100

101101

102102

103103

104104

105105

106106

107107

108108

109109

100 101 |

10i


133


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}

例用 new 算符建立动态数组 p100100

101101

102102

103103

104104

105105

106106

107107

108108

109109

100 101 |

t



134


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101101

102102

103103

104104

105105

106106

107107

108108

109109

100 101 |

t



135


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101101

102102

103103

104104

105105

106106

107107

108108

109109

100 101 |

t



136


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101101

102102

103103

104104

105105

106106

107107

108108

109109

100 101 102 |

t



137


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101101

102102

103103

104104

105105

106106

107107

108108

109109

100 101 102 |

t



138


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101101

102102

103103

104104

105105

106106

107107

108108

109109

100 101 102 |

t



139


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101101

102102

103103

104104

105105

106106

107107

108108

109109

100 101 102 |

t



140


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101101

102102

103103

104104

105105

106106

107107

108108

109109

100 101 102 103 |

t

10i


141


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101101

102102

103103

104104

105105

106106

107107

108108

109109

100 101 102 103 104 105 106 107 108 109 |

t



142


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101101

102102

103103

104104

105105

106106

107107

108108

109109

100 101 102 103 104 105 106 107 108 109 |

t



143


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101101

102102

103103

104104

105105

106106

107107

108108

109109

100 101 102 103 104 105 106 107 108 109

|

t



144


void main()


p = new int [10] ;

if ( p == NULL )

{ cout << "allocation faiulre\n" ; return ; }

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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101101

102102

103103

104104

105105

106106

107107

108108

109109

100 101 102 103 104 105 106 107 108 109

|

t



145


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101

102

103

104

105

106

107

108

109

100 101 102 103 104 105 106 107 108 109

|

t



146


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101

102

103

104

105

106

107

108

109t



147


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101

102

103

104

105

106

107

108

109t

10i

以下标方式以下标方式访问动态数组访问动态数组



148


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101

102

103

104

105

106

107

108

109t

10i

i i 是偏移量是偏移量pp 指针本身值不变指针本身值不变



149


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101

102

103

104

105

106

107

108

109t

10i

跟踪指针赋初值跟踪指针赋初值



150


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101

102

103

104

105

106

107

108

109t

10i

跟踪指针移动跟踪指针移动



151


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


101

102

103

104

105

106

107

108

109t

10i

间址访问元素间址访问元素



152


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;

}


p

100

101

102

103

104

105

106

107

108

109

10i

for ( i = 0 ; i < 10 ; i++ ) { cout << *p*p << " " ; p++;p++;}

注意结束循环后



153


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;delete [] p ;

}


p

100

101

102

103

104

105

106

107

108

109

10i

for ( i = 0 ; i < 10 ; p ++p ++ )

cout << *p*p << " " ;

注意注意结束循环后结束循环后

for ( i = 0 ; i < 10 ; i++ ) { cout << *p*p << " " ; p++;p++;}

释放什么空间？释放什么空间？



154


void main()


p = new int [10] ;

if ( p == NULL )


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

p[i] = 100 + i ;

cout << endl ;

for ( t = p ; t < p+10 ; t ++ )

cout << *t << " " ;

cout << endl ;

delete [] p ;delete [] p ;

}


p

100

101

102

103

104

105

106

107

108

109

10i

内存泄漏内存泄漏



for ( i = 0 ; i < 10 ; i++ ) { cout << *p*p << " " ; p++;p++;}


155

例输出二项式系数表

( a + b ) 0 = 1

( a + b ) 1 = 1a + 1b

( a + b ) 2 = 1a2 + 2ab + 1b2

( a + b ) 3 = 1a3 + 3a2b + 3ab2 + 1b3

( a + b ) 4 = 1a4 + 4a3b + 6a2b2 + 4ab3 + 1b4

11 11 2 11 3 3 11 4 6 4 11 5 10 10 5 1

杨辉三角形

2.4.2 new 和 delete操作符实例


156

例输出二项式系数表 11 11 2 11 3 3 11 4 6 4 11 5 10 10 5 1

杨辉三角形

n 次系数表有 n +1 项

n 次系数表由 n -1 次系数表迭代生成：

F0 = 1

Fn+1 = 1

Fi = Fi-1 + Fi

算法分析

2.4.2 new 和 delete操作符实例


157

上机题目

1 、利用动态内存分配完成杨辉三角形的输出。2 、求数列前 20项：

22

22

11

00

321 nyyy

n

n

n

y

nnn

n


158

3 、求 100 之内的自然数中所有奇数的和。4 、求出所有的水仙花数。三位数，其中各位数的立方和恰好等于该数本身，如 153＝ 13＋ 53＋ 33 。5 、求出 1～ 1000 间的素数，要求每行输出 6 个数。6 、求 1！＋ 2！＋……＋ n！。

C++ 是一门混合型面向对象程序设计语言，它兼容了 C...

Documents

Transcript of C++ 是一门混合型面向对象程序设计语言，它兼容了 C...