C++语言程序设计 3第三讲——数组_指针与字符串

第六章 数组 指针与字符串,C+语言程序设计,本章主要内容,数组 指针 动态存储分配 指针与数组 指针与函数 字符串,数组的概念,数组是具有一定顺序关系的若干相同类型变量的集合体，组成数组的变量称为该数组的元素，所有的数组元素皆无名。 数组属于构造类型（导出型） 数组是为了给数量众多、但名称无关联的变量们提供命名联系的一种技术。命名联系则要求存放的连续。为了服务于循环。,数 组,C/C+不接受数组元素个数为0的定义。 Why ?,一维数组的使用,必须先声明，后使用； 只能逐个使用数组元素，而不能一次使用整个数组，因为数组名是个地址； 例如：a0=a5+a7-a2*3； 下标一定是正数； 下标一定是整数； 下标不要越界，越界不报警； 你可以把数组存储空间以外的内存单元当作数组元素继续访问，系统会熟视无睹，但由此造成的后果由你来承担。 数组名不可以定义引用。/名字有别名，地址不能有别名。 Why?,数 组,对象数组,声明： 类名 数组名元素个数 ； 访问（使用）对象成员： 将数组元素作为对象，通过下标访问: 数组名下标 . 成员名 对于多维对象数组可以此类推。,数 组,对象个数,对象数组初始化,创建数组中每一个元素对象时，系统都会调用类构造函数初始化该对象。 通过初始化列表赋初值。 例： Point A2=Point(1,2),Point(3,4); 如果没有为数组元素指定显式初始值，数组元素便调用无参构造函数。 各元素对象的初值要求为相同值时，要声明具有默认形参值的构造函数。 各元素对象的初值要求为不同值时，要声明带形参的构造函数。 当数组中每一个对象被删除时，系统都要调用一 次析构函数。,数 组,请解释此写法的含义。,是否可以这样初始化？ Point A2=Point(2,3); 为什么？,例 对象数组应用举例,/Point.h #if !defined(_POINT_H) #define _POINT_H class Point public: Point(); Point(int xx,int yy); Point(); void Move(int x,int y); int GetX() return X; int GetY() return Y; private: int X,Y; ; #endif,该类必备两套构造函数！ 为什么？,/6-2.cpp #include using namespace std; #include “Point.h“ Point:Point() X=Y=0; cout“Default Constructor called.“endl; Point:Point(int xx,int yy) X=xx; Y=yy; cout “Constructor called.“endl; Point :Point() cout“Destructor called.“endl; void Point :Move(int x,int y) X=x; Y=y; ,8,#include #include “Point.h“ using namespace std; void main() cout“Entering main.“endl; Point A2; for(int i=0;i2;i+) Ai.Move(i+10,i+20); cout“Exiting main.“endl; ,9,此句如何产生对象？,此处是否可以增加一句： Point B = A0; 为什么？,运行结果： Entering main. Default Constructor called. Default Constructor called. Exiting main. Destructor called. Destructor called.,10,#include using namespace std; class Point public: Point(); Point(int xx,int yy); Point(); void Show(); int GetX() return X; int GetY() return Y; private: int X,Y; ;,11,部分初始化的对象数组与 无初始化的对象数组的差别,Point:Point() /无参构造函数没对数据成员初始化 cout“Default Constructor called.“endl; Point:Point(int xx,int yy) X=xx; Y=yy; cout “Constructor called.“endl; Point:Point() cout“Destructor called.“endl; void Point:Show() cout“X = “X“, Y = “Yendl; ,12,void main() cout“Entering main.“endl; Point A2=Point(4,6); for(int i=0;i2;i+) Ai.Show(); Point B2; for(i=0;i2;i+) Bi.Show(); cout“Exiting main.“endl; ,13,Constructor called Default Constructor called.,Default Constructor called. Default Constructor called.,运行结果： Entering main. Constructor called Default Constructor called. X = 4 Y = 6 X = 0 Y = 0 Default Constructor called. Default Constructor called. X = -858993460 Y = -858993460 X = -858993460 Y = -858993460 Exiting main. ,14,为何是0而不是任意值？ 尽管是调用无参构造函数来创建对象，可是为了保持与C的一致性，编译器会自作主张的将数据成员填上0。,前例的 Point B2; 语句是创建了一个对象数组。显然是调用了无参构造函数方得以完成的。可见无参构造函数对于一个打算生成各种形式的对象的类而言，决不是可有可无的，尤其是你已为类写了有参构造函数的情况下更是如此。因为你写了，系统就不再补了，于是类就无无参构造函数可用。 当然事情还可以补救：先创建一个该类的指针数组，如 Point * B8; 然后让每个指针指向堆空间上的一个对象：Bi = new Point ( ); 这时就可以调用有参构造函数来完成任务。,15,无参构造函数与对象数组,#include “iostream.h“ class Base public: Base(int i) cout“Base 类的构造函数被调用 ！“iendl; Base(Base / 请注意：该类没显式给出析构函数！,16,创建对象数组时，若用数组初始列表，则要调用拷贝构造函数,void main() Base a3=Base(100),Base(60),Base(80); ,17,其执行结果是： Base 类的构造函数被调用 ！ 100 Base 类的拷贝构造函数被调用 ！ Base 类的构造函数被调用 ！ 60 Base 类的拷贝构造函数被调用 ！ Base 类的构造函数被调用 ！ 80 Base 类的拷贝构造函数被调用 ！ 可见是：先调用构造函数，再调用拷贝构造函数，析构时无显示。,#include “iostream.h“ class Base public: Base(int i) cout“Base 类的构造函数被调用 ！“iendl; Base(Base ,18,/ 可是，若显式给出析构函数： Base() cout“Base 类的析构函数被调用 ！“endl; ,void main() Base a3=Base(100),Base(60),Base(80); ,19,则执行结果竟然是： Base 类的构造函数被调用 ！ 100 Base 类的构造函数被调用 ！ 60 Base 类的构造函数被调用 ！ 80 Base 类的析构函数被调用 ！ Base 类的析构函数被调用 ！ Base 类的析构函数被调用 ！ 这是为什么呢？,解释是： 临时对象被构造之后，直接用来初始化对象数组的元素，拷贝的步骤被省略掉了，然后调用析构函数，析构了临时对象。,关于内存地址/指向对象， /指向成员,内存空间的访问方式 通过变量名访问（直接访问） 通过地址访问（间接访问） 用指针访问 用引用访问 地址运算符： 则 式&var 表示变量var在内存中的起始地址。,指针变量的初始化,语法形式: 数据类型 *指针名初始地址； 例： int *pa= 注意事项: 用变量地址作为初值时，该变量必须在指针初始化之前已说明过，且变量类型应与指针类型一致。 可以用一个已赋初值的指针去初始化另一 个指针变量。 不要用一个内部 auto 变量去初始化 static 指针。,指 针,Why？,关于野指针,创建了但没有初始化的指针叫野指针。 野指针所指向的是非法内存，而不是NULL。 指针消亡了，并不表示其所指的内存定会被自动释放；反之，内存释放了，也不表示指针定会消亡或置NULL。 滋生野指针的环境： 创建了但没有初始化； 指针被free，但没有将指针改成NULL； 指针操作超过了变量的作用域。,指 针,指针变量的赋值运算,指针名=地址 存放地址的指针类型与数据的类型必须相符。 指针的类型是它所指向变量的类型，而不是指针本身的类型，任何一个指针本身的类型都是unsigned long int型。 允许声明 void 类型的指针。该指针可以被赋予任何类型对象的地址(万能型)。 例： void *general;,指 针,初始化与赋值的区别,注意: char *p = “China”; 不同于char *p; p = “China”; /用无名串的首址更改指针 前者叫初始化；后者叫赋值。 C语言编译器会让指针指向变量区的一个无名串，它是常串的替身。因为不可以对常量取址，所以不可用指针指向常串。“China”仅仅是初始化时的依据。 而C+语言是让指针指向一个常串，这一点与C语言不同。这种语法给人以假象：好像可以通过指针来修改 常串。这是C+不严密之处。,指 针,对于数组则不然：char A = “China”; 是用常量区的“China”为变量数组设定初值，数组是变量，而字符串是个常量。 再看下面的代码: const long a = 100; long *pa = (long *) 的解释。,指 针,可对指针变量赋值的表达式,向指针变量赋值必须是地址常量或地址变量，决不能是普通整数。有以下五种： & 对象（变量）名 数组名 指针名 函数名 NULL,指 针,指针变量的神通,只要能得到地址，指针就可以随意访问三个数据区的数据。虽然是局部指针，也能突破函数框架访问非本地数据。这种无法无天性是程序出错的根源之一。也是Java不使用指针的原因。 比如，C+竟然允许下式存在 ： 如 int *p = ( int *) 0x4567FFD0; int a = 4,b = 7; void main() int * p = ( int *) 0x4567FFD0; * p = 10; / 把全局变量a的值给改了。 cout aendl; /尽管可以达到修改目的， / 但这个程序不可移植，结果也不可重复。,指 针,例 指针的声明、赋值与使用,#include using namespace std; void main() int *i_pointer; /声明int型指针i_pointer int i=10; i_pointer= /输出int型指针所指地址的内容 ,程序运行的结果是： Output int i=10 Output int pointer i=10,void类型指针的使用,void vobject; /错，不能声明void类型的变量 void *pv; /对，可以声明void类型的指针 int *pint， i; void main() /void类型的函数没有返回值 pv = ,此表达式的作用是什么？,void类型指针的使用,void类型的指针(void * pv; )，是表示行为不确定的指针，但这不影响它已经被分配了空间，甚至得到了值别人的地址。 void类型的指针不能参与算术运算（如 +,-)，不能参与求值运算(*pv)，只能进行被赋值、比较、sizeof()操作。 当用void指针赋值给其他类型的指针时，需要强制类型转换。,指针与常量,指向常量的指针 const int a=99; const int * p = ,指 针,指向常量的指针,不能通过指针来改变所指对象的值，但指针本身可以改变，可以指向另外的对象。 “所指对象是常量，指针本身是变量。” 例1 没正确使用指针 ： char *name1 = “John“; /name1是一般指针 *name1=A; /编译通过，但运行出错，因为指的是常量 例2 正确使用了指针 ： const char *name1 = “John“; /指向常量的指针 char s=“abc“; name1=s; /正确，name1本身的值可以改变 *name1=1; /编译时能指出错误。,指 针,常指针,是指针类型的常量； 若声明指针为常量，则指针本身的值不能被改变，即该指针始终指向一个地方，不可改变。常用来作形参接受数组名实参，于是该指针便老老实实地指着该数组不变。这样指针便不可能丢失数组。 例： char *const name2 = “John“; name2=“abc“; /错误，指针常量值不能改变,请注意： 对于 “Hello”,C+视之为const *,而C却肆无忌惮地如此使用：char * a =“Hello”; C+为了兼容，也不得不宽容地接受了。但我们提倡这样使用： const char * p = “hello”; 而当这样使用时 char * q = “John”; 则意味着所指的是个变量数组。,指 针,指针的引用,是为指针声明了一个别名； 于是指针便可以在不同的场合叫不同的名字。譬如，形参和实参。 int *p; int *,int * p,int * &q,不可写为： int Why?,不可以求一个常量的地址。 对于 int * p = NULL; &p 是取指针的地址，此时它是个表达式，值是NULL,不再是个变量了。 对指针连续取址&p，可以视为求表达式的地址，那是个临时对象，所以错误。,指 针,对指针可以取址&p,但不可连续取址,访问数组元素的方法,设有一个int型数组a，有10个元素。可以用三种方法输出各元素： 使用数组名和下标； 使用数组名计算； 使用指针变量。,指 针,main() int a10; int i; for(i=0; iai; coutendl; for(i=0; i10; i+) coutai; ,访问数组元素（下标法）,38,main() int a10; int i; for(i=0; iai; coutendl; for(i=0; i10; i+) cout*(a+i); ,访问数组元素（计算法）,访问数组元素（指针法）,main() int a10; int i； for(i=0; iai; coutendl; for(int * p=a; p(a+10); p+) cout*p; ,指针与数组的相通之处,int a10; 等价于 int * const a; int b89; 等价于 int (* const b ) 9; int c456; 等价于 int (* const c ) 56; . 由此可以得出结论： 指针已经暗含了一维数组。,指针与数组的区别,数组名是静态的，一旦定义，其值就固定不变了。而指针是动态的，可随时变化。 数组名是常量，不可作为算术运算的左值；指针是变量，可作为算术运算的左值。 在访问速度上，用数组表达式慢，用指针快 。 指针比数组有更大的灵活性。如： char a10 20; /这是个固定了行和列的矩阵。而声明了char * b10; 则得到有10行但每行可长短不等的锯齿状数组。 数组有更好的可读性，可随机访问各元素；指针可读性差，更适合顺序访问。,指 针,指针数组,数组的元素是指针型; 例：int *pa2; 由pa0,pa1两个指针组成, 这两个指针是指向int 类型的变量。 当然，指针数组元素可以指向某类型的对象。,指 针,例 利用指针数组存放单位矩阵,#include using namespace std; void main() int line1=1,0,0; /声明数组，矩阵的第一行 int line2=0,1,0; /声明数组，矩阵的第二行 int line3=0,0,1; /声明数组，矩阵的第三行 int *p_line3; /声明整型指针数组 p_line0=line1; /对指针数组元素赋初值 p_line1=line2; p_line2=line3;,指 针,/输出单位矩阵 cout“Matrix test:“endl; for(int i=0;i3;i+) /对矩阵每一行循环 for(int j=0;j3;j+) /对数组元素循环 coutp_lineij“ “; coutendl; ,输出结果为： Matrix test: 1 0 0 0 1 0 0 0 1,45,明明是一维的指针数组，竟当作二维数组用,例 二维数组举例,#include using namespace std; void main() int array223=11,12,13,21,22,23; for(int i=0;i2;i+) cout*(array2+i)endl; for(int j=0;j3;j+) cout*(*(array2+i)+j)“, “; /或者 coutarray2ij“ “; coutendl; ,指 针,在某次运行之后， 程序的输出结果为： 0X 0065 FDE0 11,12,13 0X 0065 FDEC 21,22,23,指针作为函数参数,以地址方式传递数据，可以用来将函数处理结果“传回”给主调函数。 实参是数组名时形参可以是指针。 形参写成数组名，其实质是指针。,指针与函数,例 输出数组元素的内容和地址,#include #include using namespace std; void Array_Ptr(long *P, int n) int i; cout “In func, address of array is ” /显示形参数组地址 unsigned long(P) endl; cout “Accessing array in the function using pointers“ endl; for (i = 0; i n; i+) cout “ Address for index “ i “ is “ unsigned long(P+i); /输出数组元素的地址 cout “ Value is “ *(P+i) /输出数组元素的内容 endl; ,void main(void) long list5 = 50, 60, 70, 80, 90; /显示实参数组地址 cout “In main, address of array is “ unsigned long(list) endl; cout endl; Array_Ptr(list,5); ,运行结果： In main, address of array is 6684132 In func, address of array is 6684132 Accessing array in the function using pointers Address for index 0 is 6684132 Value is 50 Address for index 1 is 6684136 Value is 60 Address for index 2 is 6684140 Value is 70 Address for index 3 is 6684144 Value is 80 Address for index 4 is 6684148 Value is 90,可见作为实参、形参的数组是同一个,指向常量的指针做形参,#include using namespace std; const int N=6; void print(const int *p,int n); void main() int arrayN; for(int i=0;iarrayi; print(array,N); ,void print(const int *p, int n) cout“*p; for(int i=1;in;i+) cout“.“*(p+i); cout“endl; ,void GetMemory(char *P, int num) P = (char *) malloc(sizeof(char)*num); void main() char * str = NULL; GetMemory ( str , 100 ) ;/指针str并没得到P所申请的空间 strcpy(str , “ hello”); /将hello拷贝到NULL中, 错！ ,指针作函数参数的陷阱,void GetMemory2(char *P, int num) *P = (char *) malloc(sizeof(char)*num); void main() char * str = NULL; GetMemory2 ( ,解决办法之一：,解决办法之二：,char * GetMemory3( int num) char * p = (char *) malloc(sizeof(char)*num); return p; void main() char * str = NULL; str = GetMemory3 ( 100 ) ; strcpy(str , “ hello”); cout str endl; free (str) ; ,问： 是否还有另外的解决办法？,函数返回了栈内存的错误,char * GetString( void ) /用static区的字符串常量来初始化stack区的数组char p = “ hello world”; return p; /编译器将发出警告 void main() char * str = NULL; str = GetString ( ) ; /str得到的是垃圾 cout str endl; ,改进：,const char * GetString2( void ) /用static区的字符串常量来初始化stack区的指针const char * p = “ hello world”; return p; /编译器将发出警告 void main() /str得到的是常量串 const char * str = GetString ( ) ; cout str endl; ,指针型函数,当函数的返回值是地址时，该函数就叫指针型函数，又叫返回指针的函数。 声明形式： 数据类型 * 函数名( ),指针与函数,指针型函数的使用（串连接） #include char *my_cat(char *p1,char *p2) static char a160,*p; p=a; while (*p1!=0) *p+=*p1+; while (*p2!=0) *p+=*p2+;两个串连上 *p=*p2;/添加“0”; return a; ,57,void main() char s180,s280; printf(“n请输入第一串字符 : “); scanf(“%s“,s1); printf(“n请输入第二串字符 : “); scanf(“%s“,s2); printf(“n连接结果 : n“); printf(“n 第一串在前第二串在后 : %sn“,my_cat(s1,s2); printf(“n 第二串在前第一串在后 : %sn“,my_cat(s2,s1); printf(“nn“); / 两次调用my_cat()用同一个空间。在静态区域只有一次初始化。static char a160,58,在某次运行之后，程序的输出结果为： 请输入第一串字符 : This is 请输入第二串字符 : a function. 连接结果 : 第一串在前第二串在后 : This is a function. 第二串在前第一串在后 : a function. This is,59,为函数参数传什么?,奉劝各位，尽量使用传址，少用传值。 理由很简单：首先，传值成本太高（要调用拷贝构造函数及析构函数）。 其次，传值还会使函数的返回通道狭窄，不便于传回多个结果。 指针（或引用）做参数则可传回多个结果。 但是若返回一个局部对象的引用或首址则是致命错误。因为运行栈已释放。,指针与函数,声明形式 数据类型 (*函数指针名)( 形参表 ); 含义： 数据指针指向的是数据存储区；而函数指针指向的是程序代码存储区。函数名就是地址。,指向函数的指针,指针与函数,例： int fun(int , float ); int (*pa)(int , float );,例 指向函数的指针,#include using namespace std; void print_stuff(float data_to_ignore); void print_message(float list_this_data); void print_float(float data_to_print); void (*function_pointer)(float); void main() float pi = (float)3.14159; float two_pi = (float)2.0 * pi;,指针与函数,print_stuff(pi); function_pointer = print_stuff; function_pointer(pi); function_pointer = print_message; function_pointer(two_pi); function_pointer(13.0); function_pointer = print_float; function_pointer(pi); print_float(pi); ,63,指向函数的指针图示,function_pointer,print_stuff,print_message,print_float,其他函数,code区,stack,void print_stuff(float data_to_ignore) cout“This is the print stuff function.n“; void print_message(float list_this_data) cout“The data to be listed is “ list_this_dataendl; void print_float(float data_to_print) cout“The data to be printed is “ data_to_printendl; ,65,运行结果： This is the print stuff function. This is the print stuff function. The data to be listed is 6.283180 The data to be listed is 13.000000 The data to be printed is 3.141590 The data to be printed is 3.141590,66,指向函数的指针可组成数组。 声明形式 数据类型 (*函数指针名 )( 形参表 );,指向函数的指针数组,指针与函数,例： int fun1(int , float ); int fun2(int , float ); int (*pa2)(int , float );,#include #include using namespace std; int add (int x,int y) coutx“ + “y“ = “; return x+y; /定义函数add int sub (int x,int y) coutx“ - “y“ = “; return x-y; /定义函数sub int mult (int x,int y) coutx“ * “y“ = “; return x*y; /定义函数mult int dev (int x,int y) coutx“ / “y“ = “; return x/y; /定义函数dev void DispResult(int a, int b, int (*fun)(int,int) coutfun(a,b)endl; ,68,void main() /定义了一个函数指针数组，并初始化 int (*funp4)(int,int)=add,sub,mult,dev; char op; int a,b; coutaopb; switch(op) case +: DispResult(a,b,funp0); break;/调用函数add case -: DispResult(a,b,funp1); break; /调用函数sub case *: DispResult(a,b,funp2); break; /调用函数mult case /: DispResult(a,b,funp3); break; /调用函数dev default: cout“Operator is illegal;n“; ,69,对象指针的一般概念,概念 指针变量存放了对象的首址。 声明形式 类名 * 对象指针名； 例 Point A(5,10); Point *ptr = 通过指针访问对象成员 对象指针名-公有成员名 例 ptr-getx() 相当于 (*ptr).getx(),指 针,对象指针的图示,Point,B,A,. .,对象指针应用举例,void main() Point A(5,10); Point *ptr = ,指 针,this指针:My self,是隐含于类中的每一个非静态成员函数中的特殊指针。意即 My self。 它明确地指出了成员函数当前所操作的数据所属的对象。 例如：Point类的构造函数如下： Point : Point( int xx, int yy) X=xx; Y=yy; ,指 针,this指针,若将隐含的this还其本来面目，则是： Point : Point(Point * this, int xx, int yy) this-X=xx; this-Y=yy; (this是隐藏于所有非静态成员函数的第一个形参.) 若成员函数是常成员函数，则const 修饰的是this指针指向常量的指针。,指 针,使用this指针,#include #include using namespace std; class Time int hour; int minute; int second; public: Time( int hr= 0, int min= 0, int sec= 0 ) / 带默认值构造函数 setTime( hr, min, sec ); / 调用成员函数 Time ,因为是分别设置，故没有进位。,Time ,void main() Time t; t.setHour( 18 ).setMinute( 30 ).setSecond( 22 ); cout “Universal time: “; t.DispUniversal(); cout “nStandard time: “; t.DispStandard(); cout “nNew standard time: “; t.setTime( 20, 20, 20 ).DispStandard(); ,对 t 对象设置时、分、秒。用的手法是成员函数的连续调用。 使用的语句更节省。,this指针,当通过一个对象调用非静态成员函数时，系统先将该对象的地址赋给函数的this指针，然后调用成员函数，成员函数对对象的数据成员进行操作时，就隐含使用了this指针。 this指针也不是万般皆好，也有助纣为虐的时候。请看下例：,指 针,class A public: void Func(void) cout Func(); / p已是“野指针”了，可居然还 能调用成员函数 ! ? Why ? ,指 针,离开此作用域，局部对象a已经释放。可已存于指针p中的a的首址尚在p手中没丢，p-Func(); 时仍能完成this = p;就如同a.Func();时能完成this = 一样。,指针的两个层次：对象、成员,Point,B,A,Point * ptr,int Point: *mp,X,. .,关于指向类中成员的指针,应当知道，指向成员的指针名曰指针，实则非也，它是个偏移量，记录着该成员距离对象的首址的距离。故定义它时，总要前缀着类名 （类名:）,以便于编译器识别后予以特别处理。 比如，某个类有个int 型的数据成员，于是可 int Point: *mp = 此时mp可当作指针使用，但它并不存放地址，甚至不可显示。,指 针,为何说指向类成员的指针是偏移量,class Point3d . public : float x,y,z; ; Point3d P; 于是应有如下等式关系： &P.z = &P + &Point3d:z,已分配在内存中的对象P的数据成员z的真实地址,数据成员z在类（对象）中的偏移量,对象P的首址,声明指向类的非静态成员的指针,通过指向成员的指针只能访问公有成员 声明指向成员的指针 声明指向公有数据成员的指针 类型说明符 类名:*指针名； 声明指向公有函数成员的指针 类型说明符 (类名:*指针名)(参数表)；,指 针,使用指向数据成员的指针,对指向数据成员的指针赋值： 说明指针应该指向哪个成员 指针名=&类名:数据成员名； 使用指向数据成员的指针： 通过对象名（或对象指针）与成员指针联手来访问数据成员 对象名.* 类成员指针名 或： 对象指针名*类成员指针名,指 针,使用指向函数成员的指针,指向函数成员的指针 赋值 指针名=类名:函数成员名； 通过对象名（或对象指针）与成员指针结合来访问函数成员 (对象名.* 类成员指针名)(参数表) 或： (对象指针名*类成员指针名)(参数表),指 针,指向类的非静态成员的指针,例6-13 访问对象的公有成员函数的不同方式 void main() /主函数 Point A(4,5); /声明对象A Point *p1= ,指 针,小结： 对于对象成员的访问方式,（八种）： 对象名. 公有成员 类：静态公有成员 对象指针名 公有成员 对象名 .* 数据成员指针名 对象指针名 * 数据成员指针名 (对象名 .* 函数成员指针名)(参数表) (对象指针名 * 函数成员指针名)(参数表) 对象名.类名: 被隐藏的公有成员,指 针,指向类的静态成员的指针,对类的静态成员的访问不依赖于对象 可以用普通的指针来指向和访问静态成员 例6-14 通过指针访问类的静态数据成员 例6-15 通过指针访问类的静态函数成员,指 针,例 通过指针访问类的静态数据成员,#include using namespace std; class Point /Point类声明 public: /外部接口 Point(int xx=0, int yy=0) X=xx;Y=yy;countP+; /构造函数 Point(Point /静态数据成员定义性说明,指 针,void main() /主函数 /声明一个int型指针，指向类的静态成员 int *count= ,90,例 通过指针访问类的静态函数成员,#include using namespace std; class Point /Point类声明 public: /外部接口 /其它函数略 static void GetC() /静态函数成员 cout“ Object id=“countPendl; private: /私有数据成员 int X,Y; static int countP; /静态数据成员引用性说明 ; / 函数实现略 int Point:countP=0; /静态数据成员定义性说明,指 针,void main() /主函数 /指向类的静态成员函数的指针， void (*gc)()=Point:GetC; Point A(4,5); /定义对象A cout“Point A,“A.GetX()“,“A.GetY(); gc(); /通过指针访问静态函数成员，输出对象序号 Point B(A); /定义对象B cout“Point B,“B.GetX()“,“B.GetY(); gc(); /通过指针访问静态函数成员 ,92,指针会破坏类的私密性,class address . ; / 某人居住在此 class person public: address * personaddress() return ,私有的数据被挖了出来。这叫“走私”。,不但对数据成员，连函数成员也无一幸免,class person; / 前置声明 / ppmf 是指向person成员函数的指针 typedef void (person:*ppmf)(); class person public: static ppmf verificationfunction() return / 等同于调用scott.verifyaddress,私有的函数名被拿走了,引用也能达此目的,class address . ; / 某人居住在此 class person public: address,凡此种种，说明了私有成员也并非放进了保险箱，除了友元，指针和引用都能使它们被挖了出来。不过主动权还在类的设计者手中。,动态申请内存操作符 new,指针 = new 类型名T（初值列表） 功能：在程序执行期间，在堆区申请用于存放T类型对象的内存空间，并依照初值列表赋以初值。 结果值：成功：T类型的指针，指向新分配的内存；失败：指针得0（NULL） 注意：new内置了sizeof、类型转换、类型安全检查。并在创建对象时完成初始化工作。,动态存储分配,释放内存操作符delete,delete 指针P 功能：释放指针P所指向的内存。P必须是new操作的返回值， 即delete必须与 new操作相呼应，一一对应。,动态存储分配,对象的动态创建与释放,/设Tdate是已存在的类 void fn() Tdate *pS; / pS仅仅是个指针，没有指向对象 Tdate ob; /在栈区定义对象 pS=new Tdate; /分配堆空间并构造又一对象 delete pS; /析构了无名对象 /析构ob对象,例 动态创建对象举例,#include using namespace std; class Point public: Point() X=Y=0; cout“Default Constructor called.n“; Point(int xx,int yy) X=xx; Y=yy; cout “Constructor called.n“; Point() cout“Destructor called.n“; int GetX() return X; int GetY() return Y; void Move(int x,int y) X=x; Y=y; private: int X,Y; ;,动态存储分配,void main() coutgetX()getY()endl; delete Ptr1; cout“Step Two:“endl; Point ,运行结果： Step One: Default Constructor called. 0,0 Destructor called. Step Two: Constructor called. 2,3 Destructor