级面向对象程序设计课件一部分

第6章指针与引用本章介绍指针和引用基本知识：指针的声明、指针的运算、void和const指针、引用的声明及使用；讨论指针与数组、指针与函数、引用与函数的关系。

指针是保存内存地址的变量。通过指针，程序员可以直接管理计算机内存。正确地使用指针，可以有效地表示更加复杂的数据结构。此外，C++指针还可以用在函数的传址调用等场合，使得C++的功能非常强大。指针是C++语言从C语言中继承来的重要概念，是C++语言最重要的特色之一。指针的正确使用是C++语言的学习重点之一。【

指针】计算机内存划分为内存单元，这些内存单元按其顺序进行编址。程序运行时，系统将利用内存存储相关的数据。【

数据存储】程序中的每个变量在其生存期内存储的位置是不变的，具有固定的存储地址。数据在内存中的存储方式是：按其所属的数据类型，占据一定数量的连续内存单元。C++程序运行时，系统会自动地根据变量数据类型为该变量分配相应的内存。必要时可以使用取地址运算符“&”来获取变量的地址。指针变量是用于存放内存地址的变量。可将变量的地址保存在指针变量中列出的基类型并不是指针变量本身的类型，而是指针用于保存的地址值中存储的变量的数据类型，即指针所指向变量的数据类型。指针变量，必须先声明，后使用。其声明的一般形式如下：

基类型*指针变量名；标识符给出的是指针变量名。“*”号说明其后的变量是一个指针变量。基类型可以是C++语言中任一合法的类型。【

指针变量的声明及使用】说明：声明了p1、p2两个指针。其中p1指向int型变量，p2指向double型变量。比如：int*p1; double*p2;使用指针前，必须首先给它赋一个合法的值。否则，程序中对指针的访问有可能导致系统崩溃。注与其他变量一样，指针可以通过初始化来赋值。比如：inti,*p1=&i; int*p2=0;说明：第1个声明就将指针p1的值初始化为变量i的内存地址；第2个声明将指针p2的值初始化为0。值为0的指针叫空指针。如果在声明时，指针初始化为0或根本没有初始化，使用前，就必须首先给它赋有意义的值。比如：inti,*p1；

p1=&i;数组名表示的是该数组的首地址值，如果声明指针指向一个数组。就可以使用下述赋值方法：

intx［5］,*px=x;把指针px初始化为指向数组intx［5］的指针，即指针px指向数组的第一个元素。不需要使用取地址运算符“&”。等价intx［5］,*px=&x[0];说明：没有明确地给指针赋一个地址值，因而其值是随机的。将输出变量i的值1比如：inti=1,*p=&i; cout<<*p;*p=2；

cout<<*p;输出2例如 int*p; *p=2；//错误，指针p没有赋值

使用指针前，必须首先给它赋一个合法的值。注利用指针来访问变量需要使用间接访问运算符“*”。通过“*”运算访问目的数据的过程也称为“间接寻址”过程。传值调用减少了主调函数与被调函数之间的数据依赖，被调函数对形参值的任何改变不会影响到实参。利用指针，形参的改变对相应的实参有效。【

指针作为函数参数】函数的某个参数是指针，对这个函数的调用就是传址调用。在进行传址调用时，函数的实参传递给形参的是一个地址，从而使得形参指针和实参指针指向同一个地址。被调函数中对形参指针所指向的地址中内容的任何改变都会影响到实参。例6-1交换两个整数#include<iostream>usingnamespacestd;intmain(void){voidswap(int*p1,int*p2);int*point_1,*point_2,a,b;cin>>a>>b;point_1=&a;point_2=&b;if(a<b)swap(point_1,point_2);cout<<″Inmainfunction:″<<endl;cout<<″max=″<<a<<″min=″<<b<<endl;return0;}voidswap(int*p1,int*p2){inttemp;temp=*p1;*p1=*p2;*p2=temp;}

