MC LC Li ni u 4 Chng 1: M u .......................................................................................... 6 1.1. So snh gia lp trnh hng i tng v lp trnh hng th tc6 1.1.1. .................................................................................

Lp trnh hng th tc 6 1.1.2. ............................................................................ Lp trnh hng i tng 7 1.2. Gii thiu ngn ng C++...............................................................................................8 1.2.1. .................................................................. Ch thch trong C v trong C++ 1.2.2. ...............................................................................................Cc t kha mi 1.2.3. ........................................................................... Php chuyn kiu bt buc 1.2.4. ................................................................................................... Khai bo bin 1.2.5. .......................................................................................................... Hm main 1.2.6. ............................................................................... Truyn tham s cho hm 1.2.7. ................................................................................. Nhc li v bin con tr 1.2.8. ........................................ S dng tham s truyn ngm nh trong hm 1.2.9. .................................................................... Cp pht v gii phng b nh 1.2.10. Cc hm ti bi (Overloaded function) .........................................17 1.2.11. Hm inline.............................................................................................18 1.2.12. Kh nng vo ra mi ca C++ .........................................................21 1.3. Bi tp chng 1 ...............................................................................................................23
8 8 8 8 9 10 13 15 16

Chng 2: Lp cc i tng ..................................................................... 27 2.1. Lp cc i tng ............................................................................................................27 2.1.1. ..................................................................................... Cc khi nim c bn 2.1.2. ........................................................................... Khai bo lp cc i tng 2.1.3. ........ Cc thnh phn trong lp (Data member and function member) 2.1.4. ............................................................... i tng trong tham s ca hm
27 27 31 42

2.2. Constructor v destructor ..........................................................................................44 2.2.1. ............................................................................................. Khi nim chung 44 2.2.2. ...................................Khai bo v nh ngha constructor v destructor 44 2.2.3. ........................................................................................................Con tr this 46 2.3. Ton t ti bi v ton t ti bi thn thin..................................................48 1

Nguyn Ch Trung 2.3.1. ............................................................................................... Khi qut chung 2.3.2. .................................................................................................. Ton t ti bi 2.3.3. .............................................................................. Ton t ti bi thn thin 2.3.4. ..............................................................................................Chuyn i kiu
48 48 52 59

2.4. Vi vn v s dng t kho const ...................................................................66 2.4.1. .................................................................................S dng bin kiu const 66 2.4.2. ........................................................... Truyn tham s kiu const cho hm 67 2.4.3. ................................................................................. i tng hng ca lp 68 2.4.4.Hm thnh phn const (hm thnh phn c khai bo const pha sau) 70 2.4.5.Con tr this kiu const (hm thnh phn c khai bo const pha trc)
72

2.4.6. .................................................................................... Nghin cu lp String 73 2.4.7. ......................................................................... c thm v lp cc dy bit 78 2.5. Bi tp chng 2 ...............................................................................................................81

Chng 3: S k tha ................................................................................. 84 3.1. S tng ng trong k tha ......................................................................................84 3.1.1. ............................................................................................. Khi nim chung 3.1.2. ...................................................................................................... K tha n 3.1.3. ........................................................... Thnh phn protected trong k tha 3.1.4. ................................................................................................ K tha a mc 3.1.5. ............................................................................................. K tha phn cp 3.1.6. ........................................................................................................ K tha bi 3.1.7. .................................................................................... K tha kp (lai ghp) 3.1.8. ............................................................... Constructor trong cc lp k tha
84 86 88 92 93 94 95 99

3.2. Con tr xc nh thnh phn ca lp v con tr xc nh i tng 102 3.2.1. .................................................................... Cc quy tc c php v con tr 102 3.2.2.Cc v d minh ho cch s dng con tr xc nh i tng v thnh phn (d liu v hm) ca lp ..........................................................................103 3.2.3. ........................................................................... Con tr xc nh i tng 105 3.3. Hm o v tng ng bi trong k tha .......................................................106 3.3.1. ................................................ Cc hm dch chuyn (Override function) 106 3.3.2. ................................. Con tr xc nh i tng trong quan h k tha 107 2

Nguyn Ch Trung 3.3.3. ................................................................Con tr hm o v tng ng bi 3.3.4. ................................................................. K tha lai ghp v lp c s o 3.3.5. .............................................................................Hm rng (Null Function) 3.3.6. .. Hm o thc s v lp tru tng (pure function & abstract class) 3.3.7. .......................................... Hm thn thin o v ton t o dch chuyn 3.4. Bi tp chng 3 .............................................................................................................116
108 111 114 115 116

Chng 4: Lm vic vi Tp ..................................................................... 120 4.1. Cc Thao tc c bn vi tp...................................................................................120 4.1.1. ............................................................................................ c d liu t tp 120 4.1.2. .......................................................................................... Ghi d liu vo tp 122 4.2. Mt s vn khc lm vic vi tp ..................................................................125 4.2.1. ............................................................................................ M tp bng open 125 4.2.2. .......................................................................... Cc ch lm vic vi tp 125 4.2.3. ..................................................................................... c/ ghi tp nh phn 126 4.3. Bi tp chng 4 .............................................................................................................128

Ph lc 1: Lp mu v hm mu .............................................................. 130 Khi qut ................................................................................................................130 4.3.2. ........................................................................................................... Hm mu 130 4.3.3. ............................................................................................................. Lp mu 132 Ph lc 2: Gii thiu Mt s bi ton phn tch thit k hng i tng trn C++ .................................................................................... 137 4.3.1. .............................................................................. S lc 5 bc thc hin 137 4.3.2. ...................................................................... Xy dng lp hnh hc phng 137 4.3.3. ............................................................................................ Qun l cc l t 146 Ti liu tham kho ....................................................................................... 153

Nguyn Ch Trung LI NI U Lp trnh trn ngn ng C l mt mt v d v phng php tip cn lp trnh hng chc nng. Phng php ny tp trung vo thut ton chnh gii quyt bi ton t ra v c th phi phn r bi ton xut pht ny thnh cc bi ton con nh hn. Vic tm thut ton cho tng bi ton con thm ch li phi tip tc chia thnh cc bi ton con nh hn na v qu trnh l qu trnh lm mn dn, c ngha l vic phn chia thnh cc bi ton con s dng li cho n khi thu c tp cc bi ton con n gin nht, c th tm ngay ra li gii. Khi xy dng cc phn mm ln, phng php lp trnh hng chc nng gp kh khn trong vic cp nht v sa i, c ngha l vic thay i mt phn chc nng v d liu trong chng trnh c th lm nh hng n ton b h thng v mt nhiu cng sc iu chnh. Cn phi c mt hng tip cn khc trong lp trnh hn ch c nhng nhc im ca lp trnh truyn thng: trc tin phi ch trng n nhng i tng xut hin trong bi ton, tm cch c t i tng (gm thng tin v hnh vi) sao cho ph hp vi th gii thc. C ngha l thay v quan tm n chc nng, nhim v t ra, k thut lp trnh mi s t trng tm vo vic x l cc d liu thc hin cc chc nng . K thut lp trnh mi ny mang tn l k thut lp trnh hng i tng (Object Oriented Programing) v trn k thut ny nhiu trnh bin dch c thit k, trong c C++. Vic s dng C++ bao gm nhng thun li v nhng kh khn. Lp cc i tng ca C++ cho php ci t ring r giao din (interface) v th hin (implementation) v c th n vic th hin chi tit bn trong. R rng C++ h tr khi nim tru tng cng ging nh l mt s ngn ng khc h tr n c bit nh l Pascal, C . S thun li ca C++ l C++ c th s dng rng ri trong nhiu ngnh ngh, hc sinh c th nm bt c cc k nng l thuyt cng nh thc hnh v iu ny gip h c th tm kim vic lm d dng. Nhng s kh khn ca C++ l n khc xa ngn ng s phm v v vy cn phi ch v mt thc hnh c th t c k nng lp trnh nht nh. iu khng thun li th hai l C++ vn khng phi l ngn ng c nh v vy c cc chng trnh dch khc nhau. C++ m chng ta s s dng i cng vi ti liu ny l Turbo C++ version 3.0 ca Borland (1990 - 1992). Li cm n Tc gi xin by t lng bit n chn thnh ti: Ph gio s, tin s Nguyn Xun Huy (Vin Cng ngh thng tin); Gio s Phm Vn t (i hc giao thng); Tin s Dng T Cng (Hc vin k thut qun s); Tin s Ph c Ton (i hc s phm H Ni I); Ph gio s, tin s on Vn Ban (Vin Cng ngh thng tin) c nhng kin ng gp qu bu cun gio trnh c hon chnh v c cht lng hn.

Nguyn Ch Trung Tc gi cng xin chn thnh cm n s t chc, hp tc v gip nhit tnh ca Ban gim hiu, phng o to v t chuyn mn trng THKT Tin hc H Ni - ESTIH.

Nguyn Ch Trung M U SO SNH GIA LP TRNH HNG I TNG V LP TRNH HNG TH TC Lp trnh hng th tc Theo cch tip cn truyn thng ca lp trnh hng th tc th chng trnh c xem nh dy cc cng vic cn thc hin: Nhp d liu, X l d liu, Tnh ton, Lp bo co, In kt qu... Vy trng tm ca lp trnh hng th tc l phn r bi ton thnh cc hm chc nng theo k thut top-down. Bi ton c gii quyt bi mt s hm chnh. Cc hm chnh li c th phn chia thnh cc bi ton con - tc l cc hm chc nng nh hn na. Mt s hm c th gi thc hin (dng chung) mt s hm chc nng nh hn. Nh vy, cu trc cc hm ca mt chng trnh lp trnh hng th tc l cu trc phn cp cc hm:
main

Hm1

Hm2

Hm3

Hm4 Hm5 Hm6 Hm7 Hm8

Vic ch ti cc hm trong chng trnh s khng quan tm nhiu n d liu. D liu ca ton b chng trnh c cc hm dng chung v bin i t hm ny sang hm khc. Bn thn trong cc hm cng c d liu ring.
D liu chung D liu chung

Hm 1 D liu ring 1

Hm 2 D liu ring 2

Hm 3 D liu ring 3

Vy c trng ca lp trnh hng th tc l 1. Tp trung vo cng vic cn thc hin - thut ton. 2. Chng trnh c chia thnh cc hm nh. 3. Phn ln cc hm dng chung d liu. 4. D liu trong chng trnh chuyn ng t hm ny sang hm khc. 6

Nguyn Ch Trung 5. Hm bin i d liu t dng ny sang dng khc. 6. Thit k chng trnh theo k thut top-down Lp trnh hng i tng Lp trnh hng i tng t trng tm vo i tng v khng cho d liu chuyn ng trong h thng. D liu gn cht vo cc hm v th tc to thnh mt vng ring v khng cho cc hm bn ngoi truy nhp mt cch tu tin. Lp trnh hng i tng phn tch bi ton thnh cc thc th gi l i tng, sau xy dng cc hm xung quanh i tng . D liu ca i tng ch c th truy nhp c bi cc hm ca i tng. Ch c mt s hm ca i tng ny c th gi thc hin cc hm ca i tng khc biu th s trao i thng bo gia cc i tng.
i tng A D liu Cc hm i tng B D liu Cc hm

i tng C D liu Cc hm

Nh vy c trng ca lp trnh hng i tng l: 1. Tp trung vo d liu thay cho hm. 2. Chia chng trnh thnh cc i tng. 3. D liu c thit k sao cho c t c i tng. 4. Cc hm c xy dng trn cc vng d liu ca i tng v c gn lin vi nhau trn cu trc d liu . 5. D liu c bao bc, che du khng cho cc hm ngoi lai truy nhp. 6. Cc i tng trao i thng bo vi nhau thng qua cc hm. 7. D liu v cc hm d dng b sung vo i tng. 8. Chng trnh c thit k theo k thut botom up.

Nguyn Ch Trung GII THIU NGN NG C++ Trong phn ny: vi mc ch so snh ngn ng C v C++ s lm r mt s c im mnh ca C++ so vi C, ng thi nhn mnh thm hoc gii thch chi tit mt s vn quan trng, thng gp khi lp trnh vi C++. Ch thch trong C v trong C++ Trc ht C++ c pht trin t C nn n vn s dng li tt c cc c php ngn ng nh C v b sung thm mt s c php mi. C++ a ra mt kiu ch thch mi tin ch thch trn mt dng nu dng k php // v cng tin vit trn nhiu dng lin tc nu dng cp k php /*... */ Ch thch trong C /* dong 1 chu thich cua C */ /* dong 2 chu thich cua C */ x=y=0; /*chu thich sau lenh */ Ch thch trong C++ /* Bat dau chu thich Dong 2 chu thich Ket thuc chu thich */ x=y=10; // chu thich sau lenh // co the chu thich tren 1 dong

Cc t kha mi C++ b sung vo C mt s t kha mi asm catch friend operator new inline protected virtual this class Php chuyn kiu bt buc Ngoi php chuyn kiu nh trong ngn ng C, C++ cn a ra php chuyn kiu mi. Xt v d sau y: int x=0; long z=(long)x; // chuyen kieu cua C long z=long(x); // chuyen kieu cua C++ Nh vy php chuyn kiu trong C++ c dng nh mt hm s chuyn kiu ang c gi. Cch chuyn kiu ny r rng va khoa hc va d dc. Khai bo bin Nhn chung phm vi hot ng ca bin ph thuc vo kiu ca bin v v tr khai bo ca bin trong chng trnh. public private cdecl pascal delete templete

Nguyn Ch Trung Ngn ng C i hi phi khai bo bin trc phm vi m cc bin ang s dng. Cch khai bo n gin nht trong C l khai bo bin ton cc ln trc tt c cc hm v khai bo bin cc b u thn tng hm. Trong C++, khc vi C, cho php mt cch khai bo bin mi, vi cch khai bo ny, mt bin c th khai bo v tr bt k min sao l trc khi s dng n, phm vi hot ng ca bin trong trng hp ny l trong khi ni bin c khai bo. V d 1.1 Khai bo sau y trong C ++ chp nhn nhng trong C l li v C yu cu khai bo bin trc lnh.
clrscr(); int x;

V d 1.2
void simple() { int n; // khai bao cuc bo for(int i=0;i<10;i++) // cho phep khai bao i trong for { int m; if (i&1) n+=1 } // su dung bien m ngoai pham vi khoi cua m nhu sau la sai m = n/2; // sai n = i; // dung }

Hm main Hm main trong C khng c nh ngha kiu. Hm main trong C++ c nh ngha kiu tr li mt gi tr nguyn cho h iu hnh DOS, do phi khai bo l kiu int, ngm nh-v vy s l int. Tuy nhin ta vn c th nh ngha kiu void cho hm main. Khi chng trnh bt u thc hin, hm main c gi bi mt chng trnh khi ng c bit (start up code) c sn trong C++. Start up code trong C++ c bn cch gi (ty chn vo Option\ Application): Dos standard (tp C0.ASM) Dos overlays (tp C0.ASM) Windows Application (tp C0w.ASM) Windows DLL (tp C0d.ASM) Gi tr tr li ca hm main s c Dos s dng kim tra li khi thc hin chng trnh. Gi tr ny bng 0 nu khng c li. Cc gi tr khc 0 c C++ bin lun theo cc li khi thc hin chng trnh.

Nguyn Ch Trung Truyn tham s cho hm Trc ht phi thng nht v thut ng: Lc khai bo v nh ngha hm th phn khai bo trong ngoc n (nu c) sau tn hm gi l tham s hnh thc ca hm. Khi mt hm (c tham s hnh thc) c gi ra s dng th chng trnh gi hm phi truyn vo hm cc tham s thc s thay th cc tham s hnh thc. Thut ng "truyn tham s cho hm" l c ni ti s lin quan gia hai vic: vic khai bo, nh ngha hm vi tham s hnh thc v vic gi hm vi tham s thc s. Tuy nhin, cho ngn gn: tham s hnh thc thng c gi l i v tham s thc s nu khng nhm ln vi tham s hnh thc vn thng c gi tt l tham s. C++ vn s dng hai cch truyn tham s cho hm trong C. l hai cch truyn tham s tng ng vi hai trng hp: i ca hm l bin thng thng, gi l truyn tham s kiu tham tr i ca hm l bin con tr, gi l truyn tham s kiu con tr. Tuy nhin, C++ c thm mt cch mi truyn tham s cho hm tng ng vi trng hp i ca hm l a ch ca bin. Cch truyn tham s nh vy gi l truyn tham s kiu tham chiu. Cch mi ny rt hay s dng v thch hp truyn tham s cho hm l a ch ca i tng - mt kiu d liu mi ch c trong C++ (kiu lp). Di y ta nhc li hai cch truyn thng v cung cp cch mi th ba.
Truyn tham s kiu tham tr

Khi i ca hm l bin n thun th khi gi hm, tham s c truyn vo hm c th l gi tr c th (v d 1.3) hoc l mt bin xc nh (v d 1.4) c khai bo trong chng trnh gi hm. V bn cht, theo cch truyn tham s vo hm l bin th ch c bn sao gi tr ca bin c hm s dng. Trong thn hm, cc bn sao ny c th b thay i, t suy ra, khi ra khi hm th gi tr ban u ca bin truyn vo hm vn gi nguyn. Chnh v c im trn nn ta gi l "truyn tham s kiu tham tr" . V d 1.3
#include <stdio.h> #include <conio.h> #define PI 3.1416 float S(float); main() { printf("\n dien tich h.tron ban kinh 50.0 la: %5.1f",S(50.0)); getch(); } float S(float r) {return Pi*r*r;}

Trong v d 1.3 ta thy rng S l mt hm c i l bin bnh thng kiu float. Khi hm main gi S th tham s c gi tr c th bng 50.0 c truyn vo hm. 10

Nguyn Ch Trung V d 1.4

#include <stdio.h> #include <conio.h> void swap(int,int); main() { int x=10,y=5; clrscr(); swap(x,y); printf("x=%d y=%d\n",x,y); getch(); } void swap(int x,int y) {int z=x; x=y; y=z;}

Kt qu
x = 10 y=5

V d 1.4 minh ho rng: khi hm swap c hai i l cc bin int thng thng th khi gi hm: tham s truyn vo hm (x=10, y=5) vn gi nguyn gi tr khi ra khi hm, mc d, trong hm, gi tr ca x v y b thay i (x=5, y=10).
Truyn tham s kiu con tr

Khi khai bo v nh ngha hm c i l bin con tr th lc gi hm, cc con tr ny s thay th bng a ch ca cc bin (v d 1.5) truyn vo hm hoc l mt con tr hon ton xc nh a ch m n tr vo (chng hn ang cha mt a ch ca mt bin xc nh nh v d 1.6). V bn cht, theo cch truyn tham s kiu con tr th hm c truyn vo bn sao a ch ca bin. Nh vy, mi s thay i v gi tr ca bin (cng vn l a ch ) trong thn hm s c gi li khi hm kt thc. V d 1.5
#include <stdio.h> #include <conio.h> void swap(int*,int*); main() { int x=10,y=5; clrscr(); swap(&x,&y); printf("x=%d y=%d\n",x,y); getch();} void swap(int *x,int *y){int z=*x; *x=*y; *y=z;}

Kt qu x = 5 y=10

V d 1.6
#include <stdio.h> #include <conio.h>

Kt qu x = 5 y=10 11

Nguyn Ch Trung
void swap(int*,int*); main() { int x=10,y=5; int *px=&x, *py=&y; clrscr(); swap(px,py); printf("x=%d y=%d\n",x,y); getch();} void swap(int *x,int *y){int z=*x; *x=*y; *y=z;}

Ch : Vic s dng hm truyn tham s kiu con tr phi ghi nh cc c php sau y: Khi khai bo: void swap(int*,int*) Khi nh ngha: void swap(int *x,int *y) { // trong thn hm, vit : *x v *y; } Khi s dng: swap(&x,&y); nu x v y l hai bin swap(px,py); nu px v py l hai bin con tr
Truyn tham s kiu tham chiu cho hm

V mt tc dng, vic truyn tham s cho hm kiu tham chiu cng ging nh vic truyn tham s cho hm kiu con tr. C ngha l gi tr ca tham s b hm thay i cng s c gi li khi ra khi hm. Bn cht ca cch truyn tham s kiu tham chiu khc bn cht ca hai cch truyn tham s truyn thng: kiu tham tr v kiu con tr. Theo cch truyn tham s truyn thng th ch c bn sao gi tr (hoc gi tr ca bin hoc gi tr l a ch bin) truyn vo hm, cn trong cch truyn tham s kiu tham chiu th hm lm vic trc tip trn bin truyn vo hm, thng qua "b danh" ca n. V d 1.7
#include <stdio.h> #include <conio.h> void swap(int &,int &); void main() { int x=10,y=5; clrscr(); swap(x,y); printf("x=%d y=%d\n",x,y); getch(); } void swap(int &x,int &y) {int z=x; x=y; y=z;}

Kt qu x = 5 y=10

12

Nguyn Ch Trung So snh v d 1.7 vi cc v d 1.6 v 1.5 ta thy rng: Cng mt tc dng nh nhau nhng r rng vic s dng tham chiu n gin hn so vi con tr. Xt v c php, khi truyn tham s cho hm theo kiu tham chiu th ta ch cn bo hiu a ch ca bin phn khai bo, cn trong thn hm v trong li gi hm, ta vn vit tn bin mt cch bnh thng. Hai cch truyn tham s kiu con tr v truyn tham s kiu tham chiu, mc d cng nhn vo a ch bin nhng c nhng khc bit sau y cn c lu : Khng c cp pht b nh ng cho bin tham chiu. Trong khi , bin con tr th c php xin cp pht b nh ng. Khng dng cc php ton tng gim a ch cho bin tham chiu. Trong khi bin con tr cho php cc php ton ny. Vic tng gim a ch ca bin con tr l lm thay i a ch b nh (bin) m con tr ang tr vo. Ngc li bin tham chiu gn lin vi a ch tnh trong b nh v do khng c php thay i a ch ny. Nhc li v bin con tr
So snh con tr v tham chiu a ch ca bin

Chng hn nu c khai bo: int *p; v gn *p=10; th ng nhin c th vit (*p)++; nhng thm ch c th vit p++; Trong khi ta khng th c lnh tng a ch (&x)++ nu c khai bo int x; C++ cho php vit nh vy v hai cch vit c tc dng khc nhau: Lnh (*p)++ l tng 1 n v cho bin nguyn xc nh bi con tr p. Lnh p++ l tng a ch ca con tr p, tc l con tr p s tr vo 2 byte nh tip theo (2 bytes ng vi kiu int). Vy lnh p++ ch s dng khi dng p tr vo khng phi l 1 s nguyn m l mt dy cc s nguyn cha trong mt dy cc bin ng (cc bytes nh) lin tip nhau. Bin con tr c 2 cch s dng trong chng trnh: S dng con tr cha a ch ca bin. S dng con tr xin cp pht b nh ng. V d 1.8 sau y ni rng khi c khai bo bin con tr int *p; th vic s dng bin *p ging nh vic s dng mt bin nguyn no mt cch bnh thng. V d 1.8
#include <iostream.h> #include <conio.h> void main() { int *p; *p=10; cout<<*p<<endl; (*p)++; cout<<*p<<endl;

13

Nguyn Ch Trung
getch(); }

S dng con tr cha a ch ca bin.

Nu ta c khai bo int x; int *p; Th sau khi gn lnh p=&x; // ngha l con tr p cha a ch ca bin x ta s c ng thc *p = = x V d 1.9
#include <stdio.h> #include <conio.h> main() { int x=10; int *p; p=&x; cout << "x= " << *p; // ket qua x = 10 *p+=20; cout << "x= " << *p; // ket qua x = 20 getch(); }

S dng con tr xin cp pht v qun l dy bin ng

V d 1.10
#include <iostream.h> #include <conio.h> void main() { int *p; int i,n=5; p=new int[n]; int *q; q=p; for(i=0;i<n;i++) { cout<<"phan tu thi "<<i+1<<": "; cin>>*q; q++; } q=p; for(i=0;i<n;i++) { cout<<*q<<" "; q++; }

14

Nguyn Ch Trung
delete [] p; getch(); }

