C++
Download
1 / 158

C++ ????????????????????? C ???????????????????????????? C ????????????? - PowerPoint PPT Presentation


  • 124 Views
  • Uploaded on

C++ 是一门混合型面向对象程序设计语言,它兼容了 C 语言并弥补了其缺陷,增加了面身对象的能力。其中,改造后的 C 语言是面向对象部分的基础。. 概述. 一般语法的改进 指针和引用 函数的改进 类和对象 构造函数和析构函数. C++ 语言是一种高级程序设计语言,它的开发过程与其他高级语言程序开发过程类似,一般要经过四个步骤:. 2.1 C++ 程序的开发过程. 编辑. 编译. 链接. 执行. 编辑

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'C++ ????????????????????? C ???????????????????????????? C ?????????????' - ann


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
C c c

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

概述

  • 一般语法的改进

  • 指针和引用

  • 函数的改进

  • 类和对象

  • 构造函数和析构函数


2 1 c

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

2.1 C++程序的开发过程

编辑

编译

链接

执行


2 1 c1

编辑

是指把按照C++语法规则编写的程序代码通过编辑器(Borland C++, Visual C++, Turbo C++ 等)输入计算机,并存盘。在存盘时,C++源文件的扩展名为.CPP。

编译

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

2.1 C++程序的开发过程


2 1 c2

链接

将用户程序生成的多个目标代码文件(.obj)和系统提供的库文件(.lib)中的某些代码连接在一起,生成一个可执行文件(.exe)。

执行

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

2.1 C++程序的开发过程


2 1 c3
2.1 C++程序的开发过程


2 1 c4

书写格式

C++语言程序的书写格式自由度高,灵活性强,随意性大,如一行内可写一条语句,也可写几条语句;一个语句也可分写在多行内。不过应采用适当的格式书写,便于人们阅读和理解。

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

(1)一般情况下每个语句占用一行。

(2)不同结构层次的语句,从不同的起始位置开始,即在同一结构层次中的语句,缩进同样的字数。

(3)表示结构层次的大括号,写在该结构化语句第一个字母的下方,与结构化语句对齐,并占用一行。

(4)适当加些空格和空行。

2.1 C++程序的开发过程


2 1 c5

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

1. 函数

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

2. 预处理命令

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

2.1 C++程序的开发过程


Include

#include文件包含指令指示编译器将一个源文件嵌入到当前源文件中该指令处。#include包含指令有以下两种使用形式:

#include <文件名>

#include "文件名"

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

2.1 C++程序的开发过程

#include文件包含指令


Include1

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

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

2.1 C++程序的开发过程

为什么要使用 #include指令?


Define

2.1 C++程序的开发过程

#define宏定义指令

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

  • C++使用#define宏定义指令定义一个宏,其一般形式为:

    #define <宏名> <宏体>

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


C c c

2.1 C++程序的开发过程

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

#define MAXLENGTH 100

. . . . . .

int nArray[MAXLENGTH];

for(int i=0; i< MAXLENGTH; i++)

. . . . . .

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


C c c

2.1 C++程序的开发过程

带参数的宏定义:

利用#define指令还可定义带参数的宏。当编译器对这样的宏进行宏替换时,除了用宏体替代宏,还须用实际参数替代宏体中的参数。带参数的宏定义的一般形式为:

#define <宏名>(参数1,参数2,…,参数n) <(宏体)>

例如:

#define MAX(a , b) ( (a)>(b) ? (a):(b) )

main()

{

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

}


C c c

2.1 C++程序的开发过程

宏与内联函数的区别:

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

宏定义的取消:

#undef <宏名>


2 1 c6

3. 程序语句

一条完整的语句必须以分号“;”结束。程序语句有如下几类:

(1)说明语句

用来说明变量的类型和初值。

如下面语句是把变量说明为浮点数。

float a, b, c;

又如下面语句是把变量sum说明为整型变量,并赋初值为零。

int sum = 0;

2.1 C++程序的开发过程


2 1 c7

2)表达式语句

