类和对象(二)

1、l指向数据成员的指针格式如下： :* l指向成员函数的指针格式如下： (:*)() class A public: int fun (int b) return a * c + b; A(int i) a = i; int c; private: int a; 定义一个指向类A的数据成员c的指针pc，其格式如下： int A:*pc = &A:c; 定义一个指向类A的成员函数fun的指针pfun,其格式如下： int (A:*pfun)(int)=A:fun; 给pc指针所指向的数据成员c赋值8，可以表示如下： A a; a.*pc = 8; 使用指向对象的指针来对指向类成员的指针进行

2、操作： A *p = &a; p- *pc = 8;l一般函数指针的定义： (*)()l函数指针的赋值格式： = l函数指针的调用格式： (*)()include class A public: A(int i)a = i; int fun(int b)return a * c + b； int c; private: int a;void main() A x(8); / x.a = 8 int A:*pc; / 指向整数的指针 pc = &A:c; / 指向 c x.*pc = 3; / x.c = 3 int (A:*pfun)(int); / 指向函数的指针 pfun

3、= A:fun; A *p = &x; / 指向对象的指针 cout *pfun)(5) endl; / a*c+b = 8*3+5 = 29Ans:29l实现传址调用，可在被调用函数中改变调用函数的参数对象的值，实现函数之间的信息传递l使用对象指针实参仅将对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。 #include class M public: M()x = y = 0; M(int i,int j)x = i, y = j; void copy(M *m); void setxy(int i,int j)x = i;y = j; void pr

4、int()cout x . y x; y = m-y;void fun(M m1, M *m2);void main() M p(5, 7), q； q.copy(&p); / q.x = 5, q.y = 7 fun(p, &q); / m1 p : 5,7 m2q : 22,25 p.print(); q.print();void fun(M m1, M *m2) m1,setxy(12, 15); m2-setxy(22, 25);5, 722, 25#include class M public: M()x = y = 0; M(int i, int j)x = i;

5、y = j; void copy(M &m); void setxy(int i, int j)x = i ; y = j; void print()cout x , y x; y = m-y;void fun(M m1, M &m2);void main() M p(5, 7),q； q.copy(p); fun(p, q); p.print(); q.print();void fun(M m1, M &m2) m1,setxy(12, 15); m2-setxy(22, 25);lthis是一个隐含于每一个类的成员函数中的特殊的指针 l该指针是一个指向正在被某个成员

6、函数操作的对象的指针 l当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数 #include class A public: A()a = b = 0; A(int i,int j)a = i; b = j; void copy(A &aa); void print()cout a , b endl; private: int a,b;void A:copy(A &aa) if (this = &aa) return; *this = aa;void main() A a1, a2(3, 4); a1.copy(a2); a1.prin

7、t();Ans:3，4 对象数组是指数组元素为对象的数组l对象数组的定义格式 . 例如： DATE dates7 DATE dates235l对象数组的赋值class DATEpublic: DATE(int m,int d,int y); void print();private:int month,day,year;DATE dates4=DATE(7,22,1998), DATE(7,23,1998), DATE(7,24,1998), DATE(7,25,1998)或者 dates0=DATE(7,22,1998); dates1=DATE(7,23,1998); dates2=DAT

8、E(7,24,1998); dates3=DATE(7,25,1998);include class DATEpublic:DATE( )month = day = year = 0;DATE(int m, int d, int y)month = m;day = d;year = y;void print()cout Month= month ,day= day ,year= year endl; private:int month, day, year;void main() DATE dates5=DATE(7, 22, 1998), DATE(7, 23, 1998), DATE(7,

9、 24, 1998); dates3=DATE(7, 25, 1998); dates4=DATE(7, 26, 1998); for(int i=0; i5; i+)datesi.print();Ans：Month=7, Day=22, Year=1998Month=7, Day=23, Year=1998Month=7, Day=24, Year=1998Month=7, Day=25, Year=1998 Month=7, Day=26, Year=1998 指向一般数组的指针定义格式如下： (*)例如： int (*p)3; 指向对象数组的指针定义格式如下： (*PL)4；includ

10、e int a3=1,2,3,4,5,6,7,8,9;void main() int (*pa)3(a); / 同 int (*pa)3;pa = a; for(int i=0;i3;i+) cout n; for(int j=o;j3;j+) cout *(*(pa+i)+j) ; cout n;1 2 34 5 67 8 9#include class M public: M()a = b = 0; M(int i,int j)a = i; b = j; void print()cout a . b endl; private: int a,b;void main() M m24; int