V d 1.10 l mt cch n gin to ra mt "danh sch lin kt" cc bin ng m bin ng u danh sch c tr bi con tr p. Khi duyt trn danh sch ny lun s dng thm mt bin con tr ph (trong v d 1.10 nu trn l bin con tr q) chy trn cc bin ng, con tr p phi c gi nguyn c vai tr lu gi a ch ca danh sch. Ta gi l danh sch lin kt to ra mt cm gic cc bin ng c lin kt vi nhau. V mt bn cht l cc nh lin tc c cp pht ng, ch khng c lin kt g c. Lc chy chng trnh, php tng a ch q++ lm cho q ch vo 2 bytes tip theo ngha l truy xut n bin ng kiu int tip theo tng ng. S dng tham s truyn ngm nh trong hm C++ cn mnh hn C ch n cho php khi to mc nh cho cc tham s truyn cho hm. Ta gi tt cc tham s c khi to gi tr mc nh l cc tham s ngm nh. Khi c tham s ngm nh truyn cho hm, c hai trng hp sau xy ra lc gi hm: Nu li gi hm khuyt cc tham s ngm nh th cc gi tr ngm nh c s dng. Nu li gi hm c mt cc tham s ngm nh th cc gi tr mi s c s dng thay v s dng cc gi tr mc nh. V d 1.11
void f(int i = 100); void main() { f(); // s dng tham s ngm nh i = 100 f(200) ; // s dng gi tr mi i = 200 } void f(int i) { cout << "i = " << i; }

Khi dng cc tham s ngm nh, c hai nguyn tc sau y: Cc tham s ngm nh phi nm cui danh sch tham s. Khi gi hm khuyt cc tham s ngm nh th phi khuyt t phi sang tri v cc tham s c gi cn lin tc khng c ngt qung. V d 1.12 Khai bo sau y l sai:
void g(int a = 1, int b, int c = 3, int d = 4); // sai

v cc tham s ngm nh phi khai bo cui danh sch tham s. Khai bo sau y l ng:
void g(int a, int b=2, int c = 3, int d = 4); // ng

15

Nguyn Ch Trung Vi khai bo ng trn, xt cc li gi hm sau y:

g(); // sai v a khng c gi tr mc nh g(10,20,30,40); // ng v y tham s g(10,20,,40); // sai v s dng ngt qung g(10); // ng v nhn cc gi tr mc nh ca b,c,d l 2,3,4 g(10,20);// ng v nhn cc gi tr mc nh ca c, d l 3,4

Trong khi khai bo cc hm thnh phn ca lp, c bit l constructor (constructor) ngi ta rt hay s dng cc tham s ngm nh. Cp pht v gii phng b nh Trc ht v c php ca lnh cp pht v gii phng b nh, C++ cung cp thm hai lnh mi ngn gn v d dng hn l new v delete. So snh hai v d sau y:
Trong C char *s; char tg[100]; int len; /* Cp pht b nh cho con tr s kiu char */ * c th cha c dy k t trong */ /* chui tg */ gets(tg); len=strlen(tg); s=(char*) malloc ((len+1)*sizeof(char)); strcpy(s,tg); free(s); /* Gii phng b nh */ Trong C++ char *s; char tg[100]; gets(tg); /* cp pht b nh cho con tr s kiu char cha gi tr ca chui tg */ int len=strlen(tg); s = new char[len] strcpy(s,tg); delete s; // Gii phng b nh

Trong v d trn ton t new xin cp pht mt vng nh c s bytes l: len*sizeof(char). Nu khng b nh cp pht th new tr li gi tr ca hng con tr NULL (khng tr vo vng nh no). Gi tr NULL l gi tr cho php ngi lp trnh s dng kim tra ton t new c thc hin thnh cng hay khng. Mc d new v malloc u dng ch n a ch u ca vng nh xin c cp pht nhng gia chng vn c im khc bit. V d 1.13
#include <alloc.h> // alloc.h cn thit cho s dng malloc void main() { int* ip = new int[0]; //tr li gi tr khng xc nh ca con tr int* ip = (int*) malloc (0); // tr li gi tr NULL pointer. }

Qua v d trn ta thy ton t new tr li gi tr khc 0 ca con tr thm ch ta khng i hi phi cp pht bt c mt bytes no trong b nh. Gi tr ny ca con tr nu c s dng cho mc ch khc s sinh li trong chng trnh. Ngc li 16

Nguyn Ch Trung hm malloc trong trng hp ny tr li gi tr NULL, iu ny c ngha l con tr cha tr n bt c v tr no trong b nh. Cng cn lu l trong C++, hm malloc c kiu tr li l void* do khi s dng phi thc hin vic chuyn i kiu tng ng vi kiu ca i tng xin cp pht b nh. Ngoi hai khc bit trn v bn cht c new v malloc u dng cp pht b nh ng cho cc bin trong qu trnh thc hin chng trnh v con tr tr li theo hai cch ny khi thnh cng u khng c g khc bit. Trong lp trnh C++, ton t new c a dng v n mm do do kh nng nh ngha chng cc ton t ca lp. Cc hm ti bi (Overloaded function) Danh ng t overloading trong ting Anh dch l "Vic lm qu ti". Cm t overloaded function trong trng hp ny dch l hm nh ngha chng hoc hm ti bi. C++ a ra mt kh nng hon ton mi v rt mnh so vi C l kh nng nh ngha chng cc hm, ngha l cho php nh ngha cc hm thc hin cc chc nng khc nhau nhng c cng mt tn. Mt hm c nh ngha chng cn gi ngn gn l hm ti bi. Ngoi hm ti bi, C++ cn cho php ton t ti bi bnh thng ha cc ton t quen thuc i vi mt kiu d liu mi do ngi lp trnh nh ngha. Khi cc hm c ti bi th phi tun theo hai nguyn tc sau y: Cc hm phi khc nhau v s lng tham s hoc kiu d liu ca cc tham s. Kiu gi tr ca hm khng cho php phn bit cc hm c ti bi nu cc hm ny c danh sch tham s nh nhau. Khi gi cc hm ti bi, C++ s i snh danh sch tham s v kiu thch hp vi cc tham s thc s cho thc hin hm thch hp trong s cc hm ti bi. V d 1.14 Ti bi hm abs (l hm c sn) tnh gi tr tuyt i ca mt s bt k:
int abs(int i); long abs(long l); double abs(double d); Khi , xt li gi cc hm sau y: abs(-10); // gi hm int abs(int i); abs(-100000); // gi hm long abs(long l); abs(-34.12); // gi hm double abs(double d); abs('a'); // gi hm int abs(int i);

V d 1.15 Ti bi hm display (l hm t nh ngha) hin th mt gi tr c kiu n gin bt k: 17

Nguyn Ch Trung
void Display(char *string) {puts(string);} void Display(long value) {printf("%ld",value);} void Display(double value) {printf("%lf",value);} void main() { Display("\n Hello Mumy"); // s dng hm Display(char*) Display(123456789); // s dng hm Display(long) Display(3.1416); // s dng hm Display(double) Display(123); // chng trnh bo li }

Khi thc hin chng trnh, c li ti hm Display(123) vi thng bo: "Ambiguity between 'Display(double)' and 'Display(long)' ". C ngha l tham s c gi tr 123 c th hiu l thuc tp gi tr ca long hoc ca double, do c s nhp nhng trong vic chn hm no trong hai hm Display(long) v Display(double) trong li gi hm Display(123). trnh li, ta s s p kiu 123 sang long hoc double nh sau: Display(long(123)); hoc Display(double(123)). Hm inline
Nhc li macro trong ngn ng C

Macro (dch theo ngha thng thng l v m) hiu theo ngha tin hc l mt lnh ring l vit bng mt ngn ng lp trnh nhng kt qu l mt chui lnh bng ngn ng my tnh. Trong ngn ng C cho php to ra cc macro ng nh ngha ca n: cho php to ra mt hng hoc thm ch to ra mt hm v ni chung to ra mt tn thay th (tn macro) ghp macro ny nh mt on trnh m my vo chng trnh ngun lc thc hin. Trc ht macro c nh ngha bng ch th #define (v c hy b bng #undef). Cc ch th #define (php thay th lnh), #include (php chn tp), #if (php la chn cc dng lnh bin dch): u l cc ch th tin x l, khng phi l cc cu lnh thng thng ca chng trnh. Khi mt chng trnh C c bin dch, trc ht cc ch th tin x l s chnh l vn bn chng trnh ngun, sau bn chnh l ny mi c dch. Cc ch th tin x l, do lm cho chng trnh ngn gn hn, gip cho vic t chc bin dch, g ri chng trnh hiu qu hn. C 2 loi macro: macro thay th n gin v macro thay th theo i (nh cc hm) Macro n gin #define tn_macro biu_thc C tc dng thay th tn_macro bng biu_thc ng sau n. Khi biu thc k t di c th thm mt du \ trc khi xung dng. Trc khi dng li tn_macro cho mt biu_thc khc th phi hu b n bng ch th. #undef tn_macro V d 1.16 18

Nguyn Ch Trung
#include <stdio.h> #define In printf #define N 100 void main(){ int M = 200; In("\nN = %d, M= %d",N,M); #define M 300 In("\nN = %d, M= %d",N,M); #undef M #define M (N+400) In("\nN = %d, M= %d",N,M); }

Ch : (1) Khi nh ngha biu thc cha php ton cn t biu thc trong du ngc n. V d 1: nu vit #define P 3+5 th nh ngha ny s ng vi cu lnh Q=P; s khng ng vi cu lnh Q=2*P; /* khi Q = 2*3 + 5 vy cn phi nh ngha l #define P(3+5) (2) Khi nh ngha mt macro nh mt on chng trnh th phi vit on chng trnh trong khi lnh {... } V d 2:
#define Check { printf("\nStop ! "); exit(1); } void main(){ ... if (x > MAX_VALUE) Check; }

Macro nh ngha hm C th dng macro c i nh ngha hm. Khi c mt s im ch sau y: i ca macro c th khng cn khai bo kiu c th. Tn hm (macro) phi vit lin vi du m ngoc bt u khai bo i. Tt c cc i hnh thc trong thn hm (macro) phi vit trong ngoc n. V d 3:
#define MAX(A,B) (A)>(B)?(A):(B) khi dng lnh: x = max(p+q,r+s); s c thay th bng dng lnh x=(p+q)>(r+s)?(p+q):(r+s);

19

Nguyn Ch Trung V d 1.17

#include "stdio.h" #define tich(a,b) a*b void main() { int x=10, y=20, z=5; printf("\ntich = %d ", tich(x+y,z)); }

Khi bin dch, chng trnh s bin dch s thay tich(x+y,z) bng x+y*z nh vy s khng nhn c tch (x+y)*z nh mong mun. Vy phi khai bo li l: #define tich(a,b) (a)*(b)
Hm inline

Trong ngn ng C++, hm inline c cch hot ng ging nh mt macro trong ngn ng C. Ngha l cc hm inline s c thay th trc tip thnh dy lnh m my ti ch gi n trong chng trnh lc thc hin. u im ca macro v inline l ch n cho php trnh by chng trnh ngn gn v quan trng l cho php thc hin nhanh hn cc hm thng thng. Bi v mi ln gi hm inline (hoc macro), trnh bin dch s ghp trc tip cu lnh m my ca n ti v tr gi n trong chng trnh (m my) lc thc hin v khng i hi cc th tc b sung khi gi hm v tr gi tr v, ni cch khc khng c c ch qun l li gi v tr v (khng cn lu ng cnh) nh i vi cc hm thng thng. Nhc im ca inline (v macro) l khi chng qu ln v gi thng xuyn th kch thc chng trnh s tng ln rt nhanh. V mi ln gi inline (hoc macro) th cc ch th tng ng s c sinh ra (khng c c ch lu ng cnh gii phng b nh) do ch ph lu tr tng ln khi gi hm nhiu ln. Vy inline v macro tit kim thi gian nhng khng tit kim b nh, cho nn thn cc hm inline khng nn cha cc cu trc lp. Vic s dng inline trong C++ tt hn macro trong C ch hm inline khng cn phi vit cc tham s trong du ngoc nh i vi cc hm m macro m t. V d nu nh ngha mt macro: #define square(x) { x++*x++;} th li gi square (a) s sinh ra biu thc a++*a++ lm thay i gi tr ca a ti hai ln v hn na li gi square(3) s khng c chp nhn v khng c php tng gim i vi hng s. Hm inline c nh ngha v s dng nh mt hm bnh thng, im khc nhau duy nht l phi t m t inline trc khai bo hm. Cui cng, cn nh rng ging nh macro, c t inline l mt yu cu ch khng phi l mt ch th. Nu v mt l do no m trnh bin dch khng p ng c yu cu ca inline (chng hn nh bn trong inline c cu trc lp) th yu cu ca inline b b qua v n c bin dch nh mt hm bnh thng (y cng l mt im tin b ca inline so vi macro).

20

Nguyn Ch Trung V d 1.18

#include <iostream.h> #include <math.h> #include <conio.h> inline double Value(double vector[3]); void main(){ clrscr(); double v[3]; for (int i=0;i<3;i++) v[i]=2*i-1; cout<<Value(v); getch(); } inline double Value(double vector[3]) { double s=0; int i; for(i=0; i<3;i++) s+=vector[i]*vector[i]; return (sqrt(s)); }

Kh nng vo ra mi ca C++
Tng quan v stream trong C++

Nhn li C thy thy rng C s dng rt nhiu hm nhp v xut d liu v d nh: printf(), scanf(), sprintf(), sscanf(),... Cc hm ny c khai bo trong tp tiu stdio.h. V mt kha cnh, chng khng nht qun v th t v ng ngha ca cc tham s. C++ a ra streams thng qua cc lp v gi cc lp ny l th vin cc dng nhp/xut. Streams to ra mt kh nng rt mnh cho php sa i v m rng v v vy c th nhp/xut i vi cc kiu d liu mi do ngi dng nh ngha. Cc dng nhp (istream) cho php nhp d liu vo stream, cc dng xut (ostream) cho php xut d liu t stream. Th vin cc dng nhp/xut l mt cu trc cy cc lp v chng ta s nghin cu sau. Trong tp tiu iostream.h C++ nh ngha 2 i tng cin v cout tng ng l hai thit b chun vo/ra v c s dng cng vi hai ton t ti bi >> (vo) v << (ra). Thng thng, ta hiu cin l bn phm cn cout l mn hnh.
Ghi d liu ln thit b ra chun (mn hnh) bng <<

V d 1.19
#include <iosteam.h> void main() { cout << "Well come C++ "; }

21

Nguyn Ch Trung << l mt ton t 2 ngi: ton hng bn tri l ni kt xut thng tin (c th l mt thit b ngoi vi chun hay mt tp tin). Ton hng bn phi l mt biu thc no . Ton t << c kh nng ti bi m trc ht n ng i vi cc kiu sau y: 1. Kiu d liu c s: char, int, float, double 2. Xu k t: char* 3. Con tr (tr kiu char *) V d 1.20
#include <iosteam.h> void main() {int n=25; cout << "Value: " <<n; }

Vo d liu t thit b vo chun (bn phm) bng >>

V d 1.21
#include <iostream.h> #include <conio.h> void main() { int n; float x; char s[20]; clrscr(); do { cout << "nhap mot so nguyen, mot so thuc va mot xau "; cin >> n >> x >> s; cout << "da nhap" << n << ", " << x << endl << s; } while (n); }

>> l mt ton t cho php nhp d liu cho cc bin c kiu: char, int, float, double v char* Ging nh hm scanf(), cin tun theo mt s quy c dng trong vic phn tch cc k t: Cc gi tr s c phn cch bi SPACE, TAB, CR, LF. Gp k t "khng hp l" v d khi c s nhp du chm th k t ny s lm kt thc lnh cin v n s c xem xt trong ln c sau. i vi xu k t, du phn cch cng l SPACE, TAB, CR cn i vi k t, du phn cch l k t CR. Trong trng hp ny khng c khi nim "k t khng hp l". M sinh ra do bm phm Enter ca ln nhp trc vn c xem xt cho ln nhp xu k t tip theo, do s c th khng nhp c k t mong

22

Nguyn Ch Trung mun. Gii php t ra l trc mi ln nhp xu k t hoc k t ta lm rng b m bn phm bng mt trong 2 lnh sau y: fflush(stdin); // trong tp tiu stdio.h cin.clear(); // hm thnh phn ca lp nh ngha i tng cin. Trong trng hp mun nhp xu k t c c du cch th nn dng lnh gets(), khai bo trong tp tiu stdio.h V d 1.22
#include <iostream.h> #include <stdio.h> void main() { char s[30]; cout<<"nhap mot xau: "; gets(s) cout<<"xau vua nhap: "; puts(s); }

Streams c s dng hon ton c lp vi stdio nhng vic s dng ng thi hai th vin ny c th lm pht sinh ra mt s vn , chng hn s khng lm xut ra d liu theo ng th t mong mun. BI TP CHNG 1 Bi 1.1 Trnh by cc c trng ca lp trnh hng th tc v ca lp trnh hng i tng. Bi 1.2 Nu ngay sau khi khai bo: float *p; float r; Th lnh no sau y ng: (1) p = r; (2) p = &r; (3) *p = &r; (4) *p = r; Bi 1.3 Phn bit hng a ch vi bin con tr trong trng hp xu k t l mt trong cc kin thc ca C cn c cng c. Hy xem xt v cho bit trong hai on trnh sau y, on trnh no vit ng: on trnh 1: char *name, s[30]; name = "le phuong thuy"; gets(s); 23

Nguyn Ch Trung on trnh 2: char *name, s[30]; s="le thu ha"; gets(name); Bi 1.4 Hy xem xt v so snh hai on trnh sau y: on trnh 1: int x; int *px = &x; *px = 10; on trnh 2: int *px; px = new int[1]; *p = 10; Bi 1.5 Chng trnh sau y cho in ln mn hnh gi tr ca cc bin a, b v gi tr hm f bng bao nhiu?
#include <stdio.h> #include <conio.h> int f(int,int); main() { int a=10,b=25; printf("(%d,%d) = %d ", a,b, f(a,b)); getch(); } int f(int a,int b) {while (a!=b) if (a>b) a-=b; else b-=a; return a; }

Bi 1.6 Chng trnh di y lm nhim v nhp mt phn s p ( p = a/b) ri in ln mn hnh phn s p sau khi ti gin. Hy gii thch cch truyn tham s, cch xy dng v cch gi thc hin cc hm: hm gcd v hm reduce.
#include <stdio.h> #include <conio.h> struct frac { int a,b;}; int gcd(int,int);

24

Nguyn Ch Trung
void reduce(frac *); void main() { clrscr(); frac p; printf("\nEnter frac:\n"); printf("Numerator: "); scanf("%d", &p.a); printf("Denominator: "); scanf("%d", &p.b); reduce(&p); printf("Frac is reduced: %d/%d", p.a, p.b); getch(); } int gcd(int a,int b) { int r=a%b; while (r!=0) {a=b; b=r; r=a%b; } return b; } void reduce(frac *p) { int u = gcd(p->a,p->b); (*p).a/=u; (*p).b/=u; } Lu : Trong chng trnh, cho xc tch, s dng mt s t ting Anh sau y: GCD (Greatest Common Divisor): c s chung ln nht; Reduce: ti gin; Numerator: t s; Denominator: mu s.

Bi 1.7 Hy vit li chng trnh tm phn s ti gin trong bi tp 1.6 bng cch thay i cch truyn tham s kiu con tr trong hm reduce bng cch truyn tham s kiu tham chiu. Bi 1.8 Chng trnh sau y xy dng hm vetamgiac vi cc tham s c gi tr ngm nh v hm main thc hin mt s lnh (c ch thch s th t lnh) gi hm ny v mt s tam gic trn mn hnh. Tuy nhin khi khi chy chng trnh thy ln lt mt s li gi hm b bo li . Hy cho bit nhng lnh no b sai v cn phi b i.
#include <graphics.h>#include <stdlib.h> #include <stdio.h> #include <conio.h> void vetamgiac(int x1,int y1,int x2=200,int y2=300, int x3=400,int y3=100)

25

Nguyn Ch Trung
{ line(x1,y1,x2,y2); line(x2,y2,x3,y3); line(x3,y3,x1,y1); } void main() { int driver = DETECT, mode; initgraph(&driver, &mode, "c:\\tc\\bgi"); vetamgiac(50,50,200,200,100,300); // 1 vetamgiac(); // 2 vetamgiac(50,50,,150,350); // 3 vetamgiac(50,50); // 4 vetamgiac(50,50,200,200); // 5 vetamgiac(50,50,200,200,,150); // 6 vetamgiac(50,50,200,200,10); // 7 vetamgiac(50,50,,,150,250); // 8 getch(); closegraph(); }

Bi 1.9 Vit chng trnh s dng cc i tng cin v cout trong tp tiu iostream.h nhp d liu v in kt qu ln mn hnh mt mng cc phn t c kiu struct biu th thng tin cho mt sinh vin gm h tn, nm sinh v im thi mn C++.

26

Nguyn Ch Trung LP CC I TNG LP CC I TNG Cc khi nim c bn

Khi nim i tng (Object)

i tng l m hnh ca thc th, bao gm: Thng tin m t i tng (d liu), gi l trng thi (status) ca i tng. Cc hm tc ng ln i tng lm thay i trng thi ca i tng, gi l phng thc (method) ca i tng. D liu v cc hm ca i tng gn lin vi nhau c t i tng. i tng bao gm c s vt, hin tng v cc khi nim. V d: i tng hc sinh bao gm cc thng tin nh h tn, nm sinh, a ch. Cc hm tc ng ln d liu ca hc sinh trc ht phi k n cc hm nhp d liu, xem d liu. i tng hnh ch nht bao gm hai kch thc di v rng v cc hm lin quan n mt hnh ch nht thng l hm tnh chu vi v din tch ca n.
Lp i tng (Class)

Cc i tng c cng thnh phn d liu v phng thc hnh thnh ln mt lp. Vy c th xem i tng l mt th hin (instance) ca lp. Lp l kiu d liu c nh ngha bi ngi dng nn n cng c cc tnh cht nh mt kiu d liu c s. V d nu A l lp th vit A a; cng ging nh khi vit int x; Tc l a l mt bin kiu A, tuy nhin ta s gi l a l mt i tng ca lp A v lnh ny gi l lnh to lp i tng.
Tru tng ho d liu v bao gi thng tin (Abstraction and Encapsulation)

Vic ng gi d liu v cc hm gn vi n vo mt n v cu trc tc l mt lp cc i tng c xem nh mt nguyn tc bao gi thng tin. Nguyn tc bao gi d liu ngn cm s truy nhp trc tip trong lp trnh gi l s che du thng tin. Tru tng ho d liu l cch biu din nhng c tnh chung nht ca cc i tng c cng mt bn cht, b qua nhng thng tin chi tit ca tng i tng ring l. Trong lp trnh, lp c s dng nh kiu d liu tru tng v nng ln mc khun mu lp. Phng php lp trnh hng i tng bao gm c tru tng ho d liu v tru tng ho chc nng. Khai bo lp cc i tng
Khai bo

27

Nguyn Ch Trung
class class_name { private: data_type var_name; return_type fun_name(arg_list); public: data_type var_name; return_type fun_name(arg_list); };

To lp i tng

To lp i tng ngay sau khi khai bo

class class_name { // Cc thnh phn ca lp } obj_name;

To lp i tng bn ngoi lp
class class_name obj_name;

Phm vi hot ng ca cc thnh phn bn trong lp

Vng private Data function

Data function
Vng public

Nhng thnh phn c khai trong lp c chia thnh hai nhm: Nhng thnh phn private khng th truy nhp bi nhng hm bn ngoi lp m ch c th c truy nhp bi cc hm thnh phn khc bn trong chnh lp , tc l chng ch c s dng bn trong thn cc hm thnh phn ca lp. Nhng thnh phn public c th c truy nhp bi cc hm thnh phn khc bn trong lp v cc hm bn ngoi lp. Nu truy nhp bi cc hm bn ngoi lp th phi s dng thng qua i tng ca lp. Cc i tng thuc lp s truy nhp ti cc thnh phn public thng qua ton t xc nh "." 28

Nguyn Ch Trung Nhc li rng: C++ l ngn ng m rng t C, nn trong C++ vn cho php dng cc hm nh trong C. Hm khng gn vi lp no, cn phng thc (hm thnh phn) lun thuc mt lp no .
nh ngha cc hm thnh phn

nh ngay bn trong lp
class class_name { private: // khai bo dnh ngha cc thnh phn private public: // khai bo cc bin public return_type fun_name(arg_list) { // Cc lnh trong thn hm } // cc hm thnh phn khc };

V d 2.1 Trong ny, ta nh ngha lp MEMBERS, trong , thnh phn private gm cc thng tin ring ca mt c nhn: name (tn) v age (tui); thnh phn public gm hai phng thc: phng thc get_data() nhp thng tin v phng thc put_data() hin th thng tin ca mt c nhn . Cc hm get_data() v put_data() u c nh ngha trc tip ngay trong nh ngha lp.
#include <iostream.h> #include <conio.h> #include <stdio.h> class MEMBERS { char name[25]; int age; public: void get_data(void) { cout<<"Enter name: "; gets(name); cout<<"Enter age: "; cin>>age; } void put_data(void) { cout<<"Name: "<<name<<"\n"; cout<<"Age: "<<age<<endl; } } a; int main() { clrscr(); a.get_data(); a.put_data();

29

Nguyn Ch Trung
getch(); return 0;}

nh ngha bn ngoi lp
return_type class_name::fun_name(arg_list) {// ni dung hm }

V d 2.2 Tng t nh v d 2.1, Lp SINHVIEN trong v d 2.2 di y c thnh phn private gm cc thng tin ring ca mt sinh vin: h tn v nm sinh; thnh phn public gm hai phng thc: nhap() v xem() cc d liu cho sinh vin. Cc hm nhap() v xem() minh ho cch nh ngha hm thnh phn bn ngoi nh ngha lp.
#include <iostream.h> #include <conio.h> #include <stdio.h> class SINHVIEN { char hoten[25]; int namsinh; public: void nhap(void); void xem(void); }; void SINHVIEN::nhap() { cout<<"Nhap ho ten sinh vien: "; gets(hoten); cout<<"Nhap nam sinh: "; cin>>namsinh; } void SINHVIEN::xem() { cout<<"Ho ten: "<<hoten<<endl; cout<<"Nam sinh: "<<namsinh<<endl;} int main() { clrscr(); SINHVIEN s; s.nhap(); s.xem(); getch(); return 0; }

Truy nhp n thnh phn public thng qua i tng : obj_name.var_member; obj_name.fun_member; Ngoi thnh phn private v public, trong lp cn c thnh phn protected c dng trong quan h k tha gia cc lp, ta s nghin cu sau. Ch 30

Nguyn Ch Trung Ngoi cch dng t kho class ta cn c th s dng cc cch sau y nh ngha lp: S dng cu trc (struct) nh ngha lp, khi , ngm nh cc trng trong struct l thnh phn public. Ta c th quy nh li cc trng ny thuc thnh phn private hay public. S dng hp (union) nh ngha lp, khi , ngm nh cc trng trong union l thnh phn public v khng th thay i c. Cc thnh phn trong lp (Data member and function member)
Khi qut

D liu thnh phn trong mt lp c th c cc kiu sau y: 1. Kiu private - d liu ring 2. Kiu public - d liu chung 3. Kiu protected - d liu protected 4. Kiu class - d liu kiu lp 5. Kiu static - d liu tnh

Hm thnh phn trong mt lp c th c cc kiu sau y: 1. Kiu private - hm thnh phn ring 2. Kiu public - hm thnh phn chung 3. Kiu protected-hm thnh phn protect 4. Kiu static - hm thnh phn tnh 5. Constructor 6. Destructor 7. friend - hm thnh phn thn thin 8. Overloading Operator - Ton t ti bi 9. Overloading Function - Hm ti bi 10. virtual function - Hm o

Thnh phn private v thnh phn public

Cc thnh phn (d liu v hm) private ch c th truy nhp bn trong thn cc hm thnh phn trong lp m khng th truy nhp bn ngoi lp thng qua i tng ca lp. V d 2.3
class A { private: long x; void f(); public; double y; void g(); }; int main() { A a; a.x=10; // sai v x l d liu thnh phn private a.f(); // sai v f() l hm thnh phn private a.y=20; // ng v y l d liu thnh phn public a.g() ; // ng v g() l d liu thnh phn public

31

Nguyn Ch Trung
}

V d 2.4 Chng trnh sau y lm cc nhim v: Xy dng lp cc sinh vin, trong mi sinh vin bao gm cc thng tin: s bo danh, tn v nm sinh. S dng lp sinh vin ny to mt mng cc i tng l cc sinh vin. Thc hin cc thao tc trn danh sch sinh vin, gm: . Nhp d liu cho cc sinh vin . In ln mn hnh danh sch cc sinh vin c nm sinh no nhp t bn phm. . In ln mn hnh danh sch cc sinh vin c sp xp tng dn theo tn.
#include <iostream.h> #include <conio.h> #include <stdio.h> #include <string.h> class SINHVIEN { int sbd; char ten[30]; int ns; public: char *getten(); int getns() {return ns;} void nhapsv(); void xemsv(); }; char* SINHVIEN::getten() {int len=strlen(ten); char *s = new char[len]; strcpy(s,ten); return s; } void SINHVIEN::nhapsv() { cout<<"so bao danh : "; cin>>sbd; cout<<"ten: "; gets(ten); cout<<"nam sinh: "; cin>>ns;} void SINHVIEN::xemsv() { cout<<sbd<<" " <<ten<<" " <<ns<<endl; } const n = 4; SINHVIEN a[n]; void nhapdssv() { for(int i=0;i<n;i++) {a[i].nhapsv();} }

32

Nguyn Ch Trung
void xemdssv() { for(int i=0;i<n;i++) {a[i].xemsv();} cout<<endl; } void xemns() { int x; cout<<"nhap nam sinh : "; cin>>x; cout<<"danh sach sinh vien sinh nam "<<x<<":\n"; for(int i=0;i<n;i++) if (a[i].getns()==x) a[i].xemsv(); cout<<endl; } void swap(int i,int j) {SINHVIEN tg=a[i]; a[i]=a[j]; a[j]=tg; } void sapxepten() { int i,j,k; for(i=0;i<n;i++) { k=i; for(j=i+1;j<n;j++) if (strcmp(a[j].getten(),a[k].getten())<0) k=j; if (k!=i) swap(i,k); } } void main() { nhapdssv(); xemns(); sapxepten(); xemdssv(); getch(); }

D liu thnh phn static

V hnh thc: Nu t t kho static trc cc khai bo thnh phn th d liu l d liu thnh phn tnh (hoc gi l d liu thnh phn static) V bn cht: D liu thnh phn static ch c mt bn sao duy nht dng chung cho tt c cc i tng trong mt lp. V d khai bo class A { static int c; int n; ... } a,b; S to ra 2 i tng a v b c chung thnh phn d liu c: a.c a.n 33 b.c b.n

Nguyn Ch Trung Nh vy, cc bin thnh phn static c bn cht l cc bin ton cc trong phm vi ca lp. D liu thnh phn tnh thng c s dng duy tr nhng gi tr dng chung cho c lp. Mi mt i tng trong lp ng nhin c thnh phn d liu private l thnh phn ring ca n v c bao bc, che du. Thnh phn d liu public ca mt i tng suy cho cng cng vn l s hu ring ca i tng, nhng c th c i tng th hin ra bn ngoi. Mt thnh phn d liu static c khai bo trong mt lp th s khng l ca ring bt k i tng no trong lp v tt c cc i tng ca lp s dng chung thnh phn d liu static ny. V ngha, tc dng: Thnh phn static trong lp l cn thit m bo tnh y khi m t th gii thc. Cc thc th cng loi khi tn ti c nhng ci ring c ng kn, c ci ring c th bc l v c ci chung (ci chung ch c loi thc th ang xt) V cch s dng: Khi i tng u tin ca lp c to lp th nhng bin static c t khi gn bng 0. V thnh phn static dng chung cho tt c cc i tng ca lp nn khng th truy nhp thnh phn static thng qua mt i tng c th no trong lp m phi thng qua chnh tn lp cng vi ton t phn gii min xc nh. Trc khi s dng cc i tng trong lp phi c mt lnh c bit khi to bin static. Nu khng c lnh ny th chng trnh s bo li.
static_type class_name::var_static;

V d 2.5 V d di y to mt lp X vi c l mt bin nguyn kiu static v n l mt bin nguyn thuc thnh phn private.
#include <iostream.h> #include <conio.h> class X { static int c; int n; public: void get(int a) { n = a; c++; } void put(void) {cout<<" c :"<<c<<" n = "<<n<<endl; } }; int X::c; int main() { clrscr(); X a,b,c; a.get(10); b.get(20); c.get(30);

Kt qu: c: 3 n = 10 c: 3 n = 20 c: 3 n = 30

34

Nguyn Ch Trung
a.put(); b.put(); c.put(); getche();return 0; }

V c l bin static nn n ch c mt bn sao duy nht dng chung cho ba i tng a,b,c trong chng trnh. Mi khi mt i tng mi c to, gi tr ca bin static s c xt ti. Trong trng hp ny, gi tr ca bin static l c ln lt tng n 3 v dng chung cho c a,b,c. Ngc li vi c, bin n khng phi l bin static nn n c ba bn sao tng ng vi ba i tng khc nhau. Nu mun s dng bin c lm bin m tng s i tng v th hin th t cc i tng ln lt c to lp, ta nn thay i th t cc lnh trong main nh sau:
int X::c; int main() { clrscr(); X a,b,c; a.get(10); a.put(); b.get(20); b.put(); c.get(30); c.put(); getche();return 0; }

Kt qu: c: 1 n = 10 c: 2 n = 20 c: 3 n = 30

thy c ngha thc t ca thnh phn d liu static chng ta xem xt v d sau y: Gi s GROUP l mt nhm vi thnh vin trong cng mt phng lm vic. Do yu cu cng vic, h c mt my tnh mnh dng chung v truy cp vo mng internet bng phng php quay s (dial up). Tt c nhm u thng nht dng chung mt ti khon truy nhp mng (Acount) v mt khu i cng vi ti khon (Password). Tuy nhin, v mi ngi c cp mt quyn ring khi khai thc ti nguyn v hn na, tng ngi u c cc thit lp khc nhau v h thng nn trc khi truy cp vo mng mi ngi phi khi ng h iu hnh v phi ng nhp tn login (login name) v mt khu login (login key) ca mnh. Vy, nu xem xt GROUP l mt lp th Acount v Password phi l thnh phn d liu static ca tt c cc i tng trong lp. Login name v Login key l thnh phn d liu tnh (ca tng i tng) ca lp. Ta c chng trnh hon chnh sau y: V d 2.6
#include <iostream.h> #include <conio.h> #include <stdio.h> #include <string.h> class GROUP { static long account; static long password; char *loginname;

Kt qu
login name: thu ha login key: 555 acount:1032004 password:2004310 login name: tran binh login key: 666 acount:1032004 password:2004310

35

Nguyn Ch Trung
double loginkey; public: void get(char *s,double k) {int len=strlen(s); loginname = new char[len+1]; strcpy(loginname,s); loginkey=k;} void put() { cout<<"login name: "<<loginname<<endl; cout<<"login key: "<<loginkey<<endl; public_info(); } void public_info() { cout<<"acount: "<<account<<endl; cout<<"password: "<<password<<endl<<endl;} }; long MEMBER::account=1032004; long MEMBER::password=2004103; int main() { clrscr(); MEMBER t1,t2; t1.get("Thu Ha",555); t2.get("Tran Binh",666); t1.put(); t2.put(); getche(); return 0; }

Hm thnh phn static

Nu nh tt c cc i tng trong cng mt lp c th chia s, dng chung d liu static th l t nhin cng s chia s, dng chung mt s phng thc no , cc phng thc ny thng c s dng thao tc trn cc d liu static. Cc phng thc dng chung ny chnh l hm thnh phn static. Nu t t kho static trc cc khai bo hm thnh phn th l hm thnh phn tnh (hay hm thnh phn static) Hm thnh phn static ch c th truy nhp ti nhng thnh phn tnh trong lp (tt nhin, ngc li cc thnh phn tnh (d liu v hm) vn c th truy nhp bi cc hm thnh phn bnh thng khc). Nh vy hm thnh phn tnh c s dng thc hin nhng cng vic c tnh cht chung chung cho tt c cc i tng trong lp, chng hn truy nhp ti d liu thnh phn tnh. Cng ging nh d liu thnh phn tnh, hm thnh phn tnh khng l ca ring tng i tng trong lp, do khng truy nhp thng qua tn i tng m c gi thng qua tn lp cng vi ton t phn gii min xc nh.
class_name:: static_function(arg_list) ;

V d 2.6 36

Nguyn Ch Trung Lp MEMBERS m t lp cc thnh vin ca mt t chc. Mi mt thnh vin gm m s ring (code). Tt c cc thnh vin u bit c (dng chung) thng tin v tng s thnh vin trong t chc (bin tnh count) thng qua phng thc dng chung (hm tnh show_count() )
#include <iostream.h> #include <conio.h> class MEMBERS { static int count; double code; public: void get_member(double value) {count++; code=value;} void show_code(){cout<<"code: "<<code<<endl;} static void show_count() {cout<<"count of members: "<<count<<endl;} }; int MEMBERS::count; int main() { clrscr(); MEMBERS t1,t2,t3; t1.get_member(100); t2.get_member(200); t3.get_member(300); MEMBERS::show_count(); // kq: number of members:3 t1.show_code(); // kq: member: 100 t2.show_code(); // kq: member: 200 t3.show_code(); // kq: member: 300 getche(); return 0; }

D liu thnh phn kiu lp class

Cng nh kiu d liu struct, class cng c th coi l mt kiu d liu v do , mt thnh phn ca lp cng c th c kiu class. V d 2.7
#include <iostream.h> #include <conio.h> class A { public: int x; class SubA { public: int y; }; };

37

Nguyn Ch Trung
int main() { A a; A::SubA a1; int m=a.x=10; int n=a1.y=20; cout<<"class A, x = "<<m<<endl; cout<<"Sub class A, y = "<<n<<endl; getche(); return 0; }

V d 2.8
class First { public: int n; // cac ham thanh phan }; class Second { int id; public: int m; First obj; // cac ham thanh phan };

Hm thnh phn thn thin (friend function)

Hm thnh phn thn thin l mt trong nhng hm c bit v quan trng trong lp. Hm thnh phn thn thin khng thuc min xc nh ca lp, ni n c khai bo l thn thin (nh t kho friend). Do : Hm thnh phn thn thin nu c nh ngha bn ngoi lp th n c nh ngha nh mt hm bnh thng. Khng truy nhp hm thn thin bi i tng ca lp m truy nhp n nh mt hm bnh thng. Khai bo hm thn thin bn trong lp:
friend return_type fun_name(arg_list);

nh ngha hm thn thin bn ngoi lp:

return_type fun_name(arg_list) { // ni dung hm thn thin}

Sau y ta xem xt mt s trng hp ph bin khi s dng hm thnh phn thn thin: i truyn vo hm thn thin thng l i tng c kiu d liu l lp

38

Nguyn Ch Trung V d 2.9 V d sau y minh ho vic xy dng lp cc phn s. Trong , cc php ton: nhp, xem, ti gin v cng phn s c th hin bng cc hm thn thin.
#include <iostream.h> #include <conio.h> class FRAC { int t,m; public: void read(); friend void write(FRAC); friend void reduce(FRAC&); friend FRAC sum(FRAC,FRAC); }; void FRAC::read() { cout<<"tu so:"; cin>>t; do { cout<<"mau so:"; cin>>m; } while (m==0); } void write(FRAC P) { reduce(P); cout<<P.t<<"/"<<P.m; } void reduce(FRAC& P) { int i,j; i=P.t; j=P.m; while(i!=j) if(i>j) i-=j; else j-=i; P.t=P.t/i; P.m=P.m/j; } FRAC sum(FRAC P,FRAC Q) { FRAC R; R.t=P.t*Q.m + Q.t*P.m; R.m=P.m*Q.m; reduce(R); return R; } int main() { clrscr(); FRAC p,q; p.read(); q.read(); write(p); cout<<" + "; write(q); cout<<" = "; write(sum(p,q)); getche();

39

Nguyn Ch Trung
return 0;}

Vai tr ca hm thn thin lc ny l cho php s dng chng nh nhng hm bnh thng thao tc trn i tng hoc x l chnh d liu ca lp m khng cn truy nhp qua i tng ca lp. Gia hai lp c th thn thin ti mt hm thnh phn (thn thin) no . hm int f(...) l hm thn thin gia lp X v lp Y, ta vit:
class X; // khai bo trc class Y {... friend int f(X,Y); ... }; class X {... friend int f(X,Y); ... };

V d 2.10
#include <iostream.h> #include <conio.h> class ABC; class XYZ { int x; public: void setvalue(int x1) { x=x1;} friend int max(XYZ,ABC); }; class ABC { int a; public: void setvalue(int a1) { a=a1;} friend int max(XYZ,ABC); }; int max(XYZ xyz, ABC abc) { return xyz.x>abc.a ? xyz.x:abc.a; } int main() { clrscr(); XYZ p; ABC q; p.setvalue(100); q.setvalue(1000); cout<<"max object p,q = "<<max(p,q);

40

Nguyn Ch Trung
getche(); return 0;}

Mt lp c th thn thin vi mt lp khc khai bo Y l lp bn ca lp X th trong nh ngha lp X ta khai bo: friend class Y; Thng th dng khai bo " Y l bn ca X " c mc ch l cho php cc hm ca lp Y c th truy nhp ti d liu thnh phn ca lp X thng qua con tr i tng lp X (thng l d liu private), chiu ngc li l khng c. V d 2.11
#include <iostream.h> #include <conio.h> class X { int x; friend class Y; // Y la ban cua X void showX(); public: void getX(int x1) { x=x1;} }; void X::showX() { cout<<"class X: x = "<<x<<endl;} class Y { int y; public: void getY(int y1) { y=y1;} void showY(X *ptr); }; void Y::showY(X *ptr) { cout<<"class Y: y = "<<y<<endl; cout<<"class Y: x = "<<ptr->x<<endl; ptr->showX(); } int main() { clrscr(); X m; Y n; m.getX(100); n.getY(50); n.showY(&m); getche(); return 0; }

41

Nguyn Ch Trung i tng trong tham s ca hm Trong lp trnh hng i tng, tham s ca hm c th l i tng (c kiu lp). Tu theo tng trng hp ta c th s dng mt trong ba cch cch truyn tham s (theo tham tr, theo con tr v theo tham chiu). Tuy nhin gia con tr v tham chiu th phong cch ca C++ u dng truyn theo tham chiu hn c. V d 2.12 V d sau y minh ho rng khi khng c nh thay i i tng trong hm hoc khng mun gi li i tng b hm lm thay i th ta truyn theo tham tr.
#include <iostream.h> #include <conio.h> class time { int h,m; public: void gettime(int h1,int m1) { h=h1;m=m1;} void puttime(void) {cout<<h<<" hours "<<m<<" minutes." <<endl;} void sum(time,time); }; void time::sum(time T1,time T2) { m=T1.m+T2.m; h=m/60; m=m%60; h=h+T1.h+T2.h; T1.h=T1.h+1; } void main() { time T1,T2,T3; T1.gettime(2,45); T2.gettime(3,30); T3.sum(T1,T2); T1.puttime(); T2.puttime(); T3.puttime(); getche(); }

V d 2.13 Khi truyn cho hm tham s l i tng v thy cn thit phi thay i i tng trong hm th ta truyn cho hm hoc con tr i tng hoc "b danh" ca i tng - tc l cch truyn theo tham chiu.

42

Nguyn Ch Trung Trong v d di y minh ho vic truyn i theo tham chiu hon i gi tr ca hai i tng ca hai lp khc nhau qua mt hm thn thin: void exchange(POINT&,FRAC&);
#include <iostream.h> #include <conio.h> class POINT; class FRAC { int t,m; public: void getdata(int a,int b) { t=a; m=b;} void display() { cout<<t<<"/"<<m<<endl;} friend void exchange(POINT&,FRAC&); }; class POINT { int x,y; public: void getdata(int a,int b) { x=a;y=b;} void display() { cout<<"("<<x<<","<<y<<")"<<endl;} friend void exchange(POINT&,FRAC&); }; void exchange(POINT &p,FRAC &q) { int z=p.x; p.x=q.t; q.t=z; z=p.y; p.y=q.m; q.m=z; } int main() { clrscr(); POINT a; a.getdata(5,6); FRAC b; b.getdata(2,3); cout<<"before exchange:\n" a.display(); b.display(); exchange(a,b); cout<<"after exchange:\n" a.display(); b.display(); getche(); return 0; }

Kt qu before exchange: (5,6) (2/3) after exchange: (2,3)

(5/6)

43

Nguyn Ch Trung CONSTRUCTOR V DESTRUCTOR Khi nim chung 1. Constructor (c th dch l hm khi to) v destructor (hm hy b) l hai hm thnh phn c bit ca lp. 2. Constructor l hm thnh phn cho php khi to d liu ca i tng mt cch t ng khi n c khai bo sau tn lp. 3. Destructor l hm thnh phn cho php hu b i tng mt cch t ng khi khng cn dng n i tng trong chng trnh na. 4. Khi khng khai bo constructor v destructor trong lp th constructor ngm nh v destructor ngm nh c t ng to ra, l constructor v destructor khng tham s v cng khng c ni dung (thn hm). Constructor ngm nh th t ng gn d liu ca i tng bng 0 khi i tng c to lp, cn destructor th gii phng b nh dnh cho i tng khi thot khi chng trnh. 5. V mt c php, tn constructor phi trng vi tn lp, tn destructor cng phi trng vi tn lp nhng vit sau k hiu "ng" ~. C hai hm thnh phn c bit ny u khng c khai bo kiu d liu. Constructor c th c tham s nhng Destructor th khng c tham s. Khai bo v nh ngha constructor v destructor
Khai bo v phn loi
class class_name {... class_name(); //constructor khng tham s, l //constructor ngm nh class_name(arg_list); //constructor c tham s, l //constructor khi to class_name(class_name&); //constructor tham s l i tng // l constructor sao chp ~class_name(){} // Destructor,khng tham s, khng // ni dung, l ngm nh. ... };

nh ngha constructor

Constructor c tn gi c bit, khai bo v nh ngha cng c bit, khng cn ch ra phn kiu tr li ca hm nh i vi nhng hm thnh phn khc.
class_name::class_name([arg_list]) { // ni dung constructor tng ng. }

Constructor vi tham s truyn gi tr mc nh rt hay c s dng v n cng tun theo nguyn tc ca hm vi tham s ngm nh:

44

Nguyn Ch Trung Khi constructor c gi khng tham s th cc gi tr mc nh c t ng gn vo cc tham s vng mt. Khi khai bo, cc tham s ngm nh phi khai bo sau cng. Khi gi thc hin th khng c ngt qung tham s. Ngoi ra, vic to lp i tng vi s lng v th t cc tham s phi ph hp vi vic khai bo cc constructor trong lp. V d 2.14
#include <iostream.h> #include <conio.h> #include <graphics.h> #include <stdlib.h> // dung cho ham randomize #include <dos.h> // dung cho ham delay class CIRCLE { float x,y; double r; public: CIRCLE() {x=y=r=0;} // constructor ngam dinh CIRCLE(double r1, int x1=200, int y1=100) // constructor co tham so {x=x1; y=y1; r=r1;} CIRCLE(CIRCLE &C) // constructor sao chep { x=C.x;y=C.y;r=C.r;} ~CIRCLE() {} friend void draw(CIRCLE C) {circle(C.x,C.y,C.r);} }; void main() {CIRCLE c1(250); // su dung gia tri ngam dinh x=200, y=100 CIRCLE c2(350,250);// su dung gia tri ngam dinh y=100 CIRCLE c3(300,300,100); CIRCLE c4=CIRCLE(c1);//dung Constructor sao chep tuong minh CIRCLE c5=c3; // dung Constructor sao chep khong tuong minh int drive=DETECT,mode; initgraph(&drive,&mode,"c:\\tc\\bgi"); randomize(); for(int i=0;i<10;i++) { setcolor(random(15)+1); draw(c1); draw(c2); draw(c3); delay(100); setcolor(random(15)+1); draw(c4); draw(c5);

45

Nguyn Ch Trung
delay(100); } getch(); closegraph(); }

S dng constructor sao chp thng qua ton t gn, v c 2 cch s dng: tng minh v khng tng minh. Ton t gn (=) gia cc i tng cn c th xy dng cch th hai l ton t ti bi m ta s nghin cu phn tip theo. c bit, iu ny s c bn k trong 2.4.6 nghin cu lp String. Cc constructor s c s dng nhiu sau ny trong cc lp c quan h k tha. a s destructor trong lp n gin khng cn c ni dung bn trong, do , a s l destructor ngm nh, vy c th khng cn khai bo destructor loi ny. Tuy nhin khi c vn cp pht ng cho cc i tng trong chng trnh th nn c destructor hu b i tng bng cch gii phng b nh c cp pht . Con tr this Trong khi nh ngha lp, cha c i tng thc s no ca lp c to lp. Lc , vic truy nhp vo thnh phn d liu trong thn cc hm thnh phn thng qua mt i tng n m i tng ny c xc nh bi mt con tr c bit, l con tr this. Vai tr ca con tr this gii thch c vic biu din cho i tng c lin quan n hm thnh phn ang c thc hin. V d: Xt Constructor (hoc mt hm thnh phn bt k) ca lp A:
class A { int x; A(int x1){ x=x1;} ... };

Thc cht, Constructor A(x1) trn s dng con tr this xc nh cho mt i tng n tr vo thnh phn d liu x:
A(int x1) {this->x=x1;}

V d 2.15
#include <iostream.h> #include <conio.h> #include <stdio.h> class A { int x,y; public:

46

Nguyn Ch Trung
A() {x=y=0;} A(int x1,int y1) {this->x=x1; this->y=y1;} void show() {cout<<this->x<<","<<this->y<<endl;} }; int main() { clrscr(); A a(3,4),b(5,6); a.show(); b.show(); getche(); return 0; }

Mt ng dng quan trng ca con tr this l n tr li i tng m n tr ti bng lnh return *this trong trng hp m khai bo tn i tng l khng thun li. V d 2.16
#include <iostream.h> #include <conio.h> #include <string.h> class CANBO { char *ten; int tuoi; public: CANBO(char*,int); CANBO& gia_hon(CANBO&); void xem(void); }; CANBO::CANBO(char *s,int a) { int k=strlen(s); ten = new char[k+1]; strcpy(ten,s); tuoi=a;} CANBO& CANBO::gia_hon(CANBO &x) { if (x.tuoi>=tuoi) return x; else return *this; } void CANBO::xem() { cout<<"ten:"<<ten<<endl; cout<<"tuoi:"<<tuoi<<endl; } int main() { clrscr(); CANBO a("TUNG QUAN",32), b("CHI DUNG",25),

47

Nguyn Ch Trung
c("THANH THAO",38); CANBO p("",0); p=a.gia_hon(b); cout<<"nguoi lon tuoi hon la: "; p.xem(); p=p.gia_hon(c); cout<<"nguoi lon tuoi nhat la: "; p.xem(); getch(); return 0; }

TON T TI BI V TON T TI BI THN THIN Khi qut chung Ton t ti bi l ton t cho php nh ngha chng, tc l cho php dng mt k hiu ton t nh ngha nhiu cng vic (php ton) khc nhau. Ton t ti bi l mt hm thnh phn ca lp, nn bn ngoi lp n c s dng thng qua i tng. Ton t ti bi thn thin l mt ton t ti bi khai bo bn trong lp sau t kho friend v khng c xem nh mt hm thnh phn ca lp. N c s dng nh mt php ton thng thng v thch hp cho vic x l cc i tng ca lp (cc s hng tham gia vo php ton do thng l cc i tng). S ngi ca ton t ti bi thn thin bng s ngi ca ton t gc. S ngi ca ton t ti bi t hn 1 so vi s ngi ca ton t gc. Quy nh v cc ton t gc c ti bi nh sau: Ch c cc ton t trong C++ mi c ti bi, tr cc ton t sau y: ::, .*, . , ?: , sizeof() Cc ton t sau y c th ti bi nhng khng ti bi thn thin. = , () , [] , Ton t ti bi
Khai bo ton t ti bi
class class_name {... public: ... return_type operator (arg_list); ... };

nh ngha ton t ti bi
return_type class_name::operator (arg_list) { // ni dung ton t }

48

Nguyn Ch Trung
Cc v d

V d 2.17 nh ngha ton t ti bi mt ngi: ly i ca i tng thuc lp cc v tr trong khng gian.

#include <iostream.h> #include <conio.h> class SPACE { int x,y,z; public: void getdata(void); void display(void); void operator -(); }; void SPACE::getdata() { cout<<"x= "; cin>>x; cout<<"y= "; cin>>y; cout<<"z= "; cin>>z; } void SPACE::display() { const char *p=","; cout<<"("<<x<<p<<y<<p<<z<<")"<<endl; } void SPACE::operator -() { x=-x; y=-y;z=-z; } int main() { SPACE s; s.getdata(); s.display(); -s; s.display(); getche(); return 0; }

Lu :Lnh SPACE s1=-s; khng thc hin v hm operator -() kiu void, mun thc hin c lnh ny th cn i kiu void thnh kiu SPACE Vai tr ca con tr this trong ton t ti bi Ta bit rng, trong ton t ti bi th nu s ngi ca ton t gc l hai th s ngi ca ton t ti bi s l mt. V d:
class A { int x,y;

49

Nguyn Ch Trung
public: A operator +(A a) { A b ; b.x=x+a.x; b.y=y+a.y;return b;} };

Thc cht, ton t ti bi + ni trn vn c hai ngi. Ngi th nht l i tng n xc nh bng con tr this, ngi th hai l i tng a ca ton t.
A operator +(A a) {A b; b.x=this->x+a.x; b.y=this->y+a.y; return b;}

V d 2.18 V d sau y mnh ho v vic nh ngha ton t ti bi 2 ngi: Xy dng lp cc s phc (COMPLEX) vi cc php ton ti bi cng, tr, nhn hai s phc.
#include <iostream.h> #include <conio.h> class COMPLEX { float x,y; public: COMPLEX() {x=y=0;} COMPLEX(float a) {x=y=a;} COMPLEX(float a,float b) {x=a;y=b;} COMPLEX(COMPLEX &Z) {x=Z.x; y=Z.y;} COMPLEX operator + (COMPLEX);//cng 1 s phc vi 1 s phc COMPLEX operator - (COMPLEX);// tr 1 s phc cho 1 s phc COMPLEX operator * (COMPLEX);// nhn 1 s phc vi 1 s phc COMPLEX operator * (float); // nhn 1 s phc vi 1 s thc void show(); }; void COMPLEX::show() { cout<<x<<" + i * "<<y<<endl;} COMPLEX COMPLEX::operator +(COMPLEX z1) { COMPLEX z2; z2.x = x + z1.x; z2.y = y + z1.y; return z2;} COMPLEX COMPLEX::operator -(COMPLEX z1) { COMPLEX z2; z2.x = x - z1.x; z2.y = y - z1.y; return z2;}

50

Nguyn Ch Trung
COMPLEX COMPLEX::operator *(float r) { COMPLEX z2; z2.x = x * r; z2.y = y * r; return z2;} COMPLEX COMPLEX::operator *(COMPLEX z1) { COMPLEX z2; z2.x = x * z1.x - y*z1.y; z2.y = x * z1.y + y*z1.x; return z2;} int main() { clrscr(); COMPLEX m(5.3); // dng Constructor 1 tham s COMPLEX n(3.4,2.1); // dng Constructor 2 tham s cout<<"m = "; m.show(); cout<<"n = "; n.show(); COMPLEX p;//dng Constructor ngm nh, khng tham s p=m.operator +(n);//dng ton t cng tng mnh cout<<"m + n = "; p.show(); p=m-n; // dng ton t tr khng tng minh cout<<"m - n = "; p.show(); p=m*4.5 ; cout<<"m * 4.5 = "; p.show(); p=(m*4.5+n)*(m-n); cout<<"(m*4.5+n)*(m-n) = "; p.show(); getche(); return 0; }

V ta ch nh ngha php nhn mt s phc vi mt s thc nn lnh p=m*4.5 l ng, nhng lnh p=4.5*m; l sai. Trong trng hp ny s ngi ca cc ton t, v mt hnh thc ch c mt ngi v iu th hin ch ch c mt tham s truyn vo ton t. V mt bn cht th vn y hai ngi, ngi th hai chnh l i tng truyn vo ton t, ngi th nht chnh l i tng gi thc hin ton t (xem dng tng minh) v i tng ny c xc nh nh con tr this. Kt qu tr li l mt s phc cho nn cn nh ngha thm ton t ti bi gn = hin php gn dng: p= m+n; (th nghim cho thy chng trnh trn khng c constructor sao chp vn thc hin c php gn ny, song l cch khng r rng) Khi gi cc ton t ti bi, c 2 cch gi, v d php cng +
p=m.operator +(n);

l tng minh, v v bn cht th operator operator+(COMPLEX) l tn ca mt hm thnh phn, n thuc lp ni n c khai bo, do n c truy nhp 51

Nguyn Ch Trung thng qua i tng ca lp. Php cng c 2 ngi, y m l ngi th nht, n l ngi th 2.
p=m+n;

l khng tng minh. Thc t cho thy, mc d khng tng minh nhng C++ cho khuyn khch dng dng t nhin ny. (Ch tt c cc dng khng tng minh, ni chung, c C++ ngm t chuyn v dng tng minh) Ton t ti bi thn thin Ton t ti bi thn thin khng thuc lp ni n c khai bo, do vy ton t ti bi thn thin dng nh mt php ton thng thng m khng phi s dng thng qua i tng. Cng chnh v l do m ton t ti bi thn thin c s ngi bng s ngi ca ton t gc tc l php ton c sn ca ngn ng.
Khai bo ton t ti bi thn thin
class class_name {... public: ... friend return_type operator (arg_list); ... };

nh ngha ton t ti bi
return_type operator (arg_list) { // ni dung ton t }

V d 2.19 Xy dng lp cc s phc (COMPLEX) vi cc php ton ti bi thn thin cng, tr, nhn hai s phc vi nhau.
#include <iostream.h> #include <conio.h> class COMPLEX { float x,y; public: COMPLEX() {x=y=0;} COMPLEX(float a) {x=y=a;} COMPLEX(float a,float b) {x=a;y=b;} COMPLEX(COMPLEX &Z) {x=Z.x; y=Z.y;} friend COMPLEX operator + (COMPLEX,COMPLEX); friend COMPLEX operator - (COMPLEX,COMPLEX); friend COMPLEX operator * (COMPLEX,float);

52

Nguyn Ch Trung
friend COMPLEX operator * (float,COMPLEX); friend COMPLEX operator * (COMPLEX,COMPLEX); friend ostream& operator << (ostream&, COMPLEX &); friend istream& operator >> (istream&, COMPLEX &); }; COMPLEX operator +(COMPLEX z1,COMPLEX z2) {COMPLEX z; z.x = z1.x + z2.x; z.y = z1.y + z2.y; return z;} COMPLEX operator -(COMPLEX z1,COMPLEX z2) {COMPLEX z; z.x = z1.x - z2.x; z.y = z1.y - z2.y; return z;} COMPLEX operator *(COMPLEX z1,float r) {COMPLEX z; z.x = z1.x * r; z.y = z1.y * r;return z;} COMPLEX operator *(float r,COMPLEX z1) {COMPLEX z; z.x = r*z1.x ; z.y = r*z1.y;return z;} COMPLEX operator *(COMPLEX z1,COMPLEX z2) {COMPLEX z; z.x = z1.x * z2.x - z1.y*z2.y; z.y = z1.x * z2.y + z1.y*z2.x; return z;} ostream& operator << (ostream &dout, COMPLEX &z) { dout<<z.x<<" + i * "<<z.y <<endl; return dout;} istream& operator >> (istream& din, COMPLEX& z) { float x1,y1; cout<<"x= "; din >> x1; z.x=x1; cout<<"y= "; din >> y1; z.y=y1; return din;} int main() { clrscr(); COMPLEX m,n; cout <<"nhap so phuc m: \n"; cin>>m; cout <<"nhap so phuc n: \n"; cin>>n;

53

Nguyn Ch Trung
cout <<"m =" << m; cout <<"n =" << n; cout <<"m+n =" << m+n; cout <<"m-n =" << m-n; cout <<"m*n =" << m*n; cout <<"(m+n)*(m-n) =" << (m+n)*(m-n); getche(); return 0; }

Mt so snh quan trng: Chng ta cn so snh v cch s dng php ton ti bi (nh mt hm thnh phn ca lp) v php ton ti bi thn thin. Php ton y c th l ton t gc ca ngn ng hoc hm ngi dng nh ngha. Hai trch dn v d di y l nhn mnh vic so snh v cc php vo/ra ti bi v vo/ra ti bi thn thin: cch khai bo, cch nh ngha v cch gi thc hin: V d 2.20 (a) Xy dng php ton ti bi thn thin ton t vo/ ra thc hin vo/ra s phc:
class COMPLEX { float x,y; public: friend ostream& operator << (ostream&, COMPLEX &); friend istream& operator >> (istream&, COMPLEX &); }; ostream& operator << (ostream &dout, COMPLEX &z) { if (z.y=0) dout<<z.x; else dout<<z.x<<(z.y>0?"+":"-")<<"i"<<z.y <<endl; return dout; } istream& operator >> (istream& din, COMPLEX& z) { float x1,y1; cout<<"x= "; din >> x1; z.x=x1; cout<<"y= "; din >> y1; z.y=y1; return din; } int main() { clrscr();

54

Nguyn Ch Trung
COMPLEX m,n,p; cout<<"nhap so phuc m: \n"; cin>>m; cout<<"nhap so phuc n: \n"; cin>>n; p=m+n; cout<<m<<"+\n"<<n<<"=\n"<<p; getche(); return 0;}

V d 2.20 (b) Xy dng php ton ti bi bnh thng (khng thn thin) ton t vo/ ra thc hin vo/ra s phc:
class COMPLEX { float x,y; public: ostream& operator << (ostream&); istream& operator >> (istream&); }; ostream& COMPLEX::operator << (ostream &dout) { if (y=0) dout<<x; else dout<<x<<(y>0?"+":"-")<<"i"<<y <<endl; return dout; } istream& COMPLEX::operator >> (istream& din) { float x1,y1; cout<<"x= "; din >> x1; x=x1; cout<<"y= "; din >> y1; y=y1; return din; } int main() { clrscr(); COMPLEX m,n,p; cout<<"nhap so phuc m: \n"; m.operator >>(cin); cout<<"nhap so phuc n: \n"; n.operator >>(cin); p=m+n; m.operator<<(cout); cout << "+\n"; n.operator<<(cout); cout << "=\n"; p.operator << (cout); getche(); return 0;}

55

Nguyn Ch Trung R rng trong trng hp ny dng ton t vo/ra ti bi khng thn thin l khng t nhin trong cch s dng. V d 2.21 Xy dng lp cc phn s (FRAC) vi cc php ton ti bi thn thin cng, tr, nhn v chia phn s cng vi cc php ton vo/ra phn s.
#include <iostream.h> #include <conio.h> #include <math.h> class FRAC { int t,m; public: FRAC() {t=m=0;} FRAC(float a,float b) {t=a;m=b;} FRAC(FRAC &p) {t=p.t; m=p.m;} friend FRAC reduce(FRAC); friend FRAC operator + (FRAC,FRAC); friend FRAC operator - (FRAC,FRAC); friend FRAC operator * (FRAC,FRAC); friend FRAC operator / (FRAC,FRAC); friend ostream& operator << (ostream&, FRAC &); friend istream& operator >> (istream&, FRAC &); }; FRAC reduce(FRAC p) { int a=abs(p.t), b=abs(p.m); while(a!=b) if (a>b) a-=b; else b-=a; p.t=p.t/a; p.m=p.m/a; return p; } FRAC operator +(FRAC p1,FRAC p2) {FRAC p; p.t = p1.t*p2.m + p2.t*p1.m; p.m = p1.m*p2.m; return reduce(p); } FRAC operator -(FRAC p1,FRAC p2) {FRAC p; p.t = p1.t*p2.m - p2.t*p1.m;

56

Nguyn Ch Trung
p.m = p1.m*p2.m; return reduce(p); } FRAC operator *(FRAC p1,FRAC p2) {FRAC p; p.t = p1.t*p2.t; p.m = p1.m*p2.m; return reduce(p); } FRAC operator /(FRAC p1,FRAC p2) {FRAC p; p.t = p1.t*p2.m; p.m = p1.m*p2.t; return reduce(p); } ostream& operator << (ostream &dout, FRAC &p) { dout<<p.t<<"/"<<p.m; return dout; } istream& operator >> (istream& din, FRAC& p) { int a; cout<<"t= "; din >> a; p.t=a; do { cout<<"m= "; din >> a; p.m=a; } while (a==0); return din; } int main() { clrscr(); FRAC p,q; cout<<"nhap phan so p: \n"; cin>>p; cout<<"nhap so phuc q: \n"; cin>>q; cout<<"p ="<<reduce(p)<<endl; cout<<"q ="<<reduce(q)<<endl; cout<<"p+q ="<<p+q<<endl; cout<<"p-q ="<<p-q<<endl; cout<<"p*q ="<<p*q<<endl; cout<<"p/q ="<<p/q<<endl; getche(); return 0; }

V d 2.22 57

Nguyn Ch Trung Xy dng lp cc Vector (VECTOR) vi cc php ton ti bi thn thin cng, tr, nhn v hng hai vector v cc php vo/ra i vi vector. Ci t vector bng con tr float tr vo vector c s chiu n.
#include <iostream.h> #include <conio.h> const maxsize=10; class VECTOR { int n; float *v; public: VECTOR() {v =new float[maxsize];} VECTOR(VECTOR &); ~VECTOR() { delete v ;} int size() {return n;} friend VECTOR operator + (VECTOR,VECTOR); friend VECTOR operator - (VECTOR,VECTOR); friend float operator * (VECTOR,VECTOR); friend ostream& operator << (ostream&, VECTOR &); friend istream& operator >> (istream&, VECTOR &); }; VECTOR::VECTOR(VECTOR &b) { int i; v =new float[n=b.n]; for(i=0;i<n;v[i]=b.v[i],i++); } VECTOR operator +(VECTOR b,VECTOR c) {VECTOR d; d.n=b.n; int i; for(i=0;i<c.n;i++) d.v[i]=b.v[i]+c.v[i]; return d; } VECTOR operator -(VECTOR b,VECTOR c) {VECTOR d; d.n=b.n; int i; for(i=0;i<c.n;i++) d.v[i]=b.v[i]-c.v[i];

58

Nguyn Ch Trung
return d; } float operator *(VECTOR b,VECTOR c) {float d =0; int i; for(i=0;i<b.n;i++) d += b.v[i]*c.v[i]; return d; } ostream& operator << (ostream &dout, VECTOR &b) { int i; for(i=0;i<b.n;i++) dout<<b.v[i]<<" "; dout<<endl; return dout; } istream& operator >> (istream &din, VECTOR &b) { int i,x; cout<<"n= "; cin>>x; b.n=x; for(i=0;i<b.n;i++) {cout<<"vector["<<i+1<<"] ="; din>>x; b.v[i]=x; } return din;} int main() { clrscr(); VECTOR a,b; cout<<"nhap vec to a: \n"; cin>>a; cout<<"nhap vec to b: \n"; cin>>b; cout<<"a ="<<a; cout<<"n ="<<b; cout<<"a+n ="<<a+b; cout<<"a-n ="<<a-b; cout<<"a*n ="<<a*b; getch(); return 0; }

Chuyn i kiu Ti sao phi chuyn i kiu Xem xt li v d 1.15 (mc 2.5.10 gii thiu v kh nng ti bi ca hm v ton t), ta gp phi thng bo li "Ambiguity between 'Display(double)' and 'Display(long)' " trong lnh gi s dng mt cch nhp nhng hm Display(123). Chng t rng chng trnh khng th chn hm no nh ngha thc hin hm 59

Nguyn Ch Trung Display(123) m phi p 123 sang kiu long hoc double chn gi hm tng minh: Display(long(123)); // gi hm Display(long) hoc Display(double(123)); // gi hm Display(double) Nh vy chuyn i kiu trc ht l tho mn mt cch tng minh v kiu d liu ca mt biu thc (biu thc c mt v ch mt kiu d liu) t cc ton hng c th c kiu d liu khc nhau v cc ton t kt hp thnh biu thc . Chuyn i kiu thng c hai loi: Chuyn i kiu ngm nh (t ng) do chng trnh bin dch t ng thc hin. Chuyn i kiu tng minh (p kiu), thng gp trong cc lnh gi hm nhn vo cc tham s c kiu khc vi kiu ca i tng ng. Lp vi t cch nh mt kiu d liu c C++ cung cp cch thc chuyn kiu ngm nh v tng minh. Php chuyn kiu ngm nh c nh ngha qua Constructor, cn php chuyn kiu tng minh c xc nh thng qua ton t chuyn kiu hoc p kiu. Tip theo, ta s xem xt k hn cc vn c gii thiu.
Chuyn t kiu c s sang kiu c s.

Ring i vi vic chuyn t kiu c s sang kiu c s l do ngn ng t ng hoc do p kiu. T ng chuyn kiu theo nguyn tc: char int long float double Chuyn kiu c s dng trong li gi hm p kiu ca bin truyn vo hm cng kiu vi tham s hnh thc trong hm.
Chuyn t kiu lp sang kiu c s.

Nguyn tc: Trong lp c ton t quy hi kiu: l ton t ti bi, b sung nh ngha ton t kiu c s.
Khai bo class class_name; {... opearator type_name() ... };

nh ngha
type_name class_name::type_name() { // ni dung ton t}

V d 2.23 Chuyn t kiu VECTOR sang kiu double: Gn mt bin double bng mt vect (thc cht l bng tch v hng ca mt vector vi chnh n) 60

Nguyn Ch Trung
class VECTOR { private: int n; float *v; public: ... operator double() ... }; double VECTOR::double() { int i; double s=0; for(i=0;i<n; s += v[i]*v[i], i++); return s; }

C th ta c chng trnh sau:

#include <iostream.h> #include <conio.h> const maxsize=10; class VECTOR { int n; float *v; public: VECTOR() {v =new float[maxsize];} ~VECTOR() { delete v ;} friend ostream& operator << (ostream&, VECTOR &); friend istream& operator >> (istream&, VECTOR &); operator double(); }; double VECTOR::operator double() { double s=0; int i; for(i=0;i<n; s+=v[i]*v[i],i++); return s;} ostream& operator << (ostream &dout, VECTOR &b) { int i; for(i=0;i<b.n;i++) dout<<b.v[i]<<" "; dout<<endl; return dout;} istream& operator >> (istream &din, VECTOR &b) { int i,x; cout<<"n= "; cin>>x; b.n=x;

61

Nguyn Ch Trung
for(i=0;i<b.n;i++) {cout<<"vector["<<i+1<<"] ="; din>>x; b.v[i]=x; } return din;} int main() { clrscr(); VECTOR a; cin >> a; cout << a << endl; double d=a; cout << d << endl; getch(); return 0;}

Chuyn t kiu c s sang kiu lp.

Nguyn tc: Trong lp s dng constructor khi to m tham s ca constructor l kiu c s. V d 2.24 Chuyn t kiu char* sang kiu String thng qua constructor String(char *S). Gii thit text l mt d liu thnh phn ca lp String, text c khai bo l mt con tr kiu char.
String::String(char *S) { len=strlen(S); text = new char[len+1]; strcpy(text,S); }

Chuyn t kiu lp sang kiu lp

Nguyn tc: chuyn t lp X sang lp Y, trong lp Y phi c constructor khi to c bit nhn i l i tng ca lp X.
class X {// ni dung lp X }; class Y {... Y(X x); // chuyn t lp X ... }; void main() { X a; Y b=a;

lp Y

62

Nguyn Ch Trung
... }

V d 2.25 Cho lp MH1: M hng, S lng v n gi v lp MH2: M hng, Tng gi tr (Tng gi tr = S lng * n gi) V d sau y thc hin chuyn kiu lp MH1 sang kiu lp MH2:
#include <iostream.h> #include <conio.h> #include <stdio.h> class MH1 { int code; int num; float price; public: MH1() {code=num=price=0;} MH1(int c, int n, float p) { code=c; num=n; price=p; } void get_data() { cout << " code = "; scanf("%d",&code); cout << " num = "; scanf("%d",&num); cout << " price = "; scanf("%f",&price); } void show(void) { cout << " code: " << code << endl << " num : " << num << endl << " price : " << price << endl; } int get_code() { return code ;} int get_num() { return num ;} float get_price() { return price ;} operator double() { return num*price ;} }; class MH2 { int code; double total; public: MH2() {code=total=0;} MH2(int c, double t) { code=c; total=t; } MH2(MH1 p) { code = p.get_code(); total= p.get_num()*p.get_price(); }

63

Nguyn Ch Trung
void show(void) { cout << " code: " << code << endl << " total : " << total << endl; } }; int main() { MH1 m(4,20,35.6); MH2 n=m; m.show(); n.show(); MH1 a[3]; int i; for(i=0;i<3;i++) a[i].get_data(); double s=0; for(i=0;i<3;i++) s+=a[i]; cout<<"s = " <<s<<endl; getche(); return 0;}