由一个表达式构成一个语句,用以描述算术运算、逻辑运算、或产生某种特定动作,在任何表达式最后加一个分号就构成了一个语句。如上例由赋值表达式加“;”就构成一个赋值表达式语句。

(3)程序控制语句

用来描述语句的执行条件与执行顺序的语句,C++语言的控制语句有9种,如下页所示。其语句中的括号( )表示其中是条件,~表示内嵌的语句。

2.1 C++程序的开发过程


2 1 c8

if() ~ else条件语句

for() ~ 循环语句

while() ~ 循环语句

do ~ while() 循环语句

continue结束本次循环语句

break中止循环式(switch语句)

switch多分支选择语句

goto转移语句

return从函数返回语句

2.1 C++程序的开发过程


2 1 c9

4)复合语句

复合语句是一种十分重要的语句,由大括号{和}把一些说明语句和表达式组合在一起,使它们在语法上等价于一个简单语句;可由若干简单语句或复合语句组成。

例如:if ( a>b )

{ c = a - b;

d = c * a;

}

else

{ c = a + b;

d = c * b;

}

2.1 C++程序的开发过程


C c c

C++的输入和输出

2.2 一般语法的改进

C

C++


C c c

C语言程序:

/*这是一个简单的C程序: simple.c */

#include <stdio.h>

void main(void)

{

printf( " Hello World !\n " ) ; // 输出字符串

}

用C++语言编写同样功能的程序


C c c

C++语言程序:

// 这是一个简单的C++程序:simple.cpp

#include <iostream.h>

void main(void)

{

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

}

程序运行后在屏幕上输出:

Hello World !


C c c

注释

2.2 一般语法的改进


C c c

变量初始化

2.2 一般语法的改进

C++支持两种形式的初始化第一种形式是使用赋值操作符的显式语法形式

int Bval = 1024;

string project = " BeiJing2008";

在隐式语法形式中初始值被放在圆括号中

int Bval( 1024 );

string project("BeiJing2008 " );

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



C c c

符号常量的定义

2.2 一般语法的改进

C

C++


C c c

强制转换类型

2.2 一般语法的改进

int x;

float y;

y=(float)x;

  • C的强制类型转换法

  • (类型名)表达式

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

  • 类型名(表达式)

int i=int(1.35);


C c c

结构体与枚举类型的用户标识名

2.2 一般语法的改进

enum traffic {red,green,yellow};

struct student{

int num;

char name[20];};

traffic Light;

student stu1;

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


C c c
结构体

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

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

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

    结构类型的定义形式:


C c c

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

struct <结构类型名> {

<数据类型> <成员1>;

<数据类型> <成员2>;

. . . . . .

<数据类型> <成员n>;

};


C c c

下面定义职员结构类型:

struct staffer {

int ID;

char name[20];

bool sex;

float salary;

};

定义了结构(类型),就可以用结构声明结构变量,结构变量的声明形式如下:

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

例如. . .


C c c

例如,利用定义的职员结构staffer声明一个职员结构变量:

staffer employee1;

注意:

不能在定义结构时对成员进行初始化,因为结构是一种数据类型,而不是一个变量。只有在声明一个结构变量时才可以对该结构变量的成员进行初始化。如下所示:

staffer employee1= {110105, "LiMing", 1, 3809.80 };


C c c

结构变量的引用

  • 结构变量是一种组合类型的变量,结构变量的引用包括整个变量的引用和其成员的引用。

  • 作为变量,整个结构变量可以进行赋值、作为函数参数和返回值。

  • 结构变量成员的使用与同类型的普通变量完全一样,但必须使用成员运算符“.”说明是哪一个结构变量的成员。结构成员引用的形式为:

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

    例如. . .


C c c

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

employee1=employee2; // 引用整个结构变量

employee1.ID=110108; // 引用结构成员

strcpy(employee1.name, "WangPing"); // 结构成员

指向结构变量的指针:

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

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

例如. . .


C c c

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

staffer* pStaff=&employee1; // 声明结构变量的指针

pStaff ->ID=110115; // 引用结构成员