采用传址调用时，被调函数中形参指向的值的改变对实参有效。78(输入两个整数)max=78min=45指针变量也是一个变量，在内存中也需占据一定的空间，具有一个地址，这个地址也可以利用指针变量来保存。声明一个指针来指向它，这个指针称为指向指针的指针，也即二级指针。声明二级指针的形式如下：

数据类型**标识符比如：inti,*p=&i; int**pp=&p;指通过两次间接寻址后所访问的变量的类型。标识符为指针名。两个“*”号表示二级指针。声明了一个二级指针pp，它指向指针p。

通过二级指针访问目的单元中的数据值必须使用两个“*”号。注【

指向指针的指针】数组名表示的是该数组的首地址值，是指向数组第一个元素的指针常量。数组在内存中是顺序存储的，声明某个指针指向数组中的一个元素，就可以通过指针和整数的加减运算（包括增1和减1运算）来访问这个数组的每个元素。由于数组名本身就是指向数组第一个元素的指针常量，因此，可以通过它来访问其中的元素。【

指向数组元素的指针】

例如： intx[5];数组名x是指向第一个元素x[0]的指针，*x表示的就是元素x［0］的值；*(x+2)则是访问x［2］中的值的有效方法。【

指针与数组】例6-2访问数组元素#include<iostream>usingnamespacestd;intmain(){inta[10]={0,1,2,3,4,5,6,7,8,9},i,*p=a;

for(i=0;i<10;i++)cout<<a[i])<<′′;

//利用数组下标输出数组元素值，下标法

cout<<endl;for(i=0;i<10;i++)cout<<*(a+i)<<′′;

//利用数组名输出数组元素值，指针法

cout<<endl;for(p=a,p<(a+10);p++)cout<<*p)<<′′;

//利用指针变量输出数组元素值return0;}

012345678901234567890123456789利用指针对数组进行操作时，必须注意越界问题。比如： inta[10]; int*p=a;

//指针p指向数组x的首地址

cout<<*(p+10)*p=5;

数组是连续存储的，通过对指向数组的指针进行加减运算，使指针指向数组中不同的元素。p=p+10已经使指针p指向的地址在数组之外，*p=5表达式在这个地址中写入值有可能造成严重的后果。【

用指针变量作函数形参接受数组地址】数组名作函数参数，传递的是数组首元素的地址用指针变量作函数形参，也可以接收数组首元素的地址#include<iostream>usingnamespacestd;intmain(){voidselect_sort(int*p,intn);inta[10],i;cout<<″entertheoriginalarray:″<<endl;for(i=0;i<10;i++)cin>>a[i];cout<<endl;select_sort(a,10);cout<<″thesortedarray:″<<endl;for(i=0;i<10;i++)cout<<a[i]<<“”;cout<<endl;return0;} 例6-3将10个整数按由小到大的顺序排列voidselect_sort(int*p,intn)//用指针变量作形参