chuyn t lp X sang lp Y c trng hp phi s dng cch sau y: Trong lp X phi c ton t ti bi m rng nh ngha kiuY. (Ging nh chuyn t kiu lp sang kiu c s, nhng lc ny kiu c s chnh l kiu lp Y nh ngha.) Trong lp Y ng thi phi nhn hm - ton t ny (ca lp X) l mt hm thn thin - tc l hm ny ca X l bn ca Y , nu n nhu cu c s dng d liu private ca Y.
class Y; // khai bo trc lp Y //-------------------class X {... operator Y(); //Y c coi l kiu d liu mi , chuyn t // kiu X sang kiu Y ... }; class Y { ... friend X::operator Y(); ... }; X::operator Y()

64

Nguyn Ch Trung
{ // ni dung ton t Y(), s dng c d liu ring ca Y }

V d 2.26 V d di y minh ho vic chuyn kiu t lp im (POINT) sang lp s phc (COMPLEX)

#include <iostream.h> #include <conio.h> #include <math.h> class COMPLEX; class POINT { int x,y; public: POINT(int ox=0,int oy=0) { x=ox;y=oy;} operator COMPLEX(); }; class COMPLEX { float a,b; public: COMPLEX(float a1=0,float b1=0) {a=a1;b=b1;} friend POINT::operator COMPLEX(); void display() {cout<<a<<" + i * "<<b<<endl;} }; POINT::operator COMPLEX() { COMPLEX C(x,y); return C; } int main() { clrscr(); POINT a(2,5); COMPLEX C; C=(COMPLEX)a; C.display(); getche(); return 0; }

65

Nguyn Ch Trung VI VN V S DNG T KHO CONST S dng bin kiu const Trong C v C++ cc bin kiu const khng c php thay i trong sut qu trnh chng trnh thc hin. Phm vi ca cc gi tr const trong C v C++ khc nhau: Trong C, cc gi tr const c phm vi ton cc, ngha l chng c th nhn thy cc tps khc, tr khi n c khai bo l static V d 1: (trong C)
const int i=5; /* cac tp khac deu nhan biet duoc i=5 */ static const int i = 5; /*cac tp khac khong biet duoc i=5 */

Trong C++, cc gi tr const c phm vi hot ng cc b trong tp chng c khai bo. cc tp khc c th nhn thy gi tr const ca tp hin ti ny th n phi c khai bo sau extern v cc tp phi nhc li khai bo extern const ny, nhng khng c vit li gi tr hng. V d 2: (trong C++)
const int i=5; /* cac files khac khong nhan biet duoc i=5 */ extern const int i = 5; /* cac files khac deu nhan biet duoc i = 5 neu cc file khac do phai nhac lai const i, nhung khong chi ra gia tri cua i */ extern const int i;

Lu : cc bin kiu const trong hm trong C++ lun lun c phm vi hot ng cc b trong hm . Mt cch logic suy ra l n khng c khai bo extern trong hm, ngha l mi const l extern phi c khai bo trc tt c cc hm. Tin li ca khai bo const: Mt bin khai bo kiu const tin li hn so vi vic s dng ch th #define khai bo hng. Bi v khi khai bo mt bin kiu const th ngoi vic gi tr ca n khng thay i trong qu trnh thc hin chng trnh, trnh bin dch cn c th thc hin vic kim tra kiu ca bin v tuy th vn khng cp pht b nh cho cc bin ny khi khng cn thit. V d 3:
const int TRUE = 1 const int FALSE = 0 while (TRUE) {... int a = FALSE ; }

Cc bin TRUE v FALSE s c thay th bng cc gi tr khi bin dch m khng cn phi phn b b nh cho chng. c th phn b b nh cho mt bin int i kiu const ta cn phi khai bo nh sau:
const int& i = 9;

Theo cch ny, i c xem nh tt c cc bin tham chiu khc ch c mt iu khc bit l gi tr ca n khng c php thay i khi thc hin chng trnh.

66

Nguyn Ch Trung Truyn tham s kiu const cho hm

ngha chung ca t kho const

Trong C cng nh trong C++, vic khai bo mt bin kiu const s quy nh bin ch c php c trong chng trnh. Mt cch tng qut, t kho const quy nh mt tn gi no trong chng trnh nh: bin, tham s ca hm, hm, v i tng khng c php thay i gi tr trong chng trnh.
Truyn tham s kiu const cho hm

T kho l const t pha trc khai bo i ca hm c tc dng quy nh: trong thn hm khng c php thay i gi tr ca i ny. V, do gi tr ca tham s truyn cho hm c gi nguyn khi ra khi hm. Xt 2 trng hp sau y: Trng hp truyn tham s cho hm kiu truyn theo tham tr (i ca hm l bin n thun): Nu ta ch mong mun gi tr ca tham s truyn cho hm c gi nguyn khi ra khi hm th vi nh ny vic s dng t kho const l khng cn thit v bn thn kiu truyn theo tham tr m bo c iu . Vy ta s ch dng t kha const cho tham s gi tr nu ta cn mun quy nh cht hn na, rng: Trong thn hm khng c php vit cc lnh lm thay i gi tr ca cc tham s . Trng hp tham s truyn cho hm c kiu con tr hoc kiu tham chiu th ta s dng t kho const t trc khai bo i nu ta mun m bo chc chn hoc nhn mnh rng khng c thay i gi tr ca tham s truyn cho hm trong thn hm (v do khng thay i gi tr khi ra khi hm). V d 2.27
#include <iostream.h> #include <conio.h> #include <stdio.h> #include <string.h> class ABC { private: char *name; public: void read_name(char *s); void get_name(const char *s); //s ch c dng, khng c sa void put_name(); }; void ABC::put_name() { cout <<"name: "<<name<<endl; } void ABC::read_name(char *s)

67

Nguyn Ch Trung
{ cout<<"Enter name: "; gets(s); int k=strlen(s); name=new char[k]; strcpy(name,s);} void ABC::get_name(const char *s) { int k=strlen(s); name=new char[k]; strcpy(name,s); } int main() { ABC a; char *s; a.read_name(s); a.put_name(); a.get_name("Nguyen Mai Lan"); a.put_name(); getche(); return 0; }

i tng hng ca lp Cng nh cc bin ni chung, bin l i tng cng c th khai bo l hng v gi l i tng hng. Thng thng th hai phng thc c bit trong lp c th s dng cc i tng hng, l constructor v destructor. Bi l cc i tng hng khng c php thay i m ch c th to ra bi constructor hoc hu b bi destructor. Cc ton t sao chp i tng dng:
class_name operator = (const class_name&)

cng s dng i tng hng truyn vo n. Ta cn lin h ti s phn bit 2 dng khai bo: const int i=5; v const int& j =5; S ging nhau trong hai dng khai bo trn l i v j u l cc hng v c kim tra kiu (l int) lc dch chng trnh. S khc nhau trong hai dng khai bo trn l: i khng c phn phi b nh cn j th c phn phi b nh nh mt bin kiu tham chiu bnh thng, ch khc mt iu gi tr ca j khng c thay i trong sut qu trnh chy chng trnh. Trong constructor sao chp v ton t sao chp, i tng khai bo hng phi dng tham chiu v lin quan n vic to lp i tng khi chy chng trnh, ngha l phi phn phi b nh. V d 2.28 68

Nguyn Ch Trung
#include <iostream.h> #include <conio.h> #include <stdio.h> #include <string.h> class ABC { private: char *name; public: ABC(){} ABC(char *s); // constructor khi to (1) ABC(const ABC&); // constructor sao chp (2) ~ABC(){} void put_name(); }; void ABC::put_name() { cout <<"name: "<<name<<endl; } void ABC::ABC(char *s) { int k=strlen(s); name=new char[k]; strcpy(name,s);} void ABC::ABC(const ABC &b) { int k=strlen(b.name); name=new char[k]; strcpy(name,b.name); } int main() { clrscr(); ABC const a("Nguyen Thanh Thao"); // s dng (1) ABC b(a); // s dng (2) b.put_name(); ABC c("Le Hai Ha"); // s dng (1) b=c; // s dng (2) khng tng minh b.put_name(); getche(); return 0;}

Trong v d trn, nn khai bo constructor khi to vi tham s const v tham s s lc ny khng phi nhp t bn phm, ngha l ta nn vit li khai bo constructor ny l:
void ABC::ABC(const char *s)

69

Nguyn Ch Trung Hm thnh phn const (hm thnh phn c khai bo const pha sau) C++ cn cho php to ra cc hm thnh phn c bit khc x l i tng hng. Khi hm thnh phn ny phi c khai bo t kho const cui khai bo hm v n c gi l hm thnh phn const:
return_type fun_name(agr_list) const { // ni dung hm }

Hm thnh phn const ch x l cc i tng const, v l do nn ta c cc kt qu sau y: (1) Hm thnh phn const khng c thay i ni dung ca i tng trong thn hm. (2) Hm thnh phn const c th nh ngha chng bng mt hm thnh phn khc khng phi l hm thnh phn const. Khi , c th "chuyn mn ho" cc hm nh ngha chng. Cc hm thnh phn const lm vic vi cc i tng const, cc hm thnh phn khng phi l const lm vic trn cc i tng khng phi l const. Ta hy so snh hai v d sau y: V d 2.29 (a)
#include <iostream.h> #include <conio.h> class ABC { int x; public: ABC(int x1) {x=x1;} int get_x(void) const { return x; } int get_x(void) {int x1; cout<<"x = "; cin>>x1; x=x1; return x;} void show_x(void) {cout<<"x= "<<x<<endl;} }; int main() { clrscr(); ABC a(5); a.show_x(); cout<<"? x= "<<a.get_x()<<endl; getch(); return 0;}

Kt qu x=5 ? x =7

Trong v d ny, i tng a khng phi l i tng hng nn lnh a.get_x() s gi hm thnh thnh phn get_x() m khng phi l hm thnh phn const, ngha l gi hm:
int get_x(void) {int x1; cout<<"x = "; cin>>x1; x=x1; return x;}

V cho nhp gi tr ca x. 70

Nguyn Ch Trung Tt nhin nu khng khai bo hm ny th chng trnh s cho thc hin hm:
int get_x(void) const { return x; }

V d 2.29 (b)
#include <iostream.h> #include <conio.h> class ABC { int x; public: ABC(int x1) {x=x1;} int get_x(void) const { return x; } int get_x(void) {int x1; cout<<"x = "; cin>>x1; x=x1; return x;} void show_x(void) const {cout<<"x= "<<x<<endl;} }; int main() { clrscr(); const ABC a(5); a.show_x(); cout<<"? x= "<<a.get_x()<<endl; getche(); return 0;}

Kt qu x=5 ? x=5

Trong v d ny, i tng a l mt i tng hng nn lnh a.get_x() s gi hm thnh phn const:
int get_x(void) const { return x; }

V khng cho nhp gi tr x v khng cho php thay i ni dung i tng hng. Trong trng hp ny, lm vic vi i tng const a th hm show_x() cng phi c khai bo l const. Nu khng khai bo hm show_x() l hm thnh phn const, chng trnh s c cnh bo: "Non-const function ABC::show_x() called for const object ". Vy chng trnh v d ny tr nn y trong vic "xem" cc i tng const v i tng khng l const th ta phi c y hai hm show_x() (nh ngha chng): mt hm thnh phn const cn hm kia khng l hm thnh phn const. Ta c 3 kt qu tip theo: (3) Hm thnh phn const khng c gi mt hm thnh phn khc khng phi l const. (4) Khng c gi cc hm thnh phn khng phi const t cc i tng const.

71

Nguyn Ch Trung (5) Li khuyn: nn khai bo cc hm thnh phn const khi s dng cc i tng const. Con tr this kiu const (hm thnh phn c khai bo const pha trc) Ta bit con tr this dng thay th i tng n t truy nhp ti cc thnh phn ca lp mt cch tng minh. V d v cc constructor ca lp, v cc ton t ti bi khng thn thin ch c th gii thch bng con tr this. Xt mt hm thnh phn ca lp c tham s l mt i tng kiu const. Hm ny phi tr li a ch ca: hoc i tng const truyn vo hm hoc chnh i tng n (i tng gi hm) tc l con tr this. Nh vy chung quy l hm tr v a ch ca i tng nhng hoc i tng const hoc i tng khng const. Mt khc nhn kt qu tr li t hm (tc l v tri ca php gn) li l mt i tng khng const. Ta thy y con tr this phi c chuyn i kiu t khng const sang kiu const v ngc li. Trong trng hp ny C++ yu cu phi ni r c php i kiu ca con tr this bng cch vit t kho const trc khi khai bo hm thnh phn:
class class_name {.... const fun_name(const class_name &); ... };

Tm li t kho const t trc khai bo hm thnh phn l bo hiu c php chuyn kiu ca con tr this truyn cho hm thnh phn hoc tr li t hm thnh phn. V d 2.30
#include <iostream.h> #include <conio.h> class ABC { int v; public: ABC() {} ABC(int v1) {v=v1;} void nhap(void){int v1; cout<<"v= "; cin>>v1;v=v1;} const ABC& lonhon(const ABC&); void xem(void) const {cout<<"value = "<<v<<endl;} }; const ABC& ABC::lonhon(const ABC &m) { if(v<m.v) return m; else return *this;} int main() {

72

Nguyn Ch Trung
clrscr(); ABC a(5),b(9); cout<<"doi tuong a: "; a.xem(); cout<<"doi tuong b: "; b.xem(); ABC c; c=a.lonhon(b); cout<<"doi tuong c: ";c.xem(); getche(); return 0; }

Nu trong hm:
const ABC& ABC::lonhon(const ABC &m)

Ta b i t kho const trc khai bo hm, C++ s thng bo li: "reference initialized with 'const ABC', needs lvalue of type ABC". Nu ta thay i tng c bng mt i tng hng:
const ABC c;

Th hm lonhon(ABC&) phi l mt hm thnh phn const, v n lm vic vi i tng hng (tr li mt i tng hng cho c) Trong trng hp ny, ta phi khai bo kt hp:
const ABC& ABC::lonhon(const ABC &m)const;

Kt lun: 1. Khai bo const trong tham s ca hm quy nh khng c php thay i tham s trong hm. 2. Hm thnh phn const (khai bo const sau khai bo hm) ch lm lm vic vi cc i tng hng. 3. Khai bo const trc khai bo ca hm thnh phn cho php i kiu ca con tr this tr li t hm thnh phn . Nghin cu lp String Phn ny tham kho v vic nghin cu lp String. Mc ch t c khi tm hiu v lp String l: To ra lp String to ra cc thao tc t nhin i vi chui k t. Nghin cu k cc constructor v cc ton t. Tm hiu v nguyn tc cp pht ng cho chui k t.
Nhn xt
class String { private: char *text; int len; public: String() {len=0;text=NULL;} String(const char *S);

73

Nguyn Ch Trung
String(const String &S); ~String() {if (len!=-1) delete [] text;} ... };

Tc dng ca cc constructor : Mt i tng String c 3 cch khi to tng minh String S1; // Dng constructor String(); String S2("Hello"); // Dng constructor khi to String(const char*) String S3(S2); // Dng constructor sao chp String(const String&) Tuy nhin, c th vit cc constructor khi to v constructor sao chp khng tng minh nh sau: String S2="Hello"; String S3=S2; Thm ch trong a s trng hp php gn sau khai bo l chp nhn c: String S2,S3; S2="Hello"; // t an ton, nn dng thm ton t sao chp sau y: String operator = (const char*) S3=S2; // an ton hn nu v phi ch c mt i tng. Nu v phi l mt biu thc gia cc i tng (gi s nh ngha cc php ton trong biu thc) th php gn trn l sai. Ngha l constructor sao chp khng t gii thch c trng hp ny, v trong trng hp ny cn dng ton t sao chp: String operator = (const String &) V d: Vi gi thit lp c cc constructor nu, thm ton t cng 2 i tng String v cc ton t ti bi vo/ra. By gi xt on chng trnh:
String S1="Hello"; String S2="Hellen"; String S3="Peter"; String t1,t2; t1=S1+S2; t2=S1+S3; cout<<t1<<endl; cout<<t2<<endl;

Kt qu: Hello Peter Hello Peter

Ta thy kt qu khi chy chng trnh khng chnh xc na. Nh vy cn thit phi b sung 2 ton s sao chp: const String& operator = (const String &S); (1) const String& operator = (const char *S); (2) cho php thc hin tng minh cc lnh dng: S1="Hello"; // dng ton t (2) S2=S1+S3; // dng ton t (1)
Ci t lp String

Xy dng Lp String (mi i tng thuc lp l mt chui k t) bao gm: 74

Nguyn Ch Trung 1. Cc constructor - sao chp 2. Cc ton t khi to v sao chp: operator = 3. Cc ton t ti bi thn thin sau y: Vo/ ra So snh: operator ==, <=, >=, <, >(v di) Ghp chui: operator + (php cng) Php cho truy nhp vo tng phn t ca chui: operator []
#include <iostream.h> #include <conio.h> #include <string.h> #include <stdlib.h> #include <stdio.h> class String { private: char *text; int len; static char *NullString; public: String(): len(-1),text(NullString) {} String(const char *S); String(const String &S); // cau tu sao chep ~String() {if (len!=-1) delete [] text;} const String& operator = (const String &S); const String& operator = (const char *S); char operator [] (int index) const; char& operator [] (int index); unsigned int length() const { return strlen(text); } friend int operator == (const String &S1,const String &S2); friend int operator <= (const String &S1,const String &S2); friend String operator + (const String&,const String&); friend ostream& operator << (ostream &dout, String &S); friend istream& operator >> (istream &din, String &S); }; char *String::NullString=""; String::String(const char *S) { if(S==NULL)

75

Nguyn Ch Trung
{ len=0; text = new char[1]; text[0]='\0'; } else { len=strlen(S); text = new char[len+1]; strcpy(text,S); } } String::String(const String &S) { len=strlen(S.text); text=new char[len+1]; strcpy(text,S.text);} const String& String::operator=(const String &S) { const int len1 = strlen(S.text); if (this!=&S) { if(len1>=len) { if(len!=-1) delete [] text; len=len1; text=new char[len+1]; } strcpy(text,S.text); } return *this;} const String& String::operator=(const char *S) { if (S==NULL) S=""; const int len1 = strlen(S); { if(len1>=len) { if(len!=-1) delete[] text; len=len1; text=new char[len+1]; } strcpy(text,S); } return *this;} char String::operator [] (int index) const { if(index <0 || index > strlen(text)) { cout<<"index out of range"; abort(); } return text[index]; } char& String::operator [] (int index) { if(index <0 || index > strlen(text)) { cout<<"index out of range"; abort(); } return text[index]; }