strcpy(pStaff ->name, "WangPing"); // 引用结构成员

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

#include <iostream.h>

struct student{ // 定义结构

char name[20];

int score[4];

int average;

};


C c c

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'; // 输出结果

}


C c c
枚举

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

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

  • 枚举类型定义的一般形式为:

    enum <枚举类型名> { <常量1>,<常量2>,

    …,<常量n> };

  • 枚举常量是C++标识符,每一个枚举常量对应一个整数值,第1个常量值为0,第2个常量值为1,依此类推。

    使用举例:


C c c
使用举例:

  • 以下定义了一个表示颜色的枚举类型:

    enum Color{Red, Green, Blue};

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

    [enum]Color MyColor ;

  • 声明了枚举型变量,就可以将定义枚举类型时所列举的枚举常量集合中的任何一个常量赋值给枚举型变量。例如:

    MyColor = Green;

  • 在定义枚举类型时,可以为枚举常量指定其对应的整型值,例如:

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


Typedef
typedef定义类型

用typedef语句定义类型是指对原有的数据类型定义一个新的名称,而不是真正定义一个新的数据类型。

typedef语句的使用形式为:

typedef <数据类型> <新的类型名>;

其中的数据类型可以是简单的数据类型,如int、float和char等,也可以是诸如结构、枚举等组合数据类型。

使用typedef的目的有两个:移植程序,增加程序的可读性。

使用举例:


C c c
例如:

typedef int INTEGER;

typedef unsigned char BYTE;

typedef struct tagDate {

int year;

int month;

int day;

} DATE;

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

INTEGER i ;


C c c

2.3 数据类型和表达式

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

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

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

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


C c c

数据类型

说明

长度(位)

char

字符型

8

int

整型

32

float

单精度实型

32

double

双精度实型

64

void

无值型

0

unsigned [int]

无符号整型

16

short [int]

短整型

16

long [int]

长整型

32

C++基本数据类型


C c c

例:

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


C c c

2.3 数据类型和表达式

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


C c c

2.3 数据类型和表达式

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

Bjarne Stroustrup AT&T Labs


C c c

2.3 数据类型和表达式

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 boolfor logical values, charfor characters, intfor integer values, and doublefor floating point values. The remaining fundamental types are variations for optimizations and special needs that are best ignored until such needs arise.

Bjarne Stroustrup AT&T Labs


C c c

2.3 数据类型和表达式

  • Specifiers

Specifiers modify the meanings of the basic built-in types and 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: shortint, int, longint.

The size hierarchy for floating point numbers is: float, double, and longdouble. “Long float” is not a legal type. There are no short floating-point

Thinking in C++


C c c

2.3 数据类型和表达式

  • Specifiers

The signed and unsigned specifiers tell the compiler how to use the sign bit with integral types and characters (floating-point numbers always contain a sign). An unsigned number does not keep track of the sign and thus has an extra bit available, so it can store positive numbers twice as large as the positive numbers that can be stored in a signed number. signed is the default and is only necessary with char; char may or may not default to signed. By specifying signedchar, you force the sign bit to be used.

Thinking in C++


C c c

数组属于构造类型,它是一组具有相同类型数据的有序集合,其中每个数据称为数组的元素。数组按其下标的个数分为一维数组、二维数组和多维数组。

一维数组的声明方式如下:

<数据类型> <数组名>[常量表达式];

二维数组的声明方式如下:

<数据类型> <数组名>[常量表达式] [常量表达式];

数组名后括号中的常量表达式表示数组的长度,即数组所包含元素的数量。例如. . .


Float score 30 score 30 float int array 12 4 array 12 4 int
数组声明语句:float score[30]; // 数组score有30个元素,其数据类型是float型int Array[12][4]; // 数组Array有12×4个元素,其数据类型是int型

数组的使用:

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

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

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


C c c

注意:

  • 数组元素的下标从0开始,直到数组长度减1,如:score[0],score[1],…,score[29]。

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


C c c

数组的初始化

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

    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]的初始值。


C c c

数组的初始化

  • 初始值的个数可以比数组元素的个数少,这时未提供初始值的元素被置为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}};

    数组使用举例