{inti,j,k,t;for(i=0;i<n-1;i++){k=i;for(j=i+1;j<n;j++)if(*(p+j)<*(p+k))k=j;//用指针法访问数组元素t=*(p+k);*(p+k)=*(p+i);*(p+i)=t;}}entertheoriginalarray:3452168970thesortedarray:0123456789（续）数组中每个元素都是一个指针。它的定义形式如下：

类型名*数组名[数组长度]；指针数组就是元素为指针的数组。例如：int*p[4];

指数组中各元素指针所指向的类型，同一指针数组中各指针元素指向的类型相同。是一个标识符，是这个数组的名字，也即数组的首地址。【

指针数组】

不要写成

int(*p)[4];这是指向一维数组的指针变量注

指针数组若干字符串按字母顺序（从小到大）输出#include<iostream>usingnamespacestd;intmain(){voidsort(char*name[],intn);

//声明函数voidprint(char*name[],intn);char*name[]={“BASIC”,”FORTRAN”,”C++”,”Pascal”,”COBOL”};intn=5;sort(name,n);print(name,n);return0;}例6-4voidprint(char*name[],intn){inti;for(i=0;i<n;i++)cout<<name[i]<<endl;}BASICCOBOLC++FORTRANPascalvoidsort(char*name[],intn){char*temp;inti,j,k;for(i=0;i<n-1;i++){k=i;for(j=i+1;j<n;j++)if(strcmp(name[k],name[j])>0)k=j;if(k!=i){temp=name[i];name[i]=name[k];name[k]=temp;}}}【

字符串与指针】C++中除了可以用字符数组、字符串变量来存放字符串外，还可以用字符指针指向一个字符串#include<iostream>usingnamespacestd;intmain(){char*str=“IloveChina!”cout<<str<<endl;return0;}

例：函数名是一个指向函数首地址的指针常量。可以声明一个指向函数的指针，并使用该指针来调用函数。指向函数的指针通常简称为函数指针。声明的一般形式如下：

函数类型（*变量名）（函数形参表）；指函数返回值的类型，形参表中的内容应与指针所指向的函数的形参表相同。【

函数指针】【

函数与指针】比如：int(*p)(int,int);声明的函数指针可以指向一个函数的首地址，该函数的返回值类型和形参表都必须与上述声明中指定的相同。赋值的一般方法如下：

函数指针名=函数名使用函数指针时，必须先赋值。函数名所代表的函数必须是函数指针可以指向的。声明了指针p。该指针可以指向返回值为int型，有两个int型参数的函数。

函数指针#include<iostream>usingnamespacestd;intmain(){intmax(intx,inty);

//声明函数int(*p)(int,int);

//定义指向函数的指针变量pinta,b,m;p=max;

//使p指向函数

cin>>a>>b;m=p(a,b);cout<<“max=”<<m<<endl;return0;}intmax(intx,inty){intz;if(x>y)z=x;elsez=y;returnz;} 例6-5当一个函数的返回值是指针时，通过返回的指针中存储的地址值，主调函数就能访问相应内存中存放的数据，还能通过指针算术运算访问这个地址前后内存中的值。定义返回指针的函数的函数头一般形式如下：

类型名*函数名（参数列表）指针作为函数返回值的情形，较多地出现在主调函数需要访问返回地址前后顺序存放的多个变量时，如数组、字符串。注是函数返回的指针所指向数据的类型。【

返回指针的函数】指向void类型的指针称为void指针。声明指针时，可以用关键字const进行修饰，用关键字const修饰的指针称为const指针。比如：inta,b; int*p1=&a,*p2=p1;一般来说，只能用指向相同类型的指针给另一个指针赋值。void指针【

void和const指针】比如：inta;int*p1=&a;double*p2=p1;//错误比如：inta;

//声明int型变量int*p1=&a;

//给指针p1赋值void*p2=p1;

//用int型指针直接给void指针赋值，正确int*p3=p2;

//用void指针直接给int型指针赋值，错误int*p4=(int*)p2;

//void指针通过强制类型转换给int型指针赋值，

//正确void指针是一个特例，它可以指向任何类型的C++数据。也即可以用任一类型的指针直接给void指针赋值。如果需要将void指针的值赋给其他类型的指针，则需要进行强制类型转换。语句中的两个指针指向的类型不同，因此，它们之间不能相互赋值。除非进行强制类型转换。不同类型指针间的赋值是错误的。void指针#include<iostream>usingnamespacestd;intmain(){inta=1;int*p1=&a,*p2=0;void*pv=p1;

//用int型指针直接给void指针赋值

cout<<″a=＼t″<<a<<endl;cout<<″*(int*)pv=＼t″<<*(int*)pv<<endl;

//输出结果时，void指针必须强制类型转换

p2=(int*)pv;

//给int型指针赋值时，void指针必须转换

cout<<″*p2=＼t″<<*p2<<endl;return0;}a=1*(int*)pv=1*pa2=1例

6-61、