76

Nguyn Ch Trung
int operator == (const String &S1,const String &S2) { return strcmp(S1.text,S2.text)==0; } int operator <= (const String &S1,const String &S2) { int len1=strlen(S1.text); int len2=strlen(S2.text); return len1<=len2 ? 1:0; } String operator + (const String &S1,const String &S2) { String S; S.len=S1.len + S2.len; S.text = new char[S.len+1]; strcpy(S.text,S1.text); strcat(S.text,S2.text); return S; } ostream& operator << (ostream &dout, String &S) { dout<<S.text; return dout; } istream& operator >> (istream &din, String &S) { char str[2048]; gets(str); S.len=strlen(str); S.text=new char[S.len+1]; strcpy(S.text,str); return din; } int main() { clrscr(); String S1; String S2("Hello"); String S3(S2); String R; // String() String S="Hello "; // String(const char*) String T=S; // String(const String&) R=T; // operator = (const String &) S="World"; // operator = (const char*) R[0]='J'; // operator[]cho phep saochep ky tu S=T+S; cout<<S; getche(); return 0;

77

Nguyn Ch Trung
}

c thm v lp cc dy bit Ta tham kho thm mt lp tng i phc tp: Lp cc dy bit (BitArray) l mt lp c nhiu ng dng quan trng. Bi ton: "C n ngi, v n vn c nu ra. Mi mt ngi cho bit mnh s la chn mt s vn no trong tp n vn cho. Hi c nhng vn no m tt c mi ngi u trnh n ?" Ta c th dng lp BitArray gii bi ton trn. Vic s dng const t y s c gp nhiu ln v c bit l trong khi xy dng cc lp d liu tru tng. V d 2.31
#include <iostream.h> #include <conio.h> #include <string.h> #include <stdio.h> const MAXSIZE=320; //=================================== // LOP BITS //=================================== class BITS { private: int *array; // mng bit int N; // s bit int size; // kch thc mng enum { IntSz = sizeof(int)*8 }; // s bit ng vi 2 bytes int inrange(int i) const; const BITS& operator=(const BITS &Rhs); // ton t sao chp BITS(const BITS &R); // hm khi to - sao chp public: BITS(int size1 = MAXSIZE); ~BITS() {delete [] array;} void clearbits(); void onbit(int i); void offbit(int i); int getbit(int i) const; int getn() const {return N;} };