C c c

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


C c c

#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';

}


C c c

2.3 数据类型和表达式

  • 指针 (Pointer)

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

指针变量声明的一般形式为:

<数据类型> * <指针名>;

符号“*”是指针类型说明符,声明变量是一个指针型变量。例如:

int* pointer ;

int *pointer ; // 两条语句功能相同


C c c
与指针有关的运算符

  • 有两个与指针有关的运算符:取地址运算符“&”和指针运算符“*”;

  • 运算符“&”用于取一个变量的地址;

  • 运算符“*”以一个指针作为其操作数,其运算结果表示所指向的变量;

  • “&”运算和“*”运算互为逆运算。

    指针使用举例


C c c
例 指针的使用

#include <iostream.h>

void main()

{

int a, b, *pa, *pb;

a=10; b=20;

pa=&a; pb=&b;

cout<<*pa<<','<<*pb<<'\n';

pa=&b; pb=&a; cout<<*pa<<','<<*pb<<'\n';

*pa=100; *pb=200; cout<<a<<','<<b<<'\n';

}

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

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

// 分别对b和a赋值

运行结果


C c c

程序运行结果:

10,20

20,10

200,100

如果先声明了变量,就可以在声明指针变量时对指针进行初始化。如下所示:

int a, b;

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


C c c

指针与数组

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

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

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


C c c

利用指针引用数组的方法求一个数组中所有元素之和。

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


C c c

#include <iostream.h>

void main()

{

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';

}


C c c

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

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

2.3 数据类型和表达式

  • 指针和引用(Pointer&Reference)

<类型>* <变量>;

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


C c c

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

int int1;

int &rint=int1;

引用不是值,不占有存储空间

2.3 数据类型和表达式

  • 引用类型的概念(Reference)


C c c

引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址.

引用运算符&,声明引用的形式为:

数据类型 & 引用变量名=变量名;

如:int b;

int &a=b;

则a为b的一个引用,b为被引用对象,a、b指向同一地址空间,a相当于b的一个别名,绰号。对a的操作,就会b引起操作,反之亦然。


C c c

int引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址 ival = 1024;

int &refVal = ival;

refVal += 2;

2.3 数据类型和表达式

  • 引用类型的概念(Reference)

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

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

C++ Primer


C c c

2.3 引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址数据类型和表达式

  • 引用类型的概念(Reference)

#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;

}


C c c

说明引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

1)声明多个引用型变量,每个变量名前都冠以&。

2)引用不是变量,本身不能被修改,对引用的存取都是对它所引用的变量存取。

3)声明引用时必须要进行初始化,除非引用做参数或返回值。

4)不能声明引用的引用,也不能声明数组元素类型为引用数组,或指向引用的指针。


C c c

2.3 引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址数据类型和表达式

  • 引用类型的概念(Reference)

#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;

}


C c c

int引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址 ival = 1024;

// ok: refVal is a reference to ival

int &refVal = ival;

// error: a reference must be //initializedto an object

int &refVal2;

2.3 数据类型和表达式

  • 引用类型的概念(Reference)


C c c

int &a[5];引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

int &*p; //错误

int *a;

int *&p=a;

int b;

p=&b;

2.3 数据类型和表达式

  • 引用类型的概念(Reference)


C c c

5) 引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址指针与引用区别

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


C c c

6) 引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址引用运算符和地址运算符的区别

int num=50;

int &ref=num;

int *p=&ref;

7) 可以用另外一个引用初始化另外一个引用

int num=50;

int &ref1=num;

int &ref2=ref1;

ref2=100;

2.10 引用


C c c

8)引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址可以把函数的参数声明成引用,以建立函数参数的引用传递方式。

2.10 引用

void swap(int & rx,int & ry)

{

int temp=rx;

rx=ry;

ry=temp;

}


C c c

2.3 引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址数据类型和表达式

  • 引用类型的概念(Reference)

#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;

}


C c c

9) 引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址有空指针,无空引用

int *p=null;

int num=10;

int &ref=null; //错误