指向常量的指针变量程序中不能通过指针来改变它所指向的值，但指针本身的值可以改变，即指针可以指向其他数据。一般形式为：

const类型名*指针变量名；const指针在用关键字const修饰指针时，关键字const可以放在指针类型前或“*”号与指针名之间，甚至可以在上述两个地方都加。比如： inta=1,b=2; constint*p1=0;

//声明指向int型常量的指针p1 p1=&a;//将int型变量a的地址赋给指针 *p1=2;//错误，不能通过指向常量的指针来改变它所指的值 a=2//正确，变量的值可通过变量名改变

p1=&b;//正确，指向常量的指针本身的值可以改变关键字const放在不同的位置表示的意义也不相同。2指针常量（也称常指针）指针本身的值不可改变，即不能再指向其他数据，但它指向的数据的值可以改变。定义的一般形式为：

类型名*const

指针变量名；

在声明常指针时必须初始化（除非它是函数的形参）。注比如： inta=1,b=2;

int*constp1=&a;

//声明指向int型常量的指针p1 int*constp2;//错误，在声明指针常量时，必须初始化 *p1=2;//正确，指针常量指向的值可以改变

p1=&b;//错误，指针常量本身的值不可改变3、指向常量的常指针指针本身的值不可改变，它所指向的数据的值也不能通过指针改变。定义的一般形式为：

const

类型名*const指针变量名；

对于能说明为常量的情形，应该尽量用关键字const修饰。注比如： inta=10,b=20; constint*constp1=&a;//声明指向int型常量的常指针p1

*p1=2;//错误，指针常量指向的值不可改变

p1=&b;//错误，指针常量本身的值不可改变a=30;//正确，变量的值可通过变量名改变引用是一个别名。声明引用的过程是为某个变量建立别名的过程（也称某个变量被引用）。在声明引用时需要同时初始化其声明的一般形式如下：

数据类型&引用名=变量名； 或 数据类型&引用名（变量名）；比如：inta; int&ra=a;被引用的变量可以是任一类型的变量。ra是为整数a的引用变量名是被引用变量的名字“&”是引用运算符指被引用变量的类型【

引用】

引用#include<iostream.h>intmain(){inta=0;int&ra=a;cout<<″a=″<<a<<endl;cout<<″ra=″<<ra<<endl;ra=2;cout<<″a=″<<a<<endl;cout<<″ra=″<<ra<<endl;cout<<″&a=″<<&a<<endl;cout<<″&ra=″<<&ra<<endl;return0;}为一个变量声明了引用之后，引用就成了这个变量的别名。最后两条语句是输出变量的地址，语句中的“&”号是取地址运算符。例6-7a=0ra=0a=2ra=2&a=0x0065FDF4&ra=0x0065FDF4求引用的地址，实际上返回的是被引用变量的地址。

引用初始化后其值不能改变，即不允许把为一个变量建立的引用重新用作另一变量的别名。程序中，对引用重新赋值的意义是给被引用变量赋新值。不能建立引用数组。不能建立引用的引用。要注意区别引用声明符&和地址运算符&。注（续）之前介绍过的函数参数传递方式有两种：

（1）将变量名作为实参和形参；

（2）形参是指针变量，实参是变量的地址。这两种方式都可以看作“值传递”方式以引用作形参的调用，实参是变量名，称为引用调用。【

把引用用作函数参数】例6-8要求将变量i和j的值互换实参、形参为变量名#include<iostream>usingnamespacestd;intmain(void){voidswap(int,int);

//函数声明inti=3,j=5;swap(i,j);//实参为变量名cout<<″i=″<<i<<′＼t′<<″j=″<<j<<endl;//i

和j的值未互换return0;}

voidswap(inta,intb)//形参为变量名{inttemp;temp=a;a=b;b=temp;}

x=3y=5例6-8形参为指针，实参为地址#include<iostream>usingnamespacestd;intmain(void){voidswap(int*,int*);//函数声明inti=3,j=5;swap(&i,&j);//实参为变量名地址cout<<″i=″<<i<<′＼t′<<″j=″<<j<<endl;//i和j的值互换return0;}