78

Nguyn Ch Trung
//=========================================== // nh ngha cc hm thnh phn ca lp BITS //=========================================== BITS::BITS(int size1) { size = (size1 + IntSz -1)/IntSz; array=new int [size]; N=size1; clearbits(); } //------------------------------------------------------void BITS::clearbits() { for(int i=0;i<size;i++) array[i]=0; } //------------------------------------------------------inline int BITS::inrange(int i) const { if (i<0 || i>N) { cerr<<"Bit "<<i<<" out of range("<<N<<")\n"; return 0; } return 1; } //------------------------------------------------------void BITS::onbit(int i) { if (inrange(i)) array[i/IntSz] |= (1<< (i%IntSz)); } //------------------------------------------------------void BITS::offbit(int i) { if (inrange(i)) array[i/IntSz] &= ~(1<< (i%IntSz)); } //------------------------------------------------------int BITS::getbit(int i) const { if(!inrange(i)) return 0; return (array[i/IntSz] & (1<< (i%IntSz))) != 0; } //------------------------------------------------------BITS::BITS(const BITS &R) { size=(R.size + IntSz -1) / IntSz; array=new int [size]; N=R.size;

79

Nguyn Ch Trung
for(int i=0; i < size; i++) array[i]=R.array[i]; } //------------------------------------------------------const BITS& BITS::operator=(const BITS &R) { if (this!=&R) { if(size <R.size) { delete [] array; size = R.size; N=R.N; array = new int [size]; } for(int i=0; i<size;i++) array[i]=R.array[i]; } return *this;} //======================================== // nh ngha cc hm ngoi lai //======================================== void PrintAllBit(const BITS &R) { for(int i=0;i<R.getn();i++) cout<<R.getbit(i); cout<<endl;} //======================================== // Phn th hin ng dng (Implementation) //======================================== void demo1() { BITS A; // cau tu mac dinh voi size mac dinh =MAXSIZE BITS B(50); // cau tu voi size=50 BITS a(8); // so thu tu tu trai sang phai, tu 0 tro di a.onbit(1); a.onbit(4); a.onbit(5); PrintAllBit(a); a.offbit(5); PrintAllBit(a); } void demo2() { BITS b(10); int num;

80

Nguyn Ch Trung
cout<<"so nguoi cung nhu so van de: "; cin>>num; int i; for(i=0;i<num;i++) { cout<<"nguoi thu "<<i+1 <<" chon cac van de: "<<endl; int j; do { cout<<"nhap (ket thuc nhap -1): "; cin>>j; if(j!=-1) b.onbit(j); } while(j!=-1); } cout<<"nhung van de moi nguoi ne tranh la:"<<endl; for(i=0;i<num;i++) if (b.getbit(i)==0) cout<<i<<" "; cout<<endl; } //======================================= int main() { clrscr(); demo1(); demo2(); getche(); return 0;}

BI TP CHNG 2 Bi 2.1 C th dng struct khai bo lp c khng? [a] C [b] khng Bi 2.2 struct v class khc nhau im no? [a] struct ch c d liu, class c c phng thc [b] struct l ca C, class ca C++ [c] Cc thnh phn ca struct mc nh l public Bi 2.3 Cho khai bo lp sau y:

class example { int a; public: example(int A=0) {a=A;} 81

Nguyn Ch Trung void set_a(int A) {a=A;} int get_a() {return a;} }; Cho bit on chng trnh sau, dng no sai: 1. example V(5); 2. cout <<V.a; 3. V.set_a(V.get_a()*2)); [a] 1 [b] 2 [c] 3 Bi 2.4 Cho khai bo lp sau y: class example { int a; void f() { a*=2;} public: example(int A=2) {a=A;} friend void g(example &v); }; void g()(example &v) {v.f();} Cho bit kt qu on chng trnh sau: example V; g(V); [a] V.a c gi tr 4 [b] V.a c gi tr 0 [c] V.a c gi tr 2 Bi 2.5 Cho khai bo lp sau y: class MESS{ char *message; public: M(char *s = "Good Bye!") {message=s;} void say() {cout<<message;} }; Cho bit kt qu on chng trnh sau: char *s="Hello!"; M m(s); strcpy(s,"Chao ban!"); m.say(); [a] Good Bye! [b] Hello! 82

Nguyn Ch Trung [c] Chao ban! Bi 2.6 Cho khai bo lp sau y: class MESS{ char *message; public: M(char *s = "Good Bye!") {message=new char[strlen(s)+1]; strcpy(message,s); } void say() {cout<<message;} }; Cho bit kt qu on chng trnh sau: char *s="Hello!"; M m(s); strcpy(s,"Chao ban!"); m.say(); [a] Good Bye! [b] Hello! [c] Chao ban! Bi 2.7 Xy dng lp cc phn s (FRAC) vi cc php ton ti bi cng, tr, nhn v chia hai phn s vi nhau. Bi 2.8 Xy dng lp cc mng (ARRAY) nguyn, vi cc php ton ti bi cng, tr hai mng vi nhau. Bi 2.9 Xy dng lp cc a thc bc khc nhau (MULINO) (Mulinomial) h s nguyn, vi cc php ton ti bi cng, tr, nhn hai a thc. Bi 2.10 Xy dng lp cc ma trn vung (MATRIX) cc phn t l cc s thc vi cc php ton ti bi thn thin: vo/ra v cng, tr, nhn hai ma trn vi nhau. dng con tr int. Bi 2.11 Xy dng lp cc vc t (VECTOR) n chiu vi cc php ton ti bi thn thin: cng, tr v nhn v hng hai vc t vi nhau.

83

Nguyn Ch Trung S K THA S TNG NG TRONG K THA Khi nim chung

Khi nim

C ch dn xut ra mt lp mi t nhng lp c trc gi l s k tha. Lp mi gi l lp dn xut (derivative class), lp c trc gi l lp c s (base class). Trong lp trnh hng i tng, khi nim k tha ko theo tng s dng li, ngha l t mt lp xy dng, ta c th b sung mt s tnh cht ring to ra mt lp mi m khng lm thay i nhng ci c. im (x,y,c) ; // to v mu sc onThng(x2,y2); // u mt th 2 Tamgic(x3,y3); // nh th 3 ca tam gic
Cc loi kt tha

C 5 loi k tha: K tha n, K tha a mc, K tha phn cp, K tha bi, K tha kp (lai ghp). Sau y l biu din hnh hc ca cc loi k tha: 1) K tha n A B 2) K tha a mc A B C Lp ng - Lp c s
Lp cha - Lp dn xut trung gian Lp con - Lp dn xut (Lp c s) (Lp dn xut)

84

Nguyn Ch Trung 3) K tha phn cp A

B1

B2

B3

C1 4) K tha bi

C2

E1

E2

5) K tha lai ghp

D
Hai mode k tha

Lp dn xut B c th k tha t lp c s A theo mt trong hai mode kt tha: mode public v mode private:

85

Nguyn Ch Trung

class A { //ni dung lp A}

class B: public A { // ni dung lp B};

class B: private A { // ni dung lp C};

Thnh phn public trong lp A (lp c s) s tr thnh thnh phn public trong lp B (lp dn xut). Do vy, cc thnh phn public trong lp A c th truy nhp bi cc hm ca lp k tha v cng nh bi cc i tng ca lp k tha (lp B)

Thnh phn public tronglp A (lp c s) s tr thnh thnh phn private trong lp B (lp dn xut). Do vy, cc thnh phn public trong lp A ch c th truy nhp bi cc hm ca lp k tha v khng th truy nhp bi cc i tng ca lp k tha.

K tha n ABC XYZ V d 3.1

#include <iostream.h> #include <conio.h> #include <stdio.h> class ABC { int a; public: int b; void get_ab(){ a=5; b=10; } int get_a() {return a;} void show_a() {cout<<"a= "<<a<<endl;} }; class XYZ: public ABC { int c; public: (Lp c s)

(Lp dn xut)

Kt qu: a=5 a=5 b=10 c=50 a=5 b=20 c=100

86

Nguyn Ch Trung
void mul(void) { c= b*get_a(); } void display(void) { cout << " a = " << get_a() << endl; cout << " b = " << b << endl; cout << " c = " << c << endl; } }; int main() { clrscr(); XYZ x; x.get_ab(); x.show_a(); x.mul(); x.display(); x.b=20; x.mul(); x.display(); getche(); return 0; } class A private: int a; public: int b; get_a() show_a(); get_ab(); class B: public A private: int c; public: int b; get_a() show_a(); get_ab(); mul(); display();

V d 3. 2
#include <iostream.h> #include <conio.h> #include <stdio.h> class ABC { int a; public:

Kt qu: a=5 b=10 c=50

87

Nguyn Ch Trung
int b; void get_ab(){ a=5; b=10; } int get_a() {return a;} void show_a() {cout<<"a= "<<a<<endl;} }; class XYZ: private ABC { int c; public: void mul(void) { get_ab(); c= b*get_a(); } void display(void) { cout << " a = " << get_a() << endl; cout << " b = " << b << endl; cout << " c = " << c << endl; } }; int main() { clrscr(); XYZ x; x.mul(); x.display(); getche(); return 0; } class A private: int a; public: int b; get_a() show_a(); get_ab();

class B: public A private: int c; get_a() show_a(); get_ab();

public: int b; mul(); display();

Thnh phn protected trong k tha Cc thnh phn private trong lp c s khng c k tha trong lp dn xut. Trong v d 3.1 v v d 3.2 ch ra mt cch l dng hm public trong lp c s (hm 88

Nguyn Ch Trung get_a()) cho bit d liu private trong lp c s. Tuy nhin iu ny vn ch l truy nhp gin tip d liu private qua lp c s. Khng th chuyn ht nhng thnh phn d liu ca lp c s sang vng public v nh vy s ph v nguyn l che du thng tin. C++ cho php mt phn d liu ca vng private c lp dn xut truy xut bng cch ng gi n trong vng protected. Nh vy kiu d liu protected l mt phn d liu private c truy nhp bi cc hm thnh phn trong cng lp v trong lp dn xut trc tip vi lp c s.

class ABC { private: // khng truy nhp bi nhng hm trong cng lp ... protected: // truy nhp c bi nhng hm trong cng lp v lp dn xut trc tip ... public: // truy nhp c bi nhng hm thnh phn trong chng trnh. ... };

Bng tm tt
Lp c s gm cc thnh phn private protected public Lp dn xut mode public khng c k tha protected public mode private khng c k tha private private

V d 3.3 V d ny minh ho s ci t lc k tha sau y: A B(public) D(public) A [(a1), (a2), (a3)] B [(b1), (b2,a2), (b3,a3)] D [(d1), (d2,b2,a2), (d3,b3,a3)]
#include <iostream.h> #include <conio.h> #include <stdio.h> class A { private: int a1;

89

Nguyn Ch Trung
protected: int a2; public: int a3; void get_A(int t1,int t2,int t3) {a1=t1;a2=t2;a3=t3;} }; class B:public A { private: int b1; protected: int b2; public: int b3; void get_B(int t1,int t2,int t3) {b1=t1;b2=t2;b3=t3;} void show_B() {cout<<"b1= "<<b1 <<" b2= "<<b2 <<" b3= "<<b3<<endl; cout<<"a2= "<<a2 <<" a3= "<<a3<<endl<<endl;} }; class D:public B { private: int d1; protected: int d2; public: int d3; void get_D(int t1,int t2,int t3) {d1=t1;d2=t2;d3=t3;} void show_D() {cout<<"d1= "<<d1<<" d2= "<<d2 <<" d3= "<<d3<<endl; cout<<" b2= "<<b2<<" b3= "<<b3<<endl; cout<<" a2= "<<a2<<" a3= "<<a3<<endl<<endl;} }; int main() { clrscr(); D d; d.get_A(1,2,3); d.get_B(4,5,6); d.get_D(7,8,9); d.show_B(); d.show_D(); d.d3=300; d.b3=200; d.a3=100; d.show_D(); getche(); return 0;}

V d 3.4 V d ny minh ho s ci t lc k tha sau y: A C(private) D(public) A [(a1),(a2),(a3)] C [(b1,a2,a3),(b2),(b3)] 90

Nguyn Ch Trung D [(d1),(d2,b2),(d3,b3)]

#include <iostream.h> #include <conio.h> #include <stdio.h> class A { private: int a1; protected: int a2; public: int a3; void get_A(int t1,int t2,int t3) {a1=t1;a2=t2;a3=t3;} }; class B:private A { private: int b1; protected: int b2; public: int b3; void get_B(int t1,int t2,int t3) {b1=t1;b2=t2;b3=t3; get_A(1,2,3); } void show_B() {cout<<"b1= "<<b1<<" b2= "<<b2 <<" b3= "<<b3<<endl; cout<<"a2= "<<a2<<" a3= "<<a3<<endl<<endl;} }; class D:public B { private: int d1; protected: int d2; public: int d3; void get_D(int t1,int t2,int t3) {d1=t1;d2=t2;d3=t3;} void show_D() {cout<<"d1= "<<d1 <<" d2= "<<d2 <<" d3= "<<d3<<endl; cout<<" b2= "<<b2<<" b3= "<<b3<<endl<<endl; } }; int main() { clrscr(); D d; //d.get_A(1,2,3); d.get_B(4,5,6); d.get_D(7,8,9); d.show_B(); d.show_D(); d.d3=300;

91

Nguyn Ch Trung
d.b3=200; d.show_D(); getche(); return 0;}