11、 x = 10, y = 20; for(int i=0; i2; i+) for(int j=0; j4; j+) mij=M(x += 2, y += 10); M(*pm)4(m); for(int i=0; i2; i+) cout endl; for(int j=0; j4; j+) (*(*(pm+i)+j).print(); cout endl;12.20 14.30 16.40 18.50 20.60 22.70 24.80 26.90 l指针数组指的是数组元素为指针的那类数组 l数组的元素可以是指向同一类型的一般指针,也可以是指向同一类类型的对象 l一般指针数组的格式如下：

12、*.l例 int *pa3; char *pc25; pa是一维指针数组名，该数组有3个元素是一个int 型指针。pc是二维指针数组名，该数组有10个元素，每一个元素是char型指针 #include #include const int N = 5;void main ( ) char *stringsN; char str80; cout At each prompt, enter a string:n; for(int i=0; iN; i+) cout Enter a string # i :; cin.getline(str, sizeof(str); stringsi = new

13、charstrlen(str) + 1; strcpy(stringsi, str); cout endl; for(i=0; iN; i+) cout String # i : stringi endl;At each prompt, enter a string:Enter a string # 0: abcdeEnter a string # 1: fghijEnter a string # 2: klmnoEnter a string # 3: pqrstEnter a string # 4: uvwxy输出结果如下：String # 0: abcdeString # 1: fghij

14、String # 2: klmnoString # 3: pqrstString # 4: uvwxyl对象指针数组是指该数组的元素是指向对象的指针l要求所有数组元素都是指向同一个类类型的对象的指针l其格式如下： *.#include class A public: A(int i=0, int j=0) a = i; b = j; void print ( ); private: int a, b;void A:print( ) cout a , b endl;void main( ) A a1(7, 8), a2, a3(5, 7); A * b3 = &a3, &a2,

15、&a1; for(int i=0; iprint( );Ans：5, 70, 07, 8l带有参数的 main( )函数的格式如下： void main(int argc, char *argv )l第一个参数argc是 int 型的，它用来存放命令行参数的个数l第二个参数argv是一个一维的指针数组 argv0存放命令字 argv1存放命令行中第一个参数 argv2存放命令行中第二个参数.#include void main(int argc, char * argv ) cout The number of command line arguments is argc endl;

16、cout The program name is argv0 1) cout The command line arguments:n; for(int i=1;iargc;i+) cout argvi endl; Test prog1 prog2 prog3 prog4 则输出结果如下：The number of command line arguments is 5The program name is test.exeThe command line arguments:prog1prog2prog3prog4l常类型是指使用类型修饰符const说明的类型l常类型的变量或对象的值是不能被

17、更新的 l定义或说明常类型时必须进行初始化 l修饰符const可以用在类型说明符前，也可以用在类型说明符后 int const x = 2； 与 const int x = 2；是一样的l定义或说明一个常数组可采用如下的形式： const 或者 const 例如： int const a5= 1， 2， 3， 4， 5； 说明数组a的各个元素是int型常量，即数组元素的值是不能被更新的l常对象是指对象常量，定义格式如下： const l例如：class A public： A（int i，int j）x = i；y = j； private： int x，y；const A a1(3，4）；A

18、 const a2(8，19）； 其中，a1和a2都是常对象，它们不能被更新 使用const修饰指针时，由于const的位置不同，而含义不同l指针常量：内容可变，不可指向其他 char * const ptr1 = stringptr1； ptr1 = stringptr2； 非法 * ptr1 = m； 合法l常量指针: 内容不变，可指向其他 const char * ptr2 = stringptr1； * ptr2 = x； 非法 ptr2 = stringptr2； 合法l使用 const 修饰符说明的引用为常引用l常引用对象不能被更新，其定义格式如下： const & 例如:

19、 const double & v 其中，v是一个引用，它所引用的对象不会被更新l在实际应用中，常指针和常引用往往用来做函数的形参，这样的参数称为常参数l使用常参数，该函数不会更新参数所指向或所引用的对象，在参数传递过程不需要执行拷贝初始化构造函数，改善运行效率 #include const int N = 6;void print(const int * p, int n); / 常指针,内容不变void main( ) int arrayN; for(int i=0; i arrayi; print(array, N);void print(const int * p, int n

20、) cout * p; for(int i=1; in; i+) cout , *(p+i); cout endl;执行该程序输入如下信息：1 2 3 4 5 6 输出结果如下：1，2，3，4，5，6#include class K public: K(int i)k = i; /常成员函数，有资格操作常量 int serk( ) constreturn k; private: int k;int add(const K & g1, const K & g2);void main() K k1(8), k2(17); int s = add(k1, k2); cout s en

21、dl;int add(const K & g1, const K & g2) int sum = g1.serk( ) + g2.serk( ); return sum;Ans:2525l使用const关键字进行说明的成员函数，称为常成员函数l只有常成员函数才有资格操作常量或常对象 l类K的成员函数 setk( )被说明为常成员函数。因此，它有资格对常引用 g1 和 g2 进行操作 int sum = g1.serk( ) + g2.serk( );l常成员函数说明格式如下： () const;#include class R public: R(int r1, int r2)

22、R1 = r1; R2 = r2; void print( )； void print( ) const; private: int R1,R2;void R:print( ) cout R1 : R2 endl;void R:print( ) const cout R1 ; R2 endl;void main( ) R a(5, 4); a.print( ); const R b(20, 52); b.print( );Ans：5 : 420 ; 52 l类型修饰符 const 可以说明数据成员lconst类型对象必须被初始化，并且不能更新lconst数据成员只能通过成员初始化列表的方式，来

23、生成构造函数对数据成员初始化#include class A public: A (int i); void print( ); const int & r; private: const int a; static const int b;const int A:b = 10;A:A(int i) : a(i), r(a) / 常数 a = i = 100 常引用 r = a = i = 100 / 0 0void A:print( ) cout a : b : r endl;void main( ) A a1(100), a2(0); a1.print( ); a2.print(

24、);100：10：1000：10：0 l当一个类的成员是某个类的对象时。该对象就为子对象l子对象实际上就是对象成员l子对象通过采用成员初始化表的方法来初始化对象l该类的构造函数要包含对子对象的初始化l在成员初始化表中包含对子对象的初始化和对类中其他成员的初始化 例：B类中成员a是子对象，A类的对象作为B类的成员class A public: private:;class B public: private: A a;#include class A public: A(int i, int j)A1 = i; A1 = j; void print( )cout A1 , A2 endl; pr

25、ivate: int A1, A2;class B public: B(int i, int j, int k) : a(i, j), b(k) void print( ); private: A a; int b;void B:print( ) a.print( ); cout b endl;void main( ) B b(6, 7, 8); b.print( );6，78l堆对象是在程序运行过程中根据需要随时可以建立或删除的对象l堆对象被创建在内存一些空闲的存储单元中，这些存储单元被称为堆l创建和删除堆对象： new / c: malloc( ) 程序区 delete / c: free

26、( ) 静态存储 堆 动态区 栈 l new () 给出被创建对象的初始值, 如果省去括号和括号中的初始值，用缺省值l用 sizeof 来可以计算其大小lnew 运算符返回一个指针l如果 new 运算符不能分配到所需要的内存，它将返回0，这时的指针为空指针l创建对象数组的格式如下： new 例如： A *ptr； ptr = new A5；l使用new 创建的数组时，不能为该数组指定初始值，其初始值为缺省值。l删除使用 new 创建的对象或一般类型的指针: delete A *ptr; ptr = new A(5,6); delete ptr;l删除使用 new 创建对象数组: delete

27、A *ptr; ptr = new A5; delete ptr; 又：int *p; p = new int10; delete p;l必须使用于由运算符new返回的指针l也适用于空指针（即其值为0的指针）； l对一个指针只能使用一次delete操作l指针名只能用一对方括号符，并且不管所删除数组的维数，忽略方括号内的任何数据。 #include class AA public: AA(int i, int j) A = i; B = j; cout Constructor.n; AA( )cout Destructor.n; void print( ); private: int A, B;

28、void AA:print( ) cout A , B endl;void main( ) AA a1, a2; a1 = new AA(1, 2); / if(!a1) a2 = new AA(5, 6); / coutprint( ); a2-print( ); delete a1; delete a2;Constructor.Constructor.1, 25, 6Destrutor.Destrutor.#include #include class B public: B(char *s, double n) strcpy(name, s); b = n; cout Construct

29、or.n; B( )cout Defaultn; B( )cout Destructor name endl; void getb(char *s, double& n) strcpy(s, name); n = b; private: char name80; double b;void main( ) B *p; double n; char s80; p = new B3; p0 = B(ma, 4.8); p1 = B(wang, 3.6); p2 = B(li, 3.1); for(int i=0; i3; i+) pi.getb(s, n); cout s , n endl

30、; delete p;DefaultDefaultDefaultConstructor / 建立匿名对象Destructor maConstructorDestructor wang ConstructorDestructor lima, 4.8wang, 3.6li, 3.1Destructor liDestructor wangDestructor ma#include #include void fun( ) int *p; if(p = new int) *p = 5; cout *p endl; delete p; else cout Heap error!n;void main( ) fun( ); int *pa; pa = new int5; if(!pa) cout Heap error!n; exit(1); for(int i=0; i5; i+) pai = i+1; for(i=0; i5; i+) cout pai ; cout endl; delete pa;51 2 3 4 5l类型转换时将一种类型的值映射为另一种类型的值l类型转换包含有自动隐含的