voidswap(int*p1,int*p2)//形参为指针{inttemp;temp=*p1;*p1=*p2;*p1=temp;}

x=5y=3例6-8形参为引用，实参为变量名（引用调用）#include<iostream>usingnamespacestd;intmain(void){voidswap(int&,int&);

//函数声明inti=3,j=5;swap(i,j);//实参为变量名cout<<″i=″<<i<<′＼t′<<″j=″<<j<<endl;//i和j的值互换return0;}

voidswap(int&a,int&b)//形参为引用{inttemp;temp=a;a=b;b=temp;} x=5y=3函数可以返回引用，必须注意，引用只是一个别名，绝对不能返回不在作用域内的对象的引用。例6-9

返回引用#include<iostream>usingnamespacestd;int&fun(int&i);intmain(){inta;cout<<fun(a)<<endl;return0;}int&fun(int&i){i=2;returni;}2【

返回引用的函数】2.利用引用调用提高程序的效率采用传址或引用调用，函数中传递的是对象的地址，不需要为对象临时建立一个副本，程序的效率将会提高。指针与引用的不同：（1）引用不可以是空引用。如果对象有可能为空时，就必须采用指针。（2）引用本身不能重新赋值。如果程序需要先指向一个对象，后又指向另一对象，也应该采用指针。例6-10

空引用#include<iostream>#include<stdlib>usingnamespacestd;int&fun();intmain(){int&rp=fun();int*p=&rp;cout<<rp;deletep;

//释放内存后，引用rp是一个空引用

return0;}

上例能编译运行。但它确实出现了空引用，这是不对的。（续）int&fun(){int*p=newint;if(p==0){cout<<"内存分配错误"<<endl; exit(1); //系统函数，用于终止程序的运行

}int&rp=*p;rp=5;returnrp;}第7章自定义数据类型本章介绍自定义数据类型：结构体、共用体、枚举的定义及使用；讨论new和delete的使用及typedef的应用。

除了数组，用户可以自己声明的类型还有:结构体(structure)类型共用体(union)类型枚举(enumeration)类型类(class)类型【

结构体类型】【结构体类型变量的定义及引用】☆将不同类型的数据组合成一个有机的整体,C++语言提供了一种数据结构,称为结构体。例：