K tha a mc K tha a mc c trnh by trong hai lc k tha mc trn. Tip theo di y, ta s xt mt v d c th, thc t hn v s k tha a mc: V d 3.5: SINHVIEN DIEMTHI KETQUA Lp c s- lu h tn Lp dn xut trung gian - lu s bo danh Lp dn xut - lu tng im

Trong : Lp SINHVIEN gm H tn, s bo danh. Lp DIEMTHI gm s bo danh ca lp SINHVIEN v b sung thm thng tin gii s l im thi hai mn hc. Do lp DIEMTHI phi k tha ttheo mode public t lp SINHVIEN. Lp KETQUA gm thng tin ca lp DIEMTHI m t tng im v thng bo kt qu thi ca lp SINHVIEN. Vy lp KETQUA phi k tha t lp DIEMTHI theo mode public.
#include <iostream.h> #include <conio.h> #include <string.h> class SINHVIEN { private: char *hoten; protected: int sbd; public: void get_name(char *); void get_sbd(int); void put_sbd(void); }; void SINHVIEN::get_name(char *s) { strcpy(hoten,s); } void SINHVIEN::get_sbd(int a) { sbd=a; } void SINHVIEN::put_sbd(void)

92

Nguyn Ch Trung
{ cout<<"sbd: "<<sbd<<endl;} class DIEMTHI:public SINHVIEN { protected: float mon1,mon2; public: void get_diem(float,float); void put_diem(void); }; void DIEMTHI::get_diem(float x,float y) { mon1=x; mon2=y;} void DIEMTHI::put_diem(void) { cout<<"mon1: "<<mon1<<endl <<"mon2: "<<mon2<<endl; } class KETQUA:public DIEMTHI { private: float sum; public: void display(void); }; void KETQUA::display(void) { sum=mon1+mon2; put_sbd(); put_diem(); cout<<"tong diem: "<<sum<<endl; } int main() { KETQUA S; S.get_sbd(13); S.get_diem(8,10); S.display(); getche(); return 0;}

K tha phn cp
SINHVIEN

VANPHONG

KYTHUAT

QUANLY

VANTHU

KETOAN

QLDUAN

QLDULIEU

93

Nguyn Ch Trung K tha bi

class A { // ni dung lp A }; class B { // ni dung lp B }; class C: mode A: mode B { // ni dung lp C };

V d 3.6 V d ny s minh ho vic ci t s k tha bi nh hnh trn.

#include <iostream.h> #include <conio.h> #include <stdio.h> class M { protected: int m; public: void get_m(int); }; class N { protected: int n; public: void get_n(int); }; class P: public M, public N { public: void display(void); }; void M::get_m(int m1) { m=m1; } void N::get_n(int n1) { n=n1; } void P::display(void) {cout<<"m = "<<m<<endl; cout<<"n = "<<n<<endl; cout<<"m*n= "<<m*n<<endl;} int main() { P p; p.get_m(15); p.get_n(20); p.display(); getche(); return 0; }

94

Nguyn Ch Trung K tha kp (lai ghp) SINHVIEN

DIEMTHI

UUTIEN

KETQUA Tip tc pht trin thm cc lp k tha: Gi s trong v d 3.5 ta c thm lp UUTIEN gm cc thng tin phn nh chnh sch u tin cho cc th sinh theo vng, min, i tng thng binh, lit s, .... Tuy nhin, khng mt tnh tng qut ta giis lp ny c mt thnh phn d liu ghi gi tr im u tin. V d di y l chng trnh ci t m hnh k tha lai ghp nh m t trn: V d 3.7 (a)
#include <iostream.h> #include <conio.h> #include <string.h> class SINHVIEN { private: char *hoten; protected: int sbd; public: void get_name(char *S) { int k=strlen(S); hoten = new char[k+1]; strcpy(hoten,S);} void get_sbd(int a) {sbd=a;} void put_name(void) {cout<<"hoten: "<<hoten<<endl;} void put_sbd(void) {cout<<"sbd: "<<sbd<<endl;} }; class DIEMTHI:public SINHVIEN { protected: float mon1,mon2; public: void get_diem(float x,float y) {mon1=x;mon2=y;}

95

Nguyn Ch Trung
void put_diem(void) {cout<<"mon1: "<<mon1<<endl; cout<<"mon2: "<<mon2<<endl;} }; class UUTIEN { protected: float u; public: void get_ut(float a) {u=a;} void put_ut(void) {cout<<"uu tien: "<<u<<endl;} }; class KETQUA:public DIEMTHI,public UUTIEN { private: float tong; public: void display(void); }; void KETQUA::display(void) { tong=mon1+mon2+u; put_name(); put_sbd(); put_ut(); cout<<"tong diem: "<<tong<<endl; } int main() { KETQUA S; S.get_name("CHI DUNG"); S.get_sbd(810); S.get_diem(9,6); S.get_ut(1.5); S.display(); getche(); return 0; }

Ta d nh ci tin chng trnh trn 2 im 1) Khng dng constructor d liu sn, v d cn thay hm void get_sbd(int a) {sbd=a;} bng hm void get_sbd(void); V trong hm ny, cho php ngi dng nhp s bo danh. Tuy nhin, nu vit hm ny nh sau:
void get_sbd(void) { cout<<" sbd: "; cin>>sbd; }

96

Nguyn Ch Trung th chng trnh s bo li: "Temporary used for parameter 1 in call to 'istream::operator>>(int&)" vit cho chnh xc, ta thm mt bin ph:
void get_sbd(void) { int x; cout<<" sbd: "; cin>>x; sbd = x; }

2) Trong phn p dng, ta s thay mt vi sinh vin bng mt mng cc sinh vin. Vy ta c v d 4 sau y: V d 3.7 (b)
#include <iostream.h> #include <conio.h> #include <string.h> #include <stdio.h> class SINHVIEN { private: char *hoten; protected: int sbd; public: void get_name(void); void get_sbd(void); void put_name(void) {cout<<"hoten: "<<hoten<<endl;} void put_sbd(void) {cout<<"sbd: "<<sbd<<endl;} }; void SINHVIEN::get_name() { char S[30]; cout<<"nhap ho ten: "; gets(S); int k=strlen(S); hoten = new char[k+1]; strcpy(hoten,S); } void SINHVIEN::get_sbd(void) { int x; cout<<"nhap so bao danh: "; cin>>sbd; sbd=x; } class DIEMTHI:public SINHVIEN { protected: float mon1,mon2; public: void get_diem(void);

97

Nguyn Ch Trung
void put_diem(void); }; void DIEMTHI::get_diem() { float m1,m2; cout<<"nhap diem mon 1:"; cin>>m1; mon1=m1; cout<<"nhap diem mon 2:"; cin>>m2; mon2=m2; } void DIEMTHI::put_diem() {cout<<"mon1: "<<mon1<<endl; cout<<"mon2: "<<mon2<<endl;} class UUTIEN { protected: float u; public: void get_ut(void); void put_ut(void) {cout<<"uu tien: "<<u<<endl;} }; void UUTIEN::get_ut() { float u1; cout<<"nhap diem uu tien: "; cin>>u1; u=u1; } class KETQUA:public DIEMTHI,public UUTIEN { private: float tong; public: friend ostream& operator <<(ostream&, KETQUA &); }; ostream& operator << (ostream& dout, KETQUA& k) { k.tong=k.mon1+k.mon2+k.u; k.put_name(); k.put_sbd(); k.put_diem(); k.put_ut(); dout<<"tong diem: "<<k.tong<<endl; return dout; } int main() { const n=2; KETQUA S[n]; int i; for(i=0;i<n;i++)

98

Nguyn Ch Trung
{ S[i].get_name(); S[i].get_sbd(); S[i].get_diem(); S[i].get_ut(); } clrscr(); for(i=0;i<n;i++) cout<<S[i]; getche(); return 0;}

Constructor trong cc lp k tha Nu trong lp c s khng c constructor c tham s th trong lp dn xut khng cn phi c constructor. Nu trong lp c s c constructor c tham s th trong lp dn xut phi c constructor c tham s gm 2 thnh phn: thnh phn tng ng ca lp c s v thnh phn tham s ca n. Khi : Constructor ca lp c s thc hin trc ri mi n constructor ca lp dn xut thc hin. Trong trng hp k tha bi th constructor ca cc lp c s c thc hin theo th t ca cc lp c s c khai bo mode k tha lp dn xut. Trong trng hp k tha a mc th cc constructor ca lp c s c thc hin theo th t k tha cc mc. nh ngha constructor lp dn xut nh sau:
contructor_dn_xut(dx1,dx2,...,dxn,dxx): contructor _t_c_s1(dx1), contructor _t_c_s2(dx2), ... contructor _c_sn(dxn), { // ni dung constructor ca lp dn xut }

V d 3.8 Constructor trong k tha a mc :

#include <iostream.h> #include <conio.h> #include <stdio.h> class A { int a; public: A() {a=0;} A(int a1) { a=a1;} void put_A() { cout<<" a = "<<a<<endl;} };

99

Nguyn Ch Trung
class B:public A { int b; public: B() {b=0;} B(int a1,int b1): A(a1) { b=b1;} void put_B() { cout<<" b = "<<b<<endl;} }; class C:public B { int c; public: C() {c=0;} C(int b1,int b2,int c1): B(b1,b2) { c=c1;} void put_C() { cout<<" c = "<<c<<endl;} }; int main() { clrscr(); B n(100,200); n.put_A(); n.put_B(); cout<<endl; C m(10,20,30); m.put_A(); m.put_B(); m.put_C(); getche(); return 0; }

V d 3.9 Constructor trong k tha bi:

#include <iostream.h> #include <conio.h> #include <stdio.h> class A { int a; public: A() {a=0;} A(int a1) { a=a1;} void put_A() { cout<<" a = "<<a<<endl;} }; class B { int b; public: B() {b=0;} B(int b1) { b=b1;} void put_B() { cout<<" b = "<<b<<endl;}

100

Nguyn Ch Trung
}; class C:public A,public B { int c; public: C() {c=0;} C(int a1,int b1,int c1): A(a1),B(b1) { c=c1;} void put_C() { cout<<" c = "<<c<<endl;} }; int main() { clrscr(); C m(10,20,30); m.put_A(); m.put_B(); m.put_C(); getche(); return 0;}

101

Nguyn Ch Trung CON TR XC NH THNH PHN CA LP V CON TR XC NH I TNG Ta bit rng cc thnh phn ca lp (tr thnh phn private) c truy nhp thng qua tn i tng ca lp: Object_name.Data_member Object_name.Funtion_menber Tuy nhin trong nhiu trng hp, thay v i tng, ta phi s dng con tr truy nhp vo cc thnh phn ca lp. Mc ch ca mc kin thc ny l chnh xc li cc quy tc c php v cch s dng con tr tr vo cc thnh phn ca lp. Ngoi ra, bn thn i tng trong lp, khi cn thit, cng phi lm vic gin tip qua mt con tr, tr vo i tng . Cc quy tc c php v con tr Xt lp:
class M { public: int x; void show(void); };

Khi vic khai bo con tr i vi cc thnh phn ca lp M v i tng ca lp M tun theo cc c php cho trong bng sau y: C php Tc dng khai bo mt con tr, tr n mt thnh phn ca lp M, v d: M::*ptr ; Khi ptr c th tr n d liu thnh phn d liu x hoc hm thnh phn show(), c ngha l ptrr cha a ch ca cc thnh phn x v show. a ch ca cc thnh phn ny nh ch ra di y. khai bo a ch ca mt thnh phn no ca lp M, v d: &M::x l a ch ca thnh phn d liu x &M::show l a ca thnh phn hm show() Khi , c th vit: M::*px = &M::x; void (M::*pf)() = &M::show; khai bo mt con tr, tr n mt i tng trong lp M,v d: M*ptr; Khi ptr tr n mt i tng no trong lp M, v d tr n i tng m ca lp M, ta s vit: M*pm = &m; Con tr i tng rt hay s dng trong k tha ci t khi 102

M::*

&M::

M*

Nguyn Ch Trung nim tng ng bi bng c ch hm o. T , ta suy ra cc quy tc c php thng dng nh bng sau y: "Bng c php tng ng " m.*px; Nu: m.x pm->*px; pm->x; M m; int M::*px = &M::x; void (M::*pf)() = &M::show; (m.*pf)(); M*ptr = &m; m.show() (pm->*pf)(); Th khi ta c cc lnh tng pm->show(); ng nh hai ct bn phi: m pm->m Nhn xt: Ton t ->* dng truy nhp ti thnh phn ca i tng khi i tng ca lp v thnh phn ca i tng u xc nh bi con tr. V d 1:
pm->*px (pm->*pf)()

Ton t .* c s dng khi i tng c ch ra trc tip cn cc thnh phn ca n th c xc nh nh con tr. V d 2:
m.*px; (m.*pf)()

Cc v d minh ho cch s dng con tr xc nh i tng v thnh phn (d liu v hm) ca lp V d 3.10
#include <iostream.h> #include <conio.h> class M { public: int x; void show() { cout <<"x= "<<x<<endl; } }; int main() { M m; int M::* px= &M::x; void (M::* pf)()= &M::show; M* pm = &m;

Kt qu: 10 10 10 x=10 x=10 x=10 x=20

103

Nguyn Ch Trung
clrscr(); m.x=10; cout<<m.*px<<endl; cout<<pm->*px<<endl; cout<<pm->x<<endl<<endl; (m.*pf)(); (pm->*pf)(); pm->show(); cout<<endl; pm->*px=20; (pm->*pf)(); getche(); return 0; }

Trong v d trn: px l con tr tr vo thnh phn d liu x cn pf l con tr tr vo hm thnh phn show(). Theo bng c php tng ng th cc lnh in ra : m.*px; pm->*px; pm->x; u ging lnh in ra m.x . Ban u gn x=10 nn cc lnh in ra ba dng gi tr 10. Tip theo, cc lnh gi hm (m.*pf)(): (pm->*pf)(); pm->show(); u ging lnh gi hm m.show(), do , nh thn ca hm, trn mn hnh in ra ba dng kt qu x = 10. Vic gn li m.x = 20 c thc hin bi lnh: pm->*px=20; Tip theo lnh in ra mn hnh mt dng trng, lnh gi hm (pm->*pf)(); s in ra dng kt qu x = 20. V d 3.11
#include <iostream.h> #include <conio.h> #include <stdio.h> class M { int x,y; public: void set_xy(int a,int b) {x=a; y=b;} friend int sum(M); }; int sum(M m) { int M::* px=&M:: x; int M::* py=&M:: y;

Kt qu Tong = 30 Tong = 70

104

Nguyn Ch Trung
M* pm=&m; int s=pm->*px + pm->*py; return s; } int main() { clrscr(); M m; void (M::*pf)(int,int)=&M::set_xy; (m.*pf)(10,20); cout << "Tong = "<<sum(m)<<endl; M *ptr=&m; (ptr->*pf)(30,40); cout << "Tong = "<<sum(*ptr)<<endl; getche(); return 0; }

Con tr xc nh i tng Trong C++, vic s dng con tr tr vo i tng ca lp rt hay s dng v cc l do sau y: (1) Cho php cp pht b nh ng cho mt mng i tng. (2) Cho php s dng con tr this tr vo i tng (3) Cho php s dng con tr c kiu ca lp trong quan h k tha Vic s dng con tr this xc nh i tng n (i tng cha c to lp) thao tc trn cc thnh phn ca i tng c trnh by trong mc mc 2.3.3. Vic s dng con tr c kiu ca lp trong quan h k tha s c tm hiu mc 3.3 tip theo. Di y chng ta s xem xt mt v d minh ho vic s dng con tr xin cp pht b nh ng cho mt mng i tng V d 3.12
#include <iostream.h> #include <conio.h> #include <stdio.h> class MAT_HANG { int code; float price; public: void getdata(int c,float p) {code=c; price=p;} void show(void) { cout<<"ma hang: "<<code<<endl; cout<<"don gia: "<<price<<endl; } }; const int k=2; int main() { clrscr(); MAT_HANG *p = new MAT_HANG[k];

105

Nguyn Ch Trung
MAT_HANG *d = p; int i,x; float y; for(i=0;i<k;i++) { cout<<"nhap ma va don gia mat hang thu " <<i+1<<": "; cin>>x>>y; p->getdata(x,y); p++; } for(i=0;i<k;i++) {d->show(); d++; } getche(); return 0; }

Trong chng trnh v d trn, con tr p xin cp pht k vng nh cho k i tng mt hng v p tr vo u danh sch cc mt hng ny. d l con tr ph duyt trn danh sch cc bin ng nhp /xut d liu cho cc bin ng (mt hng) . HM O V TNG NG BI TRONG K THA Cc hm dch chuyn (Override function) Hai hm gi l cng c tnh nu chng c cng s lng i s, cng kiu ca tng i s v cng kiu d liu ca hm. C++ cho php lp c s v lp dn xut c th cng khai bo hai hm cng tn thm ch cng c tnh. Hai hm nh vy khng phi l hai hm ti bi v chng khng phi l cc hm thnh phn ca cng mt lp (khng th khai bo hai hm ti bi cng c tnh, nh trnh by trong mc 1.2.10 ) Mt hm c khai bo trong lp dn xut gi l hm dch chuyn (Override function) t mt hm trong lp c s nu hai hm ny cng c tnh. S nh ngha li cc hm nh vy lp dn xut c gi l gi l s "dch chuyn" (Overriding). V d 1:
Class A { int x; public: A(int x1) {x=x1; } void show() { cout << "show x = "<<x << endl; } void display() { cout << "display x = "<<x << endl; } }; Class B: public A { int y;

106

Nguyn Ch Trung
public: B(int x1,int y1):A(x1) {y=y1; } void show() { cout << "y = "<<y << endl; } };

Vn t ra l khi i tng ca lp dn xut s dng hm dch chuyn th hm c triu gi l thuc lp c s hay lp dn xut ? C++ quy nh nh sau (Quy tc 1) Khi i tng ca lp dn xut truy nhp ti hm dch chuyn th mc nh l hm ca chnh lp dn xut . V d 2:
B b(10,20); b.show() // gi hm ca lp B A::show() // gi hm ca lp A

Khi i tng ca lp chu truy nhp ti hm dch chuyn ca cc lp c s pha trn (bn thn hm ny khng c mt trong lp chu) th mc nh l hm ca lp c s khai bo sau cng (gn lp chu nht) Con tr xc nh i tng trong quan h k tha Con tr c kiu d liu l lp c s th ng nhin c th tr n i tng ca lp c s (nu ta gn con tr bng a ch ca i tng thuc lp c s) nhng hn na n cn c kh nng tr v i tng ca lp dn xut (nu tip theo ta gn con tr ny bng a ch ca mt i tng thuc lp dn xut) V d 3:
class A { // ni dung lp B } ; class B: public A { // ni dung lp B } ; A a; B b; A *ptr; // ptr c kiu lp A ptr=&a; // ptr tr n i tng a ca lp A ... ptr=&b; // tip theo ptr tr n i tng a ca lp A ...

Tuy nhin, trong trng hp ny th khi s dng con tr xc nh n hm dch chuyn th chng trnh dch mc nh l hm thnh phn ca lp c s, mc d con tr c gn a ch ca i tng thuc lp dn xut. (ta gi l Quy tc 2) iu ny chng t vic xc nh hm thnh phn thuc lp no l ph thuc vo kiu con tr ch khng ph thuc vo i tng m con tr ang tr ti.

107

Nguyn Ch Trung V d 3.13

#include <iostream.h> #include <conio.h> #include <stdio.h> class A { int x; public: A(int x1) {x=x1;} void show() {cout<<"Lop A: "<<x<<endl;} }; class B:public A { int y; public: B(int x1,int y1):A(x1) {y=y1;} void show() {cout<<"Lop B: "<<y<<endl;} }; int main() { clrscr(); A a(3); B b(5,6); A *ptr; ptr=&a; ptr->show(); // goi ham show() cua lop A ptr=&b; ptr->show();// van goi ham show() cua lop A getche(); return 0; }

Kt qu Lop A: 3 Lop A: 5

Con tr hm o v tng ng bi
Khi nim v lin kt tnh

Ta bit rng (quy tc 2) mt con tr thuc lp c s c th nhn a ch ca bt k i tng thuc cc lp con chu c dn xut t lp c s. Tuy nhin lc con tr ny lun lun lin kt vi cc hm thnh phn thuc lp c s trong trng hp y l cc hm dch chuyn. Mi lin k c tnh cht khng thay i nh vy gi l lin kt tnh.
Khi nim v lin kt ng

C++ a ra nguyn l lin kt ng cho php mt con tr kiu lp c s sau khi gn bng a ch ca i tng thuc lp dn xut no th tng ng n s th lin kt vi hm ca chnh lp dn xut , mc d hm ny l dch chuyn t hm ca 108

Nguyn Ch Trung lp c s. Cu trc cho php mt con tr c kiu c nh nhng c kh nng lin kt vi cc hm thnh phn dch chuyn thuc cc lp khc nhau gi l lin kt ng. C ch lin kt tnh v lin kt ng trong quan h k tha phn nh vic truy nhp ti cc hm dch chuyn trong cc lp c quan h k tha l mt trng hp ci t c th ca khi nim tng ng bi trong lp trnh hng i tng vi C++. Lin kt ng c ci t bng c ch hm o v n c bo hiu l hm o bng cch t t kho virtual pha trc khai bo hm. V d 3.14
#include <iostream.h> #include <conio.h> class A { public: virtual void display(void) {cout<<"Lop A: display()"<<endl;} void show(void) {cout<<"Lop A: show()"<<endl;} }; class B:public A { public: void display(void) {cout<<"Lop B: display()"<<endl;} void show(void) {cout<<"Lop B: show()"<<endl;} Kt qu }; Lop A: display() int main(){ Lop A: show() A a; B b; Lop B: display() A *ptr; Lop A: show() ptr = &a; ptr->display(); ptr->show(); cout<<endl; ptr= &b; ptr->display(); ptr->show(); cout<<endl; getch(); return 0;}

V d trn cho thy sau khi con tr ptr kiu lp A, c gn bng a ch ca i tng b thuc lp dn xut B ca lp A th ptr c th lin kt vi hm display() ca chnh lp B v hm display() ca lp A c khai bo o (Quy tc 3). Ngc li con tr ptr vn lin kt vi hm show() ca lp c s A ch khng phi ca lp dn xut B v hm show() trong lp c s A khng c khai bo o.

109

Nguyn Ch Trung
Khi nim v tng ng bi (Polymorphism - s a hnh)

S a hnh (Polymorphism) c hiu mt cch tru tng l kh nng mt khi nim c th xut hin nhiu dng khc nhau. Hm v ton t ti bi l mt v d ca tnh a hnh, tuy nhin, s ti bi m chng ta nhn thy y l s lin kt tnh. Hm c chn y l trong thi gian dch chng trnh v iu ny lm gii hn tnh a hnh. Trong ngn ng C++, cc hm c chn trong khi chy chng trnh v y l mt k thut trong s k tha C++. S a hnh hiu theo cch trn c l nn dch l s tng ng bi th thch hp hn v n nhm tr li cu hi: Ngoi c ch cho php ti bi ca cc hm v ton t trong mt lp, th mt con tr i tng s lin kt vi hm no trong cc lp c quan h k tha m cc hm ny c chung c tnh (cng tn v cng tham s, kiu tham s v kiu ca hm)? R rng ta ang xt n s tng ng khng phi l mt m l tng ng bi trong cc lin kt tnh (trong thi gian dch chng trnh) v lin kt ng (trong thi gian chy chng trnh). Tng ng bi ng vai tr quan trng trong vic to ra cc i tng c cu trc bn trong khc nhau nhng c kh nng cng dng chung mt giao din bn ngoi (nh tn gi). iu ny c ngha l mt lp tng qut cc php ton c nh ngha theo cc thut ton khc nhau nhng c kh nng s dng theo cng mt cch ging nhau. Tng ng bi l m rng khi nim s dng li trong nguyn l k tha. V d:

HINH_HOC VE()

HINH_TRON() VE(TRON)

DA_GIAC VE(DA_GIAC)

DUONG_THANG VE(D_THANG)

Hm VE() l hm tng ng bi v n c xc nh ty theo ng cnh khi s dng.

Cc hm o dch chuyn (Virtual override function)

Khi c mt hm c khai bo o th trong lp dn xut ca n nu nh ngha li hm ny cng tham s v kiu tham s th phi cng kiu. Nu trong lp dn xut khai bo hm cng c tnh vi hm o ca lp c s th t khc n tr thnh hm o m khng ph thuc vo hm c hoc khng c khai bo t kha virtual 110

Nguyn Ch Trung pha trc, V, hm ny c gi l hm o dch chuyn (virtual override function) t hm o tng ng ca lp c s. V d 3.15
#include <iostream.h> #include <conio.h> #include <stdio.h> class A{ public: virtual void display() { cout << "\n Class A";} }; class B{ public: virtual void display() {{ cout<<"\n Class B";} }; void show(A *a) { a->display(); } void main() { A* a = new A; B* b = new B; a->display(); b->display(); show(a); // goi ham A::display() show(b); // goi ham B::display() getch(); }

Trong v d ny, nu hm display khng c khai bo o ( lp A) th show(a) s gi hm A::display() v show(b) cng gi hm A::display() v tham s truyn B* s c chuyn kiu thnh A* trc khi gi hm. K tha lai ghp v lp c s o NGB CHA M

CON

Lp CON k tha trc tip t lp CHA v lp ME, ngoi ra lp CON cn k tha t lp ONGBA theo hai con ng khc nhau. N k tha trc tip mt s c

111

Nguyn Ch Trung tnh t lp ONGBA (ng chm chm) v k tha gin tip mt s c tnh qua hai lp CHA v lp ME. Nh vy thnh phn protected v public ca lp ONGBA s c k tha p lp CON, ln th nht k tha t lp CHA, ln th hai k tha t lp ME, ngha l lp CON s c hai tp thnh phn k tha khc nhau. Vy vn t ra l phi c c ch loi b d tha trong quan h k tha lai ghp. C++ cho php loi b d tha trong quan h k tha lai ghp bng c ch lp c s o v n c ch ra bng t kho virtual t sau tn lp v trc mode private / public. Khi mt lp c khai bo l lp c s o th ch c mt bn sao duy nht nhng thnh phn c k tha c truyn cho lp k tha cho d c bao nhiu ng k tha cng th.
class A // ONGBA { // noi dung lop A }; class B1: virtual public A // CHA { // noi dung lop B1}; class B2: virtual public A // ME { // noi dung lop B2 }; class C: public B1, public B2 // CON { // noi dung lop C};

V d 3.16
#include <iostream.h> #include <conio.h> class A { protected: int x; public: virtual void show() { cout <<" LOP A "<<endl; } }; class B1: virtual public A { protected: int y1; public: void show() { cout <<" LOP B1 "<<endl; } }; class B2: virtual public A { protected: int y2; public: void show() { cout <<" LOP B2 "<<endl; }

112

Nguyn Ch Trung
}; class C:public B1, public B2 { private: int z; public: void show() { cout <<" LOP C "<<endl; } }; int main() { clrscr(); A *ptr; C c; ptr=&c; ptr->show(); // LOP C B1 b1; ptr=&b1; ptr->show(); // LOP B1 B2 b2; ptr=&b1; ptr->show(); // LOP B2 getch(); return 0; }

Nhn xt: Nu hai lp cha B1 v B2 khng khai bo lp o th chng trnh s li. Nu hm show ca lp A khng khai bo o th lnh ptr->show() lin kt vi hm show ca lp A v hm ny k tha sang lp chu C qua hai lp cha B1 v B2 gm mt bn sao duy nht ch khng s dng hai hm show() ca hao lp cha B1 v B2 . Nu hm show ca lp A c khai bo o nh v d th lnh ptr->show() lin kt vi hm show ca lp C. Tuy nhin hm o ny vn k tha sang lp chu C bng mt bn sao duy nht ch khng s dng 2 hm show() ca 2 lp cha B1 v B2 . Kt lun

Tng ng bi Tng ng bi trong thi gian chy chng Hm o, lp o

Tng ng bi trong thi gian dch chng trnh Hm ti bi 113 Ton t ti bi

Nguyn Ch Trung

Hm o lp c s trnh nhp nhng v cc hm cng tn. Lp o trong cc lp k tha trung gian trnh lp li cc thnh phn theo cc ng khc nhau. Khi khng c hm o th ch nguyn tc 1 v nguyn tc 2. Hm rng (Null Function) Ta bit rng, khi cc lp con c hm o dch chuyn t lp cha th c th khng cn khai bo o bi t kha virtual. Tuy nhin nu xut hin lp chu v lp chu ny mun dng hm o ny ca lp cha th lp con vn phi khai bo t kha virtual. Cc hm o ca cc lp cha v con gi l cc hm rng (Null funtion} nu chng khng c lnh no trong thn hm. V d 3.17
#include <iostream.h> #include <conio.h> class A{ public: virtual void display() { cout<<"\n Class A";} }; class B: public A { public: virtual void display() { } ; // null function }; class C: public B { public: virtual void display() { cout<<"\n Class C";} }; void show(A* a) { a-> display(); } void main() { A* a = new A; B* b = new B; C* c = new C; show(a); // goi ham A::display() show(b); // goi ham B::display() show(c); // goi ham C::display()

114

Nguyn Ch Trung
}