int &ref=num;

2.10 引用


C c c

10) 引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址函数调用引用可以作为左值

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

见: P27 例2.8、例2.9

2.10 引用


C c c

2.3 引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址数据类型和表达式

运算符:

  • 运算是对数据进行加工的过程,表示各种不同运算的符号称为运算符,而参与运算的数据称为操作数。

  • 运算符实质上是系统预定义的函数名,而进行运算就是调用一个函数。

  • 按运算符和操作数的运算性质,运算符可分为算术运算符、逻辑运算符、关系运算符和其它运算符,见下表。

    常用:+、-、*、/、%、++、()、=、+=、->、&&、<、<=、new、delete


C c c

优先级引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

运算符

功能说明

结合性

1

.,->

::

成员运算符

作用域限定符

右结合

*

&

new,delete

!

++,--

( )

sizeof

指针运算,取内容

求变量的地址

动态内存分配和释放

逻辑非

自增和自减运算

强制类型转换

求所占内存字节数

左结合

3

*,/,%

乘、除和求余

右结合

4

+,-

加和减

右结合

2.3 数据类型和表达式

22


C c c

优先级引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

运算符

功能说明

结合性

5

<,<=,>,>=

小于、小于等于、…

右结合

6

==,!=

等于和不等于

右结合

7

&&

逻辑与

右结合

9

? :

条件运算,三目运算

左结合

11

10

,

=,+=,-=,*=,/=

顺序求值运算

赋值运算和复合赋值运算

左结合

左结合

2.3 数据类型和表达式

8

| |

逻辑或

右结合


X y area pi radius radius a b x y
例如:引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址x+y,area=PI*radius*radius,(a>b) && (x<=y)

表达式:

  • 一个表达式由常量、变量、函数调用和运算符组成,每个表达式都将产生一个值,并且具有某种类型(称为该表达式的类型)。

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

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

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

  • 运算符的结合性:右结合性和左结合性


C c c

引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址1:

#include <iostream.h>

void main()

{

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;

}


C c c

引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址2:

#include <iostream.h>

void main()

{

int x,y;

x=3;

y=6;

x+=3;

y*=x;

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

}


C c c

引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址3:

#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;

}


C c c

引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址4:

#include <iostream.h>

void main()

{

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;

}


C c c

引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址5:

#include <iostream.h>

void main()

{

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

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

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

}


Const

C引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址语言中常量定义

#define PI 3.1415926

C++里,用const修饰符定义常量

const float PI =3.1415926;

该常量有类型,有地址,可以用指针指向这个值,但不能修改。

const修饰符


C c c

注意引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

1)使用const修饰符定义常量时,必须初始化

2)常量被定义后,程序其他地方不能再修改

3)定义整型常量,int可省略。

4)C++编译程序会对常量进行类型检查。

5)函数参数也可声明为常量,保证实参在函数内部不被改动


C c c

常量与指针结合使用引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

1 指向常量的指针。

例如: const char * pc=“abcd”;

2 常指针。

char *const pc=“abcd”;

不能改变pc的值。

pc[3]=‘x’;

pc=“dfasdfa”


C c c

指向常量的常指针引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

const char * const pc=“abcd”;

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


String

C++引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址提供string 类型存放字符串。

string


C c c

作用运算符指定作用域引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

作用域运算符(::)


C c c

例:引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

#include <iostream>

using namespace std;

float a=2.4; //全局变量

void main()

{

int a=8; //局部变量

cout<<a<<endl;

}


C c c

例:引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

#include <iostream>

using namespace std;

float a=2.4; //全局变量

void main()

{

int a=8; //局部变量

cout<<a<<endl;

cout<<::a<<endl;

}


C c c

C++引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址里引入namespace的目的就是为了避免污染全局名字空间,简单地说,就是为了避免和减少命名冲突。一旦一个程序写大了,就很难避免重名,特别是多人合作的情况下。解决相同的函数名,或变量名,或者两个不同的库里面有相同的函数名,相当于一个文件域.

名字空间


C c c

namespace ns1引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