structStudent{ intnum;//学号

charname[20];//姓名 charsex;//性别

int//年龄};struct结构体类型名{成员表列};//注意分号不要遗漏例：

structStudent{ intnum;//类型名成员名; charname[20]; intage;};1、结构体类型声明方式结构体类型可全局声明,也可局部声明。结构体类型名2、结构体类型变量的定义使用结构体时,不能使用结构体类型名，只能使用结构体变量。定义结构体变量有三种方法。方法1：先声明结构体类型,再定义变量。方法2：声明结构体类型的同时,定义变量。方法3：直接定义结构体类型变量。系统根据变量定义,分配内存空间。方法2：声明的同时定义变量例：

structStudent{intnum;charname[20];}student1,s2,s3;方法3：直接定义变量(不可取)例：

struct{ intnum; charname[20];}student1,s2,s3;C++中，声明结构体类型时可以不加关键字struct，而C一定要加注方法1：先声明结构体类型,再定义变量。(最可取)例：structStudent//24B{ intnum; charname[20];};Studentstudent1,student2;☆其他说明(1)不是结构体类型都有相同的结构。例：structStudent//24B{ intnum; charname[20];};structStudent1//8B{ intnum; intage;};(2)类型与变量不同①使用变量,不能使用类型。②编译时,仅对变量分配内存。(3)成员的引用相当普通的变量(.成员运算符)例：structS{ intnum; charname[20];}s1,s2;使用：

s1.num=20;strcpy(,"LiMing");s2.num=21;strcpy(,"ZhangHua");(4)成员也可是结构体变量例：structDate{ intmonth; intday; intyear;

｝;structStudent{ intnum; charname[20]; charsex; intage; Datebirthday;charaddr[30];}student1,student2;3、结构体类型变量的初始化定义时指定初始值例：structStudent{ intnum; charname[20]; charsex; intage; floatscore; charaddr[30];｝student1={10001,"ZhangXin",'M',19,90.5,"Shanghai"};例：student1.num=10010;4、结构体类型变量的引用1）可以将一个结构体变量的值赋给另一个具有相同结构的结构体变量。例：student1=student2;2）可以引用一个结构体变量中的一个成员的值。引用结构体变量中成员的一般方式为：结构体变量名.成员名(.优先级高,自左向右)3）如果成员本身也是一个结构体类型,则要用若干个成员运算符,一级一级地找到最低一级的成员。4）不能将一个结构体变量作为一个整体进行输入和输出。只能对结构体变量中的各个成员分别进行输入和输出。例：

cin>>student1.num;cout>>student1.num;5）对结构体变量的成员可以像普通变量一样进行各种运算(根据其类型决定可以进行的运算种类)。例：sum＝student1.score＋student2.score;student1.age++;由于"."运算符的优先级高,因此student1.age++相当于(student1.age)++。注【

结构体数组】定义结构体数组的目的：

(一个结构体变量只能存一组数据。如：一个学生的档案,一个日期。)定义结构体数组,可有多个元素,就可存放多个学生的档案,多个日期。与定义结构体变量的方法一样，只须指出其为数组即可如：structStudent{ intnum; charname[20]; floatscore;};Studentstu[3];例:structStudent{ intnum; charname[20]; charsex; intage; floatscore; charaddr[30];}stu[3]={{10101,"LiLin",'M',18,87.5,"103BeijingRoad"},{10102,"ZhangFun",'M',19,99,"130ShanghaiRoad"},{10104,"WangMin",'F',20,78.5,"1010,ZhongshanRoad"}};结构体数组的初始化//对候选人得票的统计程序#include<iostream>usingnamespacestd;structPerson{ charname[20]; intcount;};intmain(){Personleader[3]={"Li",0,"Zhang",0,"Fun",0};inti,j;for(i=0;i<10;i++){cin>>leader_name;

for(j=0;j<3;j++) if(strcmp(leader_name,leader[j].name)==0)leader[j].count++;}

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

cout<<leader[i].name<<":”<<leader[i].count<<endl;

return0;}例7-1结构体数组输入：ZhangLiSunLiZhangLi输出：Li：3Zhang：2Sun：1修改程序：(用字符串变量)全局结构体类型声明：

structPerson{

stringname;

intcount;};定义结构体变量,但不能初始化：

Personleader[3];

for(i=0;i<3;i++){ cin>>leader[i].name;

leader[i].count=0;}

stringleader_name;统计得票：

for(i=0;i<10;i++){cin>>leader_name;for(j=0;j<3;j++)

if(leader_name==leader[j].name)

leader[j].count++;}1)指向结构体变量指针变量的定义前提：需声明结构体类型例：structStudent{longnum;charname[20];};定义：结构体类型名*变量名;例：Student*p;【

指向结构体变量的指针】1、通过指向结构体变量的指针引用结构体变量中的成员2)赋初值

Studentstudent1;Student*p;p=&student1;(指向确定)3)引用成员

student1.num=98001(*p).num=98001注意：括号不能省略。4)指向运算符->

(*p).num=98001可改写为p->num=98001优先级最高级结合性自左向右

p->num(可看成一个整体)p->num++++p->num结构体成员的三种表示方法直接访问：student1.num

间接访问：(*p).nump->num2、用结构体变量和指向结构体变量的指针构成链表链表是一种常见的重要的数据结构。链表有一个"头指针"变量,图中以head表示,它存放一个地址。该地址指向第一个元素。链表中的每一个元素称为"结点"。每个结点都应包括两个部分：一是用户需要用的实际数据,二是下一个结点的地址。链表结点的结构体类型：