Hm o thc s v lp tru tng (pure function & abstract class) Nu mt lp ch bao gm cc hm rng th vic th hin cc i tng s khng c ngha g trong lp trnh v ngoi vic phn phi b nh khng cn thit, cc i tng s khng thc hin bt c iu g. trnh to ra cc i tng c dng trn, cc lp cn khai bo dng lp tru tng (abstract class). Mt lp tru tng c t nht mt hm rng v trong s cc hm rng phi c t nht mt hm o thc s (Pure virtual function). Lp tru tng vi cc hm o thc s to ra mt c ch lp bao, ngha l mt lp tng qut nht bao tt c cc lp cn li v do thc hin trit nguyn l tru tng ha trong k thut k tha. Ch rng khng c php c lnh gi thc hin cc hm o thc s ny. V, vic gi mt hm o thc s l tng ng vi vic s dng mt con tr cha c khi to gi gin tip hm v nh th l khng c php. V d 3.18
#include <iostream.h> #include <conio.h> class A{ public: virtual void display() = 0 ; //hm o tinh khit kiu pure function }; class B: public A { public: virtual void display() { cout<<"\n Class B";} }; class C: public B { public: virtual void display() { cout<<"\n Class C";} }; void show(A* a) { a-> display(); } void main() { B* b = new B; C* c = new C; show(b); // goi ham B::display() show(c); // goi ham C::display() }

Lp A c s dng nh mt lp c s cho tt c cc lp khc. Hm ::show(A*) no c gi s c xc nh c th khi chng trnh da trn cc kiu ca i tng c truyn cho hm. 115

Nguyn Ch Trung Vic dn sut mt lp t mt lp tru tng khng c ngha l lp c th hin. Nu mt lp c dn xut t lp khc m bn thn lp c s li cha cc hm o thc s th lp dn xut cng c xem nh lp tru tng. Bng cch ny C++ i hi dch chuyn (nh ngha chng) tt c cc hm o thc s trong lp dn xut. Hm thn thin o v ton t o dch chuyn Trong C++ ngoi khi nim hm thn thin ti bi, ton t ti bi cn c khi nim hm thn thin o (virtual friend function), ton t o (virtual operator) dch chuyn. BI TP CHNG 3 Bi 3.1 Gi s cc thnh phn private, protected v public cho trong cc lp A, B, C nh sau: A[(a1,a2),(a3,a4),(a5,a6)] A[(b1,b2),(b3,b4),(b5,b6)] A[(c1,c2),(c3,c4),(c5,c6)] Hy xc nh li cc thnh phn private, protected v public trong cc lp dn xut B v lp C trong cc lc k tha sau y: 1) A B(private) C(private) 2) A B(private) C(public) 3) A B(public) C(private) 4) A B(public) C(public) 5) A B(public) v A C(public) Bi 3.2 Cho cc khai bo sau y: class A { 1. void f1() {cout << "f 1 ca lp A\n";} 2. public: 3. void f2() { cout << "f 2 ca lp A\n";} 4. }; 5. class B : public A { 6. public: 7. void f3() {f1(); } 8. }; 9. Hy cho bit dng no sai [a] 4 [b] 6 [c] 8 Bi 3.3

116

Nguyn Ch Trung Cho cc khai bo sau y:

class She; class X { { void f1() {cout << "f 1 ca lp He\n";} public: friend class She; }; class She { { public: void f1(He &h) {h.f1(); } };

Cho bit on chng trnh sau, dng no sai: He H; 1. She S; 2. S.f1(); 3. H.f1(); public: 4. [a] 1 [b] 2 [c] 3 [d] 4 Bi 3.4 Cho cc khai bo sau:
class Parent { public: virtual void f(){cout<<"f is Parent's \n";} void run() {f();} }; class Child: public Parent { public: void f() {cout<<"f is Child's\n";} };

Cho bit kt qu in ra ca on chng trnh sau: Child C; C.run(); [a] f is Parent's [b] f is Child's Bi 3.5 Cho cc khai bo sau:
class Parent { public:

117

Nguyn Ch Trung
void f(){cout<<"f is Parent's \n";} void run() {f();} }; class Child: public Parent { public: void f() {cout<<"f is Child's\n";} };

Cho bit kt qu in ra ca on chng trnh sau: Child C; C.run(); [a] f is Parent's [b] f is Child's Bi 3.6 Lp NGANH (ngnh o to) gm c: m ngnh, tn ngnh. Lp MON (mn hc) gm c: m mn, tn mn. Lp SINHVIEN k tha tt c cc thng tin ca hai lp NGANH v MON, ngoi ra cn c thm cc thng tin: h v tn, nm sinh, im thi. Tt c cc lp trn u c hai hm thnh phn nhp thng tin t bn phm v xut thng tin ra mn hnh cho cc i tng ca lp. Hy vit chng trnh C++ nh ngha cc lp trn. Vn dng nhp v in ln mn hnh thng tin cho 3 sinh vin. Bi 3.7 Vit chng trnh C++ ci t m hnh k tha sau y: MATHANG HANGBAN HANGMUA

DOANHTHU Lp MATHANG (mt hng) gm: tn hng, tn nh cung cp Lp HANGBAN (hng bn) b sung thng tin: s lng bn, gi bn Lp HANGMUA (hng mua) b sung thng tin: s lng mua, gi mua Lp DOANHTHU (doanh thu) b sung thng tin v : li, li. Cc lp trn u c constructor khi to v sao chp, cc hm ti bi thn thin vo/ra. Vn dng quan h k tha nhp thng tin cho hai mt hng v hin th li, l ca mt hng . Bi 3.8 Vit chng trnh C++ ci t s k tha bi gia cc lp sau y: 118

Nguyn Ch Trung Lp SACH (sch) gm: tn sch, tc gi, nm xut bn, nh xut bn. Lp DOCGIA (c gi) gm: tn c gi, nm sinh, a ch Lp MUON (mn sch) k tha bi t hai lp SACH v DOCGIA, thm thng tin v ngy mn sch. Cc lp trn u c constructor khi to v sao chp, cc hm ti bi thn thin vo/ra. Vn dng quan h k tha va ci t nhp thng tin cho 2 u sch, 3 c gi, in ln mn hnh cc c gi gm: tn c gi, a ch, tn sch, tc gi v ngy mn sch.

119

Nguyn Ch Trung LM VIC VI TP Trong chng trnh gii quyt cc bi ton thc t, d liu vo v c th c d liu ra sau khi x l thng khng nh v khng th ch tn ti trong b nh khi my tnh cn cha tt. Cc d liu vo/ra ny cn c lu trong tp trn b nh ngoi, khi cn thit th khng mt cng nhp li, c th sa i, cp nht v lu li kt qu. Chng 4 ch yu s trnh by cc nguyn tc m tp, c v ghi d liu ln tp. lm vic vi tp, chng trnh phi khai bo tp tiu fstream.h Tp fstream.h cha lp fstream nh ngha cc i tng v cc hm thnh phn m tp, vo/ra d liu trn tp. Lp fstream c hai lp dn xut: Lp ifstream nh ngha cc hm thnh phn m v c d liu t tp. Lp ofstream nh ngha cc hm thnh phn m v ghi d liu vo tp. CC THAO TC C BN VI TP c d liu t tp
M tp c

m mt tp c tn fname c xc nh bi i tng f (trong lp ifstream) ta dng lnh to lp i tng f, bn cht l s dng constructor sao chp:
ifstream f(fname);

fname c th l tn ca mt hng xu k t c khai bo trc hoc l mt gi tr hng xu k t tht s vit gia hai du nhy kp, ghi y ng dn v tn tp. f l tn i tng (ca lp ifstream) do ta t quy nh, v ni chung nn t tn gi nh ph hp vi ni dung tp ang lm vic. V d 1: #define fname "C:\\DATA\\DAYSO.TXT" ... ifstream f(fname) V d 2: ifstream f("C:\\DATA\\DAYSO.TXT");
c tp

c dng hin ti ca tp f ra vng m n bytes (n phi hon ton xc nh: l mt hng nguyn dng) ta dng hm thnh phn getline() nh sau:
char buffer[n]; f.getline((buffer.sizeof(buffer));

C th xem dng vn bn ny trn mn hnh: cout << buffer;

120

Nguyn Ch Trung c t dng hin ti cc phn t d liu c kiu khc nhau (khc kiu char *) tng ng ra cc bin v1, v2, ...., vn, ta dng ton t ti bi >>:
f >> v1 >> v2 >> ... >> vn;

Tt nhin i vi kiu d liu mi do ngi dng nh ngha, v d nh kiu lp, ta phi nh ngha chng thm cho ton t vo (>>) . kim tra li khi c d liu t tp ta s dng cc ton t ti bi sau y ca lp ifstream:
// Hai lnh sau kim tra li khi m tp if(!f) // c li khi m tp f if(f) // khng c li khi m tp, // Hai lnh sau s dng khi c tt c cc dng t tp if(f.eof()) // c n cui tp if(!f.eof()) // cha c n cui tp

ng tp

Trong C++, vic dng mt i tng f ca lp ifstream m v c tp th tp s t ng khi chm dt s dng i tng f (tc l s dng Destructor ngm nh). Tuy nhin, ta c th ch ng s dng hm thnh phn close()
f.close();

V d 4.1 V d sau y c tng dng ca tp vn bn Messages.txt v in kt qu ln mn hnh:

#include <iostream.h> #include <fstream.h> #include <conio.h> #define fname "messages.txt" void main() { ifstream f(fname); while (!f.eof()){ char buffer[100]; f.getline(buffer, sizeof(buffer)); cout << buffer << endl; } f.close(); getch(); }

V d 4.2 Chng trnh trong v d sau y c thng tin ca cc mt hng trong tp "Goods.txt" v in ln mn hnh.

121

Nguyn Ch Trung Gi thit mi dng trong tp ghi mt d liu ca mt mt hng gm ba mc tin theo th t l: m hng (kiu int), n gi (kiu double) v s lng (kiu int)
#include <iostream.h> #include <fstream.h> #include <conio.h> #include <string.h> const char *fname = "goods.txt" void main() { ifstream f(fname); int ID,sum; float cost; cout.precision(2); //nh dng 2 ch s sau phn thp phn while(!f.eof()) { f>>ID>>cost>>sum; if (!f.eof()) cout<<ID<<"\t"<<cost<<"\t"<<sum<<endl; } getch(); }

Ghi d liu vo tp
M tp ghi

m mt tp c tn fname v xc nh bi i tng f (trong lp ofstream) ta dng constructor sao chp:

ofstream f(fname);

Ghi tp

ghi mt d liu vo dng hin ti ca tp xc nh bi i tng f, ta dng ton t ti bi ra (<<) nh cc v d sau y:

char *text = "Nguyen Hoa Binh"; f<<text; // ghi gi tr ca text vo dng hin ti ca tp f char string[100]; cout<<"Nhap ho ten:"; gets(string); f<<"\n"<< string; // ghi mt dng trng (xung dng) trc // khi ghi vn bn string va nhp vo tp double salary; cout<<"Nhap luong: "; cin>>salary; f<<"\n" << salary; // ghi gi tr salary vo dng tip theo //ca tp f

V d 4.3

122

Nguyn Ch Trung V d sau y to mt mng cc im (point) c to nguyn, nhp to cho cc im t bn phm v ghi dy to vo tp "points.txt" , mi dng mt im.
#include <iostream.h>#include <fstream.h> #include <conio.h> #define fname "Points.txt" #define N 5 class point { public: int x,y; void get_point(void) { cout<<"x=" ; cin>>x; cout<<"y=" ; cin>>y; } } a[N]; void main() { ofstream f(fname); for (int i=1; i<=N;i++) { a[i].get_point(); f<<a[i].x<<" "<<a[i].y<<"\n"; } getch(); }

V d 4.4 Kt qu tuyn sinh ca mt trng no c lu trong tp vn bn "ketqua1.txt" gm nhiu tp d liu, cc tp d liu cch nhau mt dng trng. Mi tp d liu ghi thng tin ca mt th sinh gm ba dng: Dng th nht ghi s bo danh ca th sinh. Dng th hai ghi ngy, thng v nm sinh ca th sinh . Dng th ba ghi im thnh phn ca ba mn thi. Chng trnh di y c d liu t tp "ketqua1.txt" v to tp "ketqua2.txt" ghi danh sch cc th sinh (tng im ba mn 15) v c trnh by theo khun dng nh tp d liu vo. V yu cu lp trnh: Phi nh ngha lp cc sinh vin. Phi nh ngha ti bi thn thin cc ton t vo (<<) v ra (>>) i vi cc i tng thuc lp sinh vin.
#include <iostream.h> #include <fstream.h> #include <conio.h> #include <stdio.h>

123

Nguyn Ch Trung
#define TableResult "Ketqua1.txt" #define TableFilter "Ketqua2.txt" struct date { int d,m,y; }; class HOCSINH{ public: unsigned long sbd; struct date ns; unsigned int diem[3]; unsigned int tongdiem() { return (diem[1]+diem[2]+diem[3]);} friend ifstream& operator >> (ifstream&, HOCSINH&); friend ofstream& operator << (ofstream&, HOCSINH&); }; ifstream& operator >> (ifstream& file_inp, HOCSINH& hs) { file_inp>>hs.sbd; file_inp>>hs.ns.d>>hs.ns.m>>hs.ns.y; file_inp>>hs.diem[1]>>hs.diem[2]>>hs.diem[3]; return file_inp; } ofstream& operator << (ofstream& file_out, HOCSINH& hs) { file_out<<hs.sbd<<"\n"; file_out<<hs.ns.d<<"/"<<hs.ns.m<<"/"<<hs.ns.y<<"\n"; file_out<<hs.diem[1]<<" " <<hs.diem[2]<<" " <<hs.diem[3]<<"\n\n"; return file_out; } void main() { ifstream finp(TableResult); ofstream fout(TableFilter); if(!finp) { cout<<"File "<<TableResult<<" not found"; return; } HOCSINH hs; while(!finp.eof())

124

Nguyn Ch Trung
{ finp>>hs; if (!finp.eof()) if(hs.tongdiem() >= 15) fout<<hs; } finp.close(); fout.close(); }

MT S VN KHC LM VIC VI TP M tp bng open Ngoi vic s dng constructor m tp, c th dng hm thnh phn open() m tp.
ofstream fout; fout.open(fname); // cc lnh ghi tp fout.close(); ... ifstream finp; finp.open(fname); // cc lnh c tp finp.close();

Thng dng open() kt hp vi close() lm vic vi nhiu tp. Cc ch lm vic vi tp C++ cho php lm vic vi tp cc ch (mode) khc nhau, chng hn nh ch tp nh phn. Cc ch ny c xc nh qua cc hng quy nh cho ios trong lnh m tp. V d: ifstream f("C:\\data\\test.dat", ios::binary ) ; l lnh to lp i tng f thuc lp ifstream xc nh tp "test.dat" trong mode nh phn. Bng sau y nh ngha cc mode m tp Bng cc mode m tp Mode ngha ios::out M tp ch ghi ios::trunc Xo ni dung ca fiel nu tp tn ti ios::app Ghi b sung vo cui tp ios::ate Chuyn con tr tp v cui tp sau khi m ios::binary M tp mode nh phn ios::in M tp ch c ios::nocreate Khng m tp khi tp cha c 125

Nguyn Ch Trung ios::noreplace Khng m tp khi tp c

M tp mode ios::out ging nh mode ios::trunc, ios::app, ios::ate ch u chuyn con tr v cui tp nu m thnh cng. Khc nhau ch, trng hp ios::out th cho php ghi b sung vo cui tp, cc trng hp sau cho php thay i v tr bt k trong tp. c/ ghi tp nh phn Tp kiu nh phn ghi v c trung thnh mi k t trong tp. Vic ghi tp c thc hin ghi theo cc byte nh phn nh trong b nh. Vic c tp dng li khi gp k t m EOF. Tp nh phn khng phn bit cc k t cch (m 32), cc k t CR, LF. Do khng th thao tc ging nh tp vn bn trong vic c, ghi d liu cc mc d liu ngn cch bi du cch (v d nh d liu s) v ngn cch theo dng (tp vn bn t chc theo dng). Trong C++: vic m , ng tp nh phn cng tng t nh tp vn bn, ngoi tr vic s dng hng ios::binary trong lnh m tp. Ngoi ra, vic c/ghi tp nh phn tt nht l lm vic theo tng k t trong tp. i vi tp nh phn nn thc hin cc thao tc x l tun t theo tng mu tin bng cc hm sau y trong tp fstream.h: (Mu tin c th l cc k t; cc bin cng kiu struct, cc i tng cng mt lp,....) put() : ghi tng k t get() : c tng k t write(): ghi vo tp mt mu tin. Cc mu tin y c hiu nh cc khi d liu c kch thc (s bytes) khng i, v d nh cc bin cng kiu struct. read(): c mt mu tin. seekg(k): nh v con tr tp (tp m c) n bytes th k+1 seekp(k): nh v con tr tp (tp m ghi) n byte th k+1 tellg(): xc nh v tr hin thi ca con tr tp (c) tellp(): xc nh v tr hin thi ca con tr tp (ghi) V d 4.5 V d sau y c tt c cc loi k t trong tp test.dat v ghi ra mn hnh.
#include <iostream.h>#include <fstream.h> #include <conio.h> #define fname "test.dat" void main() { ifstream fb(fname, ios::binary); if(!fb) { cout<<"Khong co file << fname; return;} while(!fb.eof()) { char c; fb.get();

126

Nguyn Ch Trung
cou<<c; } getch(); }

V d 4.6 V d di y minh ho vic m v to tp mi (nu cha c) v c/ghi vo tp cc mu tin l cc i tng trong mt lp.
#include <iostream.h> #include <fstream.h> #include <stdio.h> #include <conio.h> #define fname "hocsinh.dat" const int N=3; class HOCSINH{ char ht[30]; int ns; float dtb; public: void read_data(void); void write_data(void); }; void HOCSINH::read_data(void) { cout<<"Ho va ten: "; gets(ht); cout<<"Nam sinh: "; cin>>ns; cout<<"Diem trung binh: "; cin>>dtb; } void HOCSINH::write_data(void) { cout.precision(1); cout<<"Ho va ten: "<<ht<<"\n"; cout<<"Nam sinh: "<<ns<<"\n"; cout<<"Diem trung binh: "<<dtb<<"\n"; } HOCSINH hs[N]; void main() { fstream fb(fname,ios::binary | ios::app); if(!fb) { cout<<"Khong co file "<<fname; return; } cout<<"Nhap thong tin cho cac hoc sinh:\n";

127

Nguyn Ch Trung
for(int i=0;i<N;i++) { hs[i].read_data(); fb.write((char*) &hs[i], sizeof(hs[i])); } fb.seekg(0); // chuyen con tro ve dau file cout<<"Kiem tra cac thong tin trong file:\n"; for(i=0;i<N;i++) { fb.read((char*) &hs[i], sizeof(hs[i])); hs[i].write_data(); } fb.close(); getch();}

BI TP CHNG 4 Bi 4.1 Vit chng trnh C++ nh ngha lp s phc v sinh ngu nhin d liu cho n i tng (n l s nguyn dng chn), vi mi i tng, ghi d liu ca n vo mt dng ca tp sophuc.txt (gm hai s thc biu th phn thc v phn o ca s phc tng ng, mi s thc ly 2 ch s sau phn thp phn). Bi 4.2 Vit chng trnh C++ : - nh ngha lp s phc vi cc php ton ti bi thn thin cng, tr v nhn hai s phc. - c tng cp s phc trong tp sophuc.txt c to ra trong bi 4.1, thc hin cc php cng, tr v nhn hai s phc. Kt qu ca mi php ton l mt s phc ghi vo mt dng ca tp sophuc2.txt . Trong tp sophuc2.txt gm cc b ba dng, cc b ny cch nhau mt dng trng. Bi 4.3 Cho tp matran.inp l mt tp vn bn (c to bng tay): - Dng mt ghi s nguyn dng n (n20) - n dng tip theo biu th mt ma trn vung A cp n, cc phn t l mt s thc. Phn t th j trn dng th i l s thc biu th gi tr ca A[i][j], i,j = 1,2,..,n. Cc s thc c 2 ch s sau phn thp phn v ngn cch bi t nht mt k t trng (m 32). - Tip theo l mt dng trng. - n dng cui cng biu th mt ma trn vung B cp n, cc phn t l mt s thc, c khun dng trnh by nh ma trn A. Vit chng trnh C++ : - nh ngha lp cc ma trn vung cp n, cc phn t l cc s thc vi cc php ton ti bi thn thin: vo/ra ma trn trao i vi tp vn bn; cng v nhn hai ma trn. 128

Nguyn Ch Trung - Vn dng lp ma trn va xy dng, hy c hai ma trn A v B vo b nh, tnh cc ma trn C = A + B v D = A x B. Cc ma trn C v D c ghi vo tp vn bn matran.out vi khun dng c trnh by nh hai ma trn A v B trong tp d liu vo. Bi 4.4 Vit chng trnh C++: - nh ngha lp mt hng gm: . Tn hng . n gi . S lng . Nh cung cp - nh ngha cc hm thnh phn thn thin . Vo/ra i tng mt hng t bn phm v mn hnh . Vo/ra i tng mt hng t tp input v tp output l cc tp nh phn. Vn dng cc nh ngha trn, chng trnh thc hin cc nhim v sau y: - To tp nh phn c tn l mathang.dat lu thng tin ca n mt hng c nhp t bn phm, s nguyn dng n 10 c nhp t bn phm. - c tng mt hng t tp mathang.dat v hin th ln mn hnh. Bi 4.5* Tip tc pht trin lp String tm hiu trong mc 2.4.7, hy b sung cc hm thnh phn thn thin sau y n gin ho vic s dng mt xu k t: char *copy(char *s, int k, int n) : cho gi tr l xu k t con ca xu s gm n k t, bt u t v tr k int pos(char *x, char *s) : cho bit v tr xut hin ln u tin ca xu x trong xu s. char *delete(char *s, int k, int n) : xo n k t trong xu s, tnh t k t th i char *insert(char *x, char *s, in k) : chn xu x vo xu s bt u t sau k t th k. Vn dng lp va nh ngha cng vi cc hm c b sung gii cc bi ton con (application) sau y: Cho mt tp vn bn, hy: - m s t, s cu. - m s ln xut hin mt xu k t con. - Tm cu gm nhiu t nht.

129