{

float a, b, c;

fun1(){….}

}

使用域内成员,需要使用域操作符号“::”

ns1::a ;

ns1::fun1();

名字空间定义


C c c

namespace引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址 ns1

{

namespace ns2

{

class matrix{…}

}

}

访问matrix,可写成n1::n2::matrix。

名字空间分层嵌套定义

全局名字空间


C c c

使用关键字引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址using

using ns1::ns2::martix

以后在再次使用martix, 可以直接使用

使用using namespace 名字空间名

 空间所有成员都可以被直接使用

using namespace std

c++所有组件都在std中,通过该语句则可以使用标准C++库所有成员,注意此时若使用include包含头文件,要去掉头文件扩展名。

名字空间使用


C c c

动态内存分配引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址(Dynamic memory allocation)

2.4 动态内存分配

  • 静态与动态内存分配的两个主要区别是

  • 静态对象是有名字的变量,直接对其进行操作。而动态对象是没有名字的变量,通过指针间接地对它进行操作。

  • 静态对象的分配与释放由编译器自动处理,程序员需要理解这一点,但不需要做任何事情。相反,动态对象的分配与释放必须由程序员显式地管理,相对来说比较容易出错它通过new和delete两个运算符来完成。


C c c

动态内存分配引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址(Dynamic memory allocation)

2.4 动态内存分配

C

malloc(), calloc()和free().

C++


C c c

2.4.1 new引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址和delete操作符

  • new运算符动态分配堆内存

    使用形式:指针变量 = new 类型 (常量);

    指针变量 = new 类型 [ 表达式] ;

    作用:从堆分配一块“类型”大小的存储空间,返回首地址

    其中:“常量”是初始化值,可缺省

    创建数组对象时,不能为对象指定初始值

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

    使用形式:delete 指针变量 ;

    delete [ ] 指针变量 ;

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


C c c

2.4.1 new引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址和delete操作符

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 ;


C c c

2.4.1 new引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址和delete操作符

p1

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 ;


C c c

p1引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

2.4.1 new和delete操作符

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 ;

p2


4 5 1 new delete

p1引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

p2

2.4.1 new和delete操作符

4.5.1 new 和 delete 操作符

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 ;

p3


4 5 1 new delete1

p1引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

p2

2.4.1 new和delete操作符

4.5.1 new 和 delete 操作符

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 ;

p3

p4


4 5 1 new delete2

p2引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

p1

2.4.1 new和delete操作符

4.5.1 new 和 delete 操作符

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 ;

p3

p4


4 5 1 new delete3

p2引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

2.4.1 new和delete操作符

4.5.1 new 和 delete 操作符

p1

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 ;

p3

p4


4 5 1 new delete4

p2引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

2.4.1 new和delete操作符

4.5.1 new 和 delete 操作符

p1

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 ;

p3

p4


C c c

2.4.1 new引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址和delete操作符

p1

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 ;

p2

p3

p4


C c c

2.4.1 new引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址和delete操作符

p1

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 ;

p2

p3

p4


C c c

2.4.1 new引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址和delete操作符

p1

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 ;

p2

p3

p4


C c c

2.4.1 new引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址和delete操作符

p1

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 ;

p2

p3

p4


C c c

2.4.1 new引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址和delete操作符

p1

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 ;

p2

p3

p4


C c c

2.4.1 new引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址和delete操作符

p1

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 ;

p2

p3

p4


C c c

2.4.1 new引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址和delete操作符

例用 new 算符建立简单对象

#include<iostream.h>

void main()

{ int * p = NULL ;

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

if ( p == NULL )

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

cout << *p ;

delete p ;

}


C c c

p引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

2.4.1 new和delete操作符

例用 new 算符建立简单对象

#include<iostream.h>

void main()

{ int * p = NULL ;

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

if ( p == NULL )

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

cout << *p ;

delete p ;

}


C c c

2.4.1 new引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址和delete操作符

例用 new 算符建立简单对象

p

#include<iostream.h>

void main()

{ int * p = NULL ;

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

if ( p == NULL )

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

cout << *p ;

delete p ;

}