structStudent{longnum;floatscore;Student*next;};链表的表头：

Student*head;

Part1

Part2

NULL【

结构体类型数据作为函数参数】

将一个结构体变量中的数据传递给另一个函数,有下列3种方法：用结构体变量名作参数。一般较少用这种方法。

(传值调用,单向,不共占内存)(2)用指向结构体变量的指针作实参,将结构体变量的地址传给形参。(传址调用)(3)用结构体变量的引用(别名)作函数参数。

(传址调用)(最可取)例7.2有一个结构体变量stu,内含学生学号、姓名和3门课的成绩。要求在main函数中为各成员赋值,在另一函数print中将它们的值输出。函数声明：voidprint(Student);函数调用：print(stu);函数定义：voidprint(Studentstu){ cout<<stu.num……;}实参stu和形参stu各占内存。传递的是整个结构体成员值用结构体变量作函数参数函数声明：voidprint(Student*);函数调用：print(&stu);

或Student*pt;pt=&stu;print(pt);函数定义：voidprint(Student*p){ cout<<p->num……;}形参p指向实参stu。传递的是结构体变量stu首地址。（2）

用指向结构体变量的指针作形参函数声明：voidprint(Student&);函数调用：print(stu);函数定义：voidprint(Student&stud){ cout<<stud.num……;}形参stud是实参stu的别名,共占内存。传递的是结构体的首地址。（3）用结构体变量的引用(别名)作函数参数在软件开发过程中,常常需要动态地分配和撤销内存空间,例如对动态链表中结点的插入与删除。C++提供了较简便而功能较强的运算符new和delete。

new:动态分配内存空间delete:撤销(释放)内存空间【

new和delete运算符】new和delete是运算符。C语言中malloc()和free()是函数注1、new运算符1)用new分配数组空间时不能指定初值。2)如果由于内存不足等原因而无法正常分配空间,则new会返回一个空指针NULL,用户可以根据该指针的值判断分配空间是否成功。注一般格式为：

new类型[(初值)]

(该中括号表示可选项)例：newint;作用：开辟一个存放整数的存储空间,返回一个指向该存储空间的地址(即指针)。例：newint(100);作用：开辟一个存放整数的空间,并指定该整数的初值为100,返回一个指向该存储空间的地址。

(注意：没有赋给变量,下面的例子也是如此)例：newchar[10];作用：开辟一个存放字符数组(包括10个元素)的空间,返回首元素的地址。

例：newint[5][4];作用：开辟一个存放二维整型数组(大小为5*4)的空间,返回首元素的地址。例：loat*p=newfloat(3.14159);作用：开辟一个存放单精度数的空间,并指定该实数的初值为3.14159,将返回的该空间的地址赋给指针变量p。

一般格式为

delete指针变量（对变量）

或delete[]指针变量（对数组）1)前提：必须有指针变量指向new开辟的内存空间,才可用delete释放。例：newint;开辟了,却不能释放。2)注意：此处中括号为释放动态数组空间需要的。例：float*p=newfloat(3.14159);deletep;作用：释放上面用new开辟的存放单精度数的空间。例：char*pt=newchar[10];delete[]pt;作用：在指针变量前面加一对方括号,表示是对数组空间的释放操作。2、delete运算符//临时开辟一个存储空间存放一个结构体数组#include<iostream>#include<string>usingnamespacestd;structStudent{ stringname; intnum;charsex;};intmain(){Student*p;p=newStudent;p->name=“wangfang”;p->num=10123;p->sex=‘m’;cout<<p->name<<endl<<p->num<<endl<<p->sex<<endl;deletep;

return0;}例7-3动态分配内存输出：wangfang10123m【

共用体】☆有时需要使几种不同类型的变量存放到同一段内存单元中。这种使几个不同的变量共占同一段内存的结构,称为共用体(union)类型声明共用体类型的一般形式