Nguyn Ch Trung PH LC 1: LP MU V HM MU Khi qut Trong lp trnh, nhiu khi c nhng on chng trnh tng ng v cng vic cn lm. trnh nhng cng vic c tnh cht lp i lp li nh vy, C++ h tr khi nim khun mu (template) Khun mu cho php ta nh ngha mt cng vic c tnh cht tng qut, chung chung, t c th to nn hng lot nhng cng vic c th theo mt cch no . C hai khun mu: Hm mu (function template) v lp mu (class template) Hm mu
Khai bo v nh ngha hm mu
template <class Etype1, class Etype2,...) return_type func_name(Etype1 v1,Etype2 v2,...) { //ni dung hm }

Cc v d

V d 1 Xy dng hm mu sao chp t mt A sang mt mng B c kiu d liu bt k v di ca 2 mng l tu first first last U
#include <iostream.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <string.h> template <class U, class V> V *copy(U *first,U *last,V *result) { while(first !=last) *result++ = *first++; return result; }

first last V T

130

Nguyn Ch Trung
template <class T> void write(T *first,T *last) { while(first !=last) cout<<*first++<< " "; cout<<endl; } template <class T> void read(T *first,T *last) { int i=0; while(first !=last) { cout<<"element["<<i++<<"]= "; cin>>*first++; } } int main() { clrscr(); const n=4; int a[n]; read(&a[0],&a[n]); const m=10; double b[m]; copy(&a[0],&a[n],&b[0]); write(&b[0],&b[n]); copy(&a[1],&a[n],&a[0]); write(&a[0],&a[n]); getche(); return 0;}

V du 2 Xy dng hm mu sp xp mt danh sch c kiu bt k.

#include <iostream.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <string.h> template <class Etype> void putdata(Etype *first,const int n) { int i=0; while(i++<n) cout<<*first++<< " "; cout<<endl;} template <class Etype> void getdata(Etype *first,const int n) { int i=0; while(i<n)

131

Nguyn Ch Trung
{ cout<<"element["<<i++<<"]= "; cin>>*first++; } } template <class Etype> void InsertionSort(Etype A[],const int n) { for(int i=1;i<n;i++) { Etype x=A[i]; int j; for(j=i;j>0 && A[j-1]>x ;j--) A[j]=A[j-1]; A[j]=x; } } int main() { clrscr(); const m=4; int a[m]; getdata(a,m); putdata(a,m); InsertionSort(a,m); putdata(a,m); double b[6]; getdata(a,6); putdata(a,6); InsertionSort(a,6); putdata(a,6); getche(); return 0; }

Lp mu
Khai bo lp mu v nh ngha cc hm thnh phn trong lp mu
template <class Etype> class class_name { // ni dung lp mu };

v
template <class Etype> return_type class_name::func_name(arg_list) { // ni dung hm mu }

Cc v d

V d 1 Xy dng lp mu SWAP gm 2 thnh phn d liu c kiu bt k v cho php hon i gi tr ca 2 thnh phn d liu .
#include <iostream.h>

132

Nguyn Ch Trung
#include <conio.h> template <class Etype> class SWAP { Etype x,y; public: SWAP(Etype a,Etype b) { x=a; y=b; } void swap(); void print(); }; template <class Etype> void SWAP<Etype>::swap() { Etype z=x; x=y; y=z; } template <class Etype> void SWAP<Etype>::print() { cout<<" x = "<<x<<" y = "<<y <<endl; } int main() { SWAP<int> s1(4,5); SWAP<char> s2('A','M'); s1.print(); s1.swap(); s1.print(); s2.print(); s2.swap(); s2.print(); return 0; }

V d 2 Xy dng lp mu VECTOR c kiu d liu bt k vi cc phng thc cho php: Gn 2 vc t cng kiu Vo / ra 1 vc t
#include <iostream.h> #include <conio.h> #include <stdlib.h> #include <string.h> template <class Etype> class VECTOR { int size; Etype *array; public: VECTOR(int); ~VECTOR() { delete [] array ;} const Etype& operator [](int) const ; // kiem tra tinh dung dan cua chi so trong gioi han const VECTOR& operator = (const VECTOR &RS);

133

Nguyn Ch Trung
// phep gan 2 doi tuong friend ostream& operator << (ostream&,VECTOR&); friend istream& operator >> (istream&,VECTOR&); }; template <class Etype> VECTOR<Etype>:: VECTOR(int n) { size = n; array = new Etype[size]; } template <class Etype> const Etype& VECTOR<Etype>:: operator [] (int index) const { if(index<0 || index>size) {cout << " Index out of range."; abort();} return array[index]; } template <class Etype> const VECTOR<Etype>& VECTOR<Etype>::operator = (const VECTOR<Etype> &RS) { if (this!=&RS) { if (size != RS.size) { cout<< " In incompatible array size. " ; abort();} for(int i=0;i<size;i++) array[i]=RS.array[i]; } return *this; } template <class Etype> ostream& operator << (ostream &dout,VECTOR<Etype> &V) { dout<<"("; int k=V.size-1; for(int i=0;i<k;i++) dout<<V.array[i]<<","; dout<<V.array[k]<<")\n"; return dout; } template <class Etype> istream& operator >> (istream &din,VECTOR<Etype> &V) { for(int i=0;i<V.size;i++) {cout<<"array["<<i<<"]= "; din>>V.array[i]; } return din;

134

Nguyn Ch Trung
} int main() { clrscr(); VECTOR<int> a(4),b(4); cin>>a; b=a; cout<<b; VECTOR<char> x(3),y(3); cin>>x; y=x; cout<<y; getche(); return 0; }

Ch , nu trong main, ta mun p dng lp VECTOR i vi cc lp m kiu d liu bt k, v d:

VECTOR<SINHVIEN> sv(2),u(2); cin>>sv; cout<<sv; u=sv; cout<<u; Th ta cn b i hm thnh phn const Etype& operator [](int) const ; V thm vo lp SINHVIEN nh sau: class SINHVIEN { char *name; int age; public: friend ostream& operator << (ostream&,SINHVIEN&); friend istream& operator >> (istream&,SINHVIEN&); }; ostream& operator << (ostream &dout,SINHVIEN &s) { dout<<s.name<<" "<<s.age; return dout; } istream& operator >> (istream &din,SINHVIEN &s) { char st[20]; cout<<"\n name: "; gets(st); int l=strlen(st); s.name=new char[l+1]; strcpy(s.name,st); int k;

135

Nguyn Ch Trung
cout<<"age: "; din>>k; s.age=k; return din; }

Hn ch ca lp mu, hm mu: Mc d v mt l thuyt cho php khai bo lp mu/ hm mu c kiu d liu bt k, song khng th p dng cho tt c cc lp bt k khc nhau v l do d liu thnh phn ca cc lp l khc nhau v do ni dung ci t bn trong cc hm mu, bn trong cc hm thnh phn trong cc lp cng khc nhau.

136

Nguyn Ch Trung PH LC 2: GII THIU MT S BI TON PHN TCH THIT K HNG I TNG TRN C++ S lc 5 bc thc hin
Bc 1

Phn tch bi ton xc nh c danh sch cc i tng - Phn tch ni dung m t bi ton gm nhng danh t ch ngi, ch vt, ch s kin c l l i tng. - Phn tch cc h thng thc v cc ti liu h s m t h thng gn vi h thng cn xy dng. - Da vo kinh nghim v kin thc ca ngi lp trnh xc nh c cc i tng. Ch : bc ny quan tm n nhim v bi ton m ch quan tm n yu t to thnh i tng.
Bc 2

Phn tch mi quan h gia cc i tng xy dng cu trc phn cp cc i tng m t quan h k tha gia cc lp i tng. Vic phn tch m bo cc vn sau y: - Tn dng sa li cc c tnh v php tnh t lp cha. - C th cn tnh n hiu qu thit k v ci t m chn la thay i li cc quan h k tha. - Thc hin tru tng ho cc lp, nht l lp c s.
Bc 3

Phn tch bi ton xy dng thnh phn cc lp. To bng 3 ct: Ct 1: Tn lp (k tha t lp no, mode k tha). Ct 2: D liu thnh phn. Ct 3: Hm thnh phn.
Bc 4

nh ngha cc lp i tng trong ngn ng hng i tng

Bc 5

Thit k phn mm bng ngn ng ni trn. Xy dng lp hnh hc phng

Cc bc phn tch v thit k

Xy dng cc lp hnh hc phng v cc hnh vi kch thc, mu, hnh dng v to nguyn xc nh. Bc 1: Xc nh cc i tng: - im - on thng- Hnh ch nht- Hnh vung- Hnh thang- Hnh bnh hnh - Hnh thoi - Hnh trn - Hnh tam gic. 137

Nguyn Ch Trung Bc 2: Lc mi quan h gia cc i tng

DOANTHANG

HINH

DIEM

HCHUNHA

HVUONG

TAMGIAC HTRON HTHANG

BINHHANH

HTHOI

138

Nguyn Ch Trung Bc 3: Xy dng bng cc thnh phn lp v quan h k tha

Lp HINH D liu thnh phn int x,y ; // to v Hm thnh phn virtual void VE()=0; // o ths virtual void XOA()=0; void CHUYENDI(int dx,int dy) ; void CHUYENDEN(int x2,int y2); virtual void VE(); virtual void XOA(); void VE(); void XOA(); void VE(); void XOA(); void VE(); void XOA(); void VE(); void XOA(); void VE(); void XOA(); void VE(); void XOA(); void VE(); void XOA(); void VE(); void XOA();

DIEM:HINH DOANTHANG:DIEM HCHUNHAT:DIEM HVUONG:HCHUNHAT TAMGIAC:DIEM HTRON:DIEM HTHANG:DIEM BINHHANH:HTHANG HTHOI:BINHTHANG

int c; // mu im v int x1,y1; // to ch int a,b; // cnh (a==b) int x1,y1,x2,y2; int r; //bn knh int a,b,c,d,h; (a==b) (c==d)

Xy dng cc lp i tng vi mi quan h (k tha) nh a phn tch, thit k. Vn dng vi mt s chng trnh demo - V 200 ng trn mu vng lng nhau - V mt chm 30 tam gic ngu nhin nhng chung nh - V mt mn hnh caro mu xanh ng k xanh dng
Ci t trn C++
#include <graphics.h> #include <math.h> #include <iostream.h> #include <conio.h> #include <stdlib.h> // LOP HINH TONG QUAT //==================== class HINH {

139

Nguyn Ch Trung
protected: int x,y; //toa do ve public: HINH(){x=y=0;} HINH(int x1,int y1) {x=x1;y=y1;} virtual void VE()=0; virtual void XOA()=0; void CHUYENDI(int,int); void CHUYENDEN(int,int); }; void HINH::CHUYENDI(int x1,int y1) { XOA(); x+=x1; y+=y1; VE(); } void HINH::CHUYENDEN(int x1,int y1) { XOA(); x=x1; y=y1; VE(); } // LOP DIEM <-- HINH //======================== class DIEM:public HINH { protected: int c; //mau sac public: DIEM():HINH() {c=0;} DIEM(int x1,int y1,int c1): HINH(x1,y1) { c=c1;} virtual void VE(); virtual void XOA(); }; void DIEM::VE() { putpixel(x,y,c); } void DIEM::XOA() { int k=getbkcolor(); putpixel(x,y,k); } // LOP DOANTHANG <-- DIEM //============================== class DOANTHANG: public DIEM { int x1,y1 ; // toa do diem thu 2 public: DOANTHANG(): DIEM() {x1=y1=0;}

140

Nguyn Ch Trung
DOANTHANG(int a1,int b1,int c1,int a2,int b2) : DIEM(a1,b1,c1) {x1=a2,y1=b2;} void VE(); void XOA(); }; void DOANTHANG::VE() { setcolor(c); moveto(x,y); lineto(x1,y1); } void DOANTHANG::XOA() { int k=getbkcolor(); setcolor(k); moveto(x,y); lineto(x1,y1); } // LOP HCHUNHAT <-- DIEM //============================= class HCHUNHAT: public DIEM { protected: int a,b; public: HCHUNHAT(): DIEM() { a=b=0;} HCHUNHAT(int x1,int y1,int c1,int a1,int b1) : DIEM(x1,y1,c1) { a=a1; b=b1; } void VE(); void XOA(); }; void HCHUNHAT::VE() { setcolor(c); rectangle(x,y,x+a,y+b); } void HCHUNHAT::XOA() { int k=getbkcolor(); setcolor(k); rectangle(x,y,x+a,y+b); } // LOP HVUONG <-- HCHUNHAT //============================== class HVUONG:public HCHUNHAT { public: HVUONG():HCHUNHAT() {;} HVUONG(int x1,int y1,int c1,int a1):HCHUNHAT(x1,y1,c1,a1,a1) {;} };

141

Nguyn Ch Trung
// LOP TAMGIAC <-- DIEM //=========================== class TAMGIAC:public DIEM { int x1,y1,x2,y2; public: TAMGIAC():DIEM() {;} TAMGIAC(int a1,int b1,int c1,int a2,int b2,int a3,int b3) :DIEM(a1,b1,c1) {x1=a2;y1=b2;x2=a3;y2=b3;} void VE(); void XOA(); }; void TAMGIAC::VE() { setcolor(c); moveto(x,y); lineto(x1,y1); lineto(x2,y2); lineto(x,y); } void TAMGIAC::XOA() { int k=getbkcolor(); setcolor(k); moveto(x,y); lineto(x1,y1); lineto(x2,y2);} // LOP HTRON <-- DIEM //=========================== class HTRON: public DIEM { int r; public: HTRON(): DIEM() {;} HTRON(int a1,int b1,int c1,int r1): DIEM(a1,b1,c1) {r=r1;} void VE(); void XOA(); }; void HTRON::VE() { setcolor(c); circle(x,y,r); } void HTRON::XOA() { int k=getbkcolor(); setcolor(k); circle(x,y,c); } // LOP HTHANG <-- DIEM //=========================== class HTHANG: public DIEM { protected: int a,b,c,d,h; public:

142

Nguyn Ch Trung
HTHANG():DIEM() {;} HTHANG(int x1,int y1,int m1,int a1,int b1,int c1,int d1,int h1) :DIEM(x1,y1,m1) {a=a1;b=b1;c=c1;d=d1;h=h1;} void VE(); void XOA(); }; void HTHANG::VE() { setcolor(c); moveto(x,y); lineto(x+a,y); int k=sqrt(d*d-h*h); if (d*d<h*h) cout<<"Error 1 !"<<endl; lineto(x+a+k,y+h); int k1=sqrt(c*c-h*h); if (c*c<h*h) cout<<"Error 2 !"<<endl; lineto(x-k1,y+h); lineto(x,y); } void HTHANG::XOA() { int co=getbkcolor(); setcolor(co); moveto(x,y); lineto(x+a,y); int k=sqrt(d*d-h*h); lineto(x+a+k,y+h); int k1=sqrt(c*c-h*h); lineto(x-k1,y+h); lineto(x,y); } // LOP BINHHANH <-- HTHANG //============================== class BINHHANH: public HTHANG { public: BINHHANH():HTHANG() {;} BINHHANH(int x1,int y1,int m1,int a1,int c1,int d1,int h1) :HTHANG(x1,y1,m1,a1,a1,c1,d1,h1) {;} }; // LOP HTHOI <-- HTHANG //============================== class HTHOI: public HTHANG { public: HTHOI():HTHANG() {;} HTHOI(int x1,int y1,int m1,int a1,int c1,int h1) :HTHANG(x1,y1,m1,a1,a1,c1,c1,h1) {;} }; //========= THE END CLASS ============

143

Nguyn Ch Trung
const int sh=8; const int mau=15; const maxx=640; const maxy=480; //=============== DEMO =============== void demo1() // ve 200 duong tron long nhau { int xx,yy,cc; xx=maxx/2; yy=maxy/2; cc=14; for(int rr=1;rr<200;rr+=10) {HTRON s(xx,yy,cc,rr); s.VE();} } void demo2() { int xx1,yy1,xx2,yy2,xx3,yy3,cc; xx1=random(100)%maxx; yy1=random(100)%maxy; for(int i=0;i<30;i++) { xx2=(xx1+random(200))%maxx; yy2=(yy1+random(200))%maxy; xx3=(xx2+random(300))%maxx; yy3=(yy2+random(300))%maxy; cc=random(mau); TAMGIAC tg(xx1,yy1,cc,xx2,yy2,xx3,yy3); tg.VE(); } } void demo3() { int xx,yy; setbkcolor(BLUE); int cc=CYAN; for(yy=0;yy<maxy;yy+=10) {DOANTHANG dt(0,yy,cc,maxx,yy); dt.VE(); } for(xx=0;xx<maxx;xx+=10) {DOANTHANG dt(xx,0,cc,xx,maxy); dt.VE(); } } int main() { int drive = DETECT, mode; initgraph(&drive,&mode,"D:\\TC"); demo1(); // demo2(); // demo3(); getch(); closegraph(); return 0; }// DEMO CAP PHAT BO NHO CHO MANG CAC DOI TUONG void demo0() { int loaih; int xx,yy,cc; randomize();

144

Nguyn Ch Trung
HINH *H[sh]; int dem=0; while (dem<20) { dem++; for(int i=0;i<sh;i++) { loaih = random(sh); xx=random(maxx); yy=random(maxy); cc=random(mau); switch(loaih) { case 0: //diem H[i]=new DIEM(xx,yy,cc); break; case 1: //doan thang int x2;int y2; x2=xx+100; y2=yy+200; H[i]=new DOANTHANG(xx,yy,cc,x2,y2); break; case 2: //tam giac int x3;int y3; x3=xx+150; y3=yy+200; H[i]=new TAMGIAC(xx,yy,cc,x2,y2,x3,y3); break; case 3: //hinh chu nhat int aa,bb; aa=random(100); bb=random(200); H[i]=new HCHUNHAT(xx,yy,cc,aa,bb); break; case 4: //hinh vuong aa=random(100); H[i]=new HVUONG(xx,yy,cc,aa); break; case 5: //hinh tron int r=random(200); H[i]=new HTRON(xx,yy,cc,r); break; case 6: //hinh thang int cc,dd,hh; aa=random(100); bb=random(200); hh=random(100); cc=hh + random(50); dd=hh + random(50); H[i]=new HTHANG(xx,yy,cc,aa,bb,cc,dd,hh); break; case 7: //hinh binh hanh aa=random(200); hh=random(100); cc= hh + random(50); dd= hh + random(50); H[i]=new BINHHANH(xx,yy,cc,aa,cc,dd,hh); break; case 8: //hinh thoi aa=random(200); hh=random(100); cc=hh + random(50); H[i]=new HTHOI(xx,yy,cc,aa,cc,hh); break; }//switch H[i]->VE(); }//for for(i=0;i<sh;i++) {delete H[i];} } //while

145

Nguyn Ch Trung
}

Qun l cc l t
Phn tch thit k

Xy dng lp cc l t vi cc hnh dng khc nhau vn dng vo chng trnh qun l bt ng sn ca mt cng ty gii thiu bn nh t. Bc 1: Xc nh cc i tng: - LODAT - HTHANG - HCHUNHAT - HVUONG - HINHTRON

146

Nguyn Ch Trung Bc 2: Lc mi quan h gia cc i tng LODAT

HTRON

HTHANG HCHUNHAT HVUONG

Bc 3: Xy dng bng cc thnh phn lp v quan h k tha

Lp D liu thnh phn Hm thnh phn float dongia() float tonggiatri() virtual int style() = 0; virtual float CHUVI() = 0; virtual float DIENTICH() = 0; virtual void display() = 0; virtual int style() ; virtual float CHUVI() ; virtual float DIENTICH() ; virtual void display() ; virtual int style() ; virtual float CHUVI() ; virtual float DIENTICH() ; virtual void display() ; virtual int style() ; virtual float CHUVI() ; virtual float DIENTICH() ; virtual void display() ; virtual int style() ; virtual float CHUVI() ; virtual float DIENTICH() ; void display() ;

LODAT

int x,y; // v tr float cost ; // n gi

HTHANG:LODAT

float a,b,c,d,h ;

HCHUNHAT:HTHANG

(a==b=h, c==d,)

HVUONG:HCHUNHAT

(a==b)

HTRON:LODAT

float r;

Ci t trn C++
* Xy dng cc lp i tng vi mi quan h (k tha) nh a phn tch, thit k. #include <iostream.h>

147

Nguyn Ch Trung
#include <fstream.h> #include <conio.h> const float PI = 3.14; // LOP LODAT TONG QUAT //==================== class LODAT { protected: int x,y; //toa do lo dat float cost; // gia 1 met vuong dat public: LODAT(){x=y=cost=0;} LODAT(int x1,int y1,int c1) {x=x1;y=y1;cost=c1;} float dongia() { return cost; } float tonggiatri() { return cost*DIENTICH() ;} virtual int style()=0; virtual float CHUVI()=0; virtual float DIENTICH()=0; virtual void display(); }; void LODAT::display() { cout<<"\n vi tri: ("<<x<<","<<y<<")"; cout<<"\n don gia: "<< cost ; } // LOP HINH THANG <-- LODAT // ========================= class HTHANG:public LODAT { protected: float a,b,c,d,h; // bon kich thuoc va duong cao public: HTHANG(): LODAT() { a=b=c=d=h=0; } HTHANG(int x1,int y1,float cost1,float a1,float b1,float c1,float d1,float h1) : LODAT(x1,y1,cost1) { a=a1;b=b1;c=c1;d=d1;h=h1;} virtual int style() {return 1;} virtual float CHUVI() { return a+b+c+d;} virtual float DIENTICH() { return ((a+b)*h)/2; } virtual void display(); }; void HTHANG::display() { cout<<"\n vi tri: ("<<x<<","<<y<<")"; cout<<"\n don gia: "<< cost; cout<<"\n lo dat hinh thang voi kich thuoc la: "; cout<<"\n canh tren: "<<a <<"\n canh duoi: "<<b

148

Nguyn Ch Trung
<<"\n canh trai: "<<c <<"\n canh phai: "<<d; cout<<"\n CHU VI: "<<CHUVI(); cout<<"\n DIEN TICH: "<<DIENTICH(); cout<<"\n=================="; } // LOP HINH CHU NHAT <-- HTHANG // ========================= class HCHUNHAT:public HTHANG { public: HCHUNHAT(): HTHANG() {;} HCHUNHAT(int x1,int y1,float cost1,float a1,float b1) : HTHANG(x1,y1,cost1,a1,a1,b1,b1,a1){;} int style() {return 2;} float CHUVI() {return (a+c)*2;} float DIENTICH() {return a*c;} virtual void display(); }; void HCHUNHAT::display() { cout<<"\n vi tri: ("<<x<<","<<y<<")"; cout<<"\n don gia: "<< cost; cout<<"\n lo dat hinh chu nhat voi kich thuoc la: "; cout<<"\n canh a: "<<a <<"\n canh b: "<<c; cout<<"\n CHU VI: "<<CHUVI(); cout<<"\n DIEN TICH: "<<DIENTICH(); cout<<"\n=================="; } // LOP HINH VUONG <-- HCHUNHAT // ========================= class HVUONG:public HCHUNHAT { public: HVUONG(): HCHUNHAT() {;} HVUONG(int x1,int y1,float cost1,float a1) : HCHUNHAT(x1,y1,cost1,a1,a1){;} int style() {return 3;} float CHUVI() {return a*4;} float DIENTICH() {return a*a;} virtual void display(); }; void HVUONG::display() { cout<<"\n vi tri: ("<<x<<","<<y<<")"; cout<<"\n don gia: "<< cost;

149

Nguyn Ch Trung
cout<<"\n lo dat hinh vuong voi kich thuoc la: "<<a; cout<<"\n CHU VI: "<<CHUVI(); cout<<"\n DIEN TICH: "<<DIENTICH(); cout<<"\n=================="; } // LOP HINHTRON <-- LODAT // ========================= class HTRON:public LODAT { protected: float r; public: HTRON(): LODAT() {;} HTRON(int x1,int y1,float cost1,float r1) : LODAT(x1,y1,cost1) {r=r1;} int style() {return 4;} float CHUVI() {return 2*PI*r;} float DIENTICH() {return PI*r*r;} virtual void display(); }; void HTRON::display() { cout<<"\n lo dat hinh tron voi ban kinh la: "<<r; cout<<"\n vi tri tam: ("<<x<<","<<y<<")"; cout<<"\n don gia: "<< cost; cout<<"\n CHU VI: "<<CHUVI(); cout<<"\n DIEN TICH: "<<DIENTICH(); cout<<"\n=================="; } const max=10; const char *f_name ="LODAT.DAT"; // gom 1 so lo dat, moi lo dat chiem 1 so dong theo thu tu nhu sau // - dong 1 gom 4 so tuong ung la hinh dang lo dat,toa do va don gia // - dong 2 la cac thuoc tinh tuong ung LODAT *LD[max]; int hinhdang; int xx,yy; float dg; float aa,bb,cc,dd,hh,rr; float sld; void nhap_dl()

150

Nguyn Ch Trung
{ ifstream f_input(f_name); f_input>>sld; for(int i=0;i<sld;i++) { f_input>>hinhdang>>xx>>yy>>dg; switch(hinhdang) { case 1: f_input>>aa>>bb>>cc>>dd>>hh; LD[i] = new HTHANG(xx,yy,dg,aa,bb,cc,dd,hh); break; case 2: f_input>>aa>>bb; LD[i] = new HCHUNHAT(xx,yy,dg,aa,bb); break; case 3: f_input>>aa; LD[i] = new HVUONG(xx,yy,dg,aa); break; case 4: f_input>>rr; LD[i] = new HTRON(xx,yy,dg,rr); break; default: break; } // switch } // for } // nhap_dl void in_dl() { for(int i=0;i<sld;i++) LD[i]->display();} void chon_hinhdang() { cout<<"\n 1: hinh thang, 2: hinh chu nhat, 3: hinh vuong, 4: hinh tron "; cout<<"\n Ban mua lo dat hinh dang: "; cin>>hinhdang; cout<<"\n co cac lo dat sau day "; for(int i=0;i<sld;i++) if(LD[i]->style()==hinhdang) LD[i]->display(); } int main() { nhap_dl(); int chon=1; do { clrscr(); cout<<"\n 1. xem cac lo dat "; cout<<"\n 2. chon mua 1 lo dat theo hinh dang "; cout<<"\n 0. thoat khoi chuong trinh "; cout<<"\n Ban chon: "; cin>>chon; if(!chon==0)

151

Nguyn Ch Trung
{ switch(chon) { case 1:in_dl(); break; case 2:chon_hinhdang(); break; default: break; } //switch getch(); } //if } while (!chon == 0); return 0; }// main

Tp LODAT.DAT 7 1 4 5 890 20 30 4 10 4 2 10 10 1900 30 40 3 15 21 2000 100 4 17 22 500 100 1 40 51 800 10 30 5 10 6 2 30 45 2100 20 45 4 71 32 550 120

152

Nguyn Ch Trung TI LIU THAM KHO [1] Mark Allen Weiss - Florida International University, 1998. Algorithms, Data Structures, and Problem Solving with C++ Addison-Wesley Publishing Company, Inc. [2] Scott Robert Ladd - United States of America, 1996. C++: Components And Algorithms M&T Books. A Division of MIS:Press,Inc. A Subsidiary of Henry Holt and Company, Inc.115 Wes 18th Street. New York, New York 10011 [3] Dng T Cng Lp trnh bng C++ Nh xut bn Khoa hc k thut, H Ni - 1998 [4] on Vn Ban - Trung tm KHTN v Cng ngh Quc Gia Phn tch, thit k v lp trnh hng i tng Nh xut bn thng k, H Ni - 1997

153