89


C c c

p引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

89

例用 new 算符建立简单对象

#include<iostream.h>

void main()

{ int * p = NULL ;

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

if ( p == NULL )

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

cout << *p ;

delete p ;

}


C c c

p引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

89

2.4.1 new和delete操作符

例用 new 算符建立简单对象

#include<iostream.h>

void main()

{ int * p = NULL ;

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

if ( p == NULL )

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

cout << *p ;

delete p ;

}

对象无名

只能通过指针访问

89


C c c

89引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

2.4.1 new和delete操作符

例用 new 算符建立简单对象

p

#include<iostream.h>

void main()

{ int * p = NULL ;

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

if ( p == NULL )

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

cout << *p ;

delete p ;

}

89


C c c

2.4.1 new引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址和delete操作符

例用 new 算符建立简单对象

p

#include<iostream.h>

void main()

{ int * p = NULL ;

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

if ( p == NULL )

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

cout << *p ;

delete p ;

}

89

89


C c c

2.4.1 new引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址和delete操作符

例用 new 算符建立动态数组

#include<iostream.h>

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 ;

}


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

p

t

2.4.1 new和delete操作符

例用 new 算符建立动态数组

#include<iostream.h>

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 ;

}


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

#include<iostream.h>

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 ;

}


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

#include<iostream.h>

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 ;

}


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

|


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

|


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

|


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

100 |


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

100 |


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

100 |


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

100 101 |


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

100 101 |


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

100 101 |


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

100 101 |


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

100 101 102 |


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

100 101 102 |


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

100 101 102 |


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

100 101 102 |


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

100 101 102 103 |


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

100 101 102 103 104 105 106 107 108 109 |


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

100 101 102 103 104 105 106 107 108 109 |


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

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 ;

}

100 101 102 103 104 105 106 107 108 109

|


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

void main()

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

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 ;

}

100 101 102 103 104 105 106 107 108 109

|


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

void main()

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

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 ;

}

100 101 102 103 104 105 106 107 108 109

|


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

void main()

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

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 ;

}


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

void main()

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

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 ;

}

以下标方式

访问动态数组


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

void main()

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

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 ;

}

i 是偏移量

p指针本身值不变


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

void main()

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

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 ;

}

跟踪指针赋初值


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

void main()

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

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 ;

}

跟踪指针移动


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

t

2.4.1 new和delete操作符

p

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

void main()

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

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 ;

}

间址访问元素


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

p

2.4.1 new和delete操作符

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

void main()

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

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 ;

}

注意

结束循环后

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

{ cout << *p << " " ;

p++;

}


C c c

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

p

2.4.1 new和delete操作符

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

void main()

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

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 ;

}

注意

结束循环后

释放什么空间?

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

{ cout << *p << " " ;

p++;

}

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

cout << *p << " " ;


4 5 1 new delete5

i引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

10

p

2.4.1 new和delete操作符

4.5.1 new 和 delete 操作符

例用 new 算符建立动态数组

100

101

102

103

104

105

106

107

108

109

#include<iostream.h>

void main()

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

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 ;

}

内存泄漏

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

{ cout << *p << " " ;

p++;

}


C c c

杨辉三角形引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

2.4.2 new和delete操作符实例

例输出二项式系数表

( 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


C c c

杨辉三角形引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

2.4.2 new和delete操作符实例

例输出二项式系数表

算法分析

  • n 次系数表有 n +1 项

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

    F0 = 1

    Fn+1 = 1

    Fi = Fi-1 + Fi


C c c
上机题目引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址

  • 1、利用动态内存分配完成杨辉三角形的输出。

  • 2、求数列前20项:


C c c

  • 3引用描述一种特殊的数据类型,用于声明两个以上的变量名,指向同一地址、求100之内的自然数中所有奇数的和。

  • 4、求出所有的水仙花数。三位数,其中各位数的立方和恰好等于该数本身,如153=13+53+33。

  • 5、求出1~1000间的素数,要求每行输出6个数。

  • 6、求1!+2!+……+n!。


ad