Giáo trình Phương pháp lập trình

Nội dung text: Giáo trình Phương pháp lập trình

1. Ph
   ng Pháp Lp Trình PHA¿N 1 CAŸC KHAŸI NIEƒM C‘ BA¤N Trang 1
2. Ph
   ng Pháp Lp Trình BAÿI 1: M‘¤ —A¿U KHAŸI NIEƒM VE¿ CH÷‘NG TRÃNH ñ THUAƒT TOAŸN ñ VAÿ —O¡I T÷‘œNG: La‰p trÏnh: (program m ing)la¯ mo‰t qua˘ trÏnh vie·t chˆÙng trÏnh baËng mo‰t ngo‚n ngˆı na¯o Òo˘ ma¯ ma˘y tÌnh co˘ the tra˚ lÙ¯i va¯ nhˆıng ngˆÙ¯i la‰p trÏnh kha˘c co˘ the hieÂu. Ta‰p hÙÔp ca˘c chÊ thÚ, dˆı lie‰u va¯ ca˘c nguye‚n taÈc du¯ng Òe xa‚y dˆÔng mo‰t chˆÙng trÏnh goÔi la¯ mo‰t ngo‚n ngˆı la‰p trÏnh. Ngo‚n ngˆı la‰p trÏnh co˘ the pha‚n loaÔi theo hai ca˘ch: + Ngo‚n ngˆı ba‰c cao ñ ngo‚n ngˆı ba‰c tha·p + Ngo‚n ngˆı hˆÙ˘ng thu˚ tuÔc ñ ngo‚n ngˆı hˆÙ˘ng Òo·i tˆÙÔng C++ la¯ mo‰t ngo‚n ngˆı ba‰c cao co˘ chˆ˘a ca˘c ÒaÎc trˆng cu˚a ca˚ hai loaÔi ngo‚n ngˆı hˆÙ˘ng thu˚ tuÔc ñ ngo‚n ngˆı hˆÙ˘ng Òo·i tˆÙÔng. Thua‰t toa˘n (Algorithm ) va¯ thu˚ tuÔc (procedure): Thua‰t toa˘n la¯ troÔng ta‚m cu˚a pha‡n la‰p trÏnh theo hˆÙ˘ng thu˚ tuÔc cu˚a C++ Mo‰t thua‰t toa˘n la¯ mo‰t ba˚ng mo‚ ta˚ sˆÔ tÌnh toa˘n, ˆÙ˘c tÌnh co‚ng vie‰c pha˚i thˆÔc hie‰n nhˆ the· na¯o. —o˘ la¯ trÏnh tˆÔ saÈp xe·p cu˚a ca˘c chÊ thÚ. - TrˆÙ˘c khi vie·t chˆÙng trÏnh ta pha˚i tÏm hieÂu ro˚ ra¯ng + Seı du¯ng nhˆıng dˆı lie‰u na¯o. + Ke·t qua˚ mong muo·n + Thu˚ tuÔc (chuoÂi ha¯nh Òo‰ng) seı du¯ng Òe ҈a ra ke·t qua˚ (ÒˆÙc xem nhˆ thua‰t toa˘n) - - Sau khi Òaı hieÂu ro˚ ca˘c va·n Òe‡ tre‚n chu˘ng ta co˘ the vie·t chˆÙng trÏnh baËng mo‰t ngo‚n ngˆı la‰p trÏnh na¯o Òo˘. (Va‰y ro˚ ra¯ng ngo‚n ngˆı la‰p trÏnh theo hˆÙ˘ng thu˚ tuÔc la¯ co‚ng cuÔ Òe chuyeÂn thua‰t toa˘n va¯o mo‰t ngo‚n ngˆı ma¯ ma¯y tÌnh co˘ the hieÂu). - Tho‚ng thˆÙ¯ng trˆÙ˘c mo‰t ba¯i toa˘n ngˆÙ¯i ta thˆÙ¯ng co˘ khuynh hˆÙ˘ng suy nghÛ trˆÔc quan ra ca˘ch gia˚i (phˆÙng pha˘p) nhˆng kho‚ng Òˆa ra ÒˆÙÔc thua‰t gia˚i Òe tˆ¯ Òo˘ chuyeÂn tha¯nh mo‰t chˆÙng trÏnh co˘ the thˆÔc hie‰n tre‚n ma˘y tÌnh. - Mo‰t thua‰t toa˘n kho‚ng pha˚i la¯ mo‰t chˆÙng trÏnh, no˘ co˘ the ҈ÙÔc mo‚ ta˚ bÙ˚i mo‰t trong ba ca˘ch + Du¯ng ca˘c cuÔm tˆ¯ gÙÔi nhÙ˘ (pseudocode) + Du¯ng ca˘c phˆÙng trÏnh toa˘n hoÔc (formula) + Du¯ng ca˘c bieÂu tˆÙÔng ÒˆÙÔc qui ÒÚnh Òe bieÂu die„n gia˚i thua‰t (flowchart) Trang 2
3. Ph
   ng Pháp Lp Trình Trong Òo˘ pseudocode thˆÙ¯ng ÒˆÙÔc sˆ˚ duÔng L8/" (Classes) va¯ —o·i tˆÙÔng) Objects: classes la¯ troÔng ta‚m cu˚a ngo‚n ngˆı la‰p trÏnh hˆÙ˘ng Òo·i tˆÙÔng bÙ˚i vÏ ca˘c Òo·i tˆÙÔng ÒˆÙÔc taÔo tˆ¯ ca˘c lÙ˘p. Ca˘c lÙ˘p dˆÙÔc pha‚n loaÔi dˆÔa va¯o hai ÒaÎc ÒieÂm: dˆı lie‰u va¯ ca˘c phˆÙng pha˘p co˘ the a˘p duÔng cho dˆı lie‰u na¯y Mo‰t Òo·i tˆÙÔng la¯ mo‰t trˆÙ¯ng hÙÔp cuÔ the cu˚a mo‰t lÙ˘p. VÌ duÔ: LÙ˘p so· nguye‚n: bao go‡m ca˘c so· nguye‚n va¯ ca˘c phe˘p toa˘n +,-.*,/ ,mod,div So‚ 5 la¯ mo‰t Object thuo‰c lÙ˘p so· nguye‚n. I. HAÿM ñ CAŸC L‘ŸP ñ HAÿM m ain() Mo‰t chˆÙng trÏnh co˘ ca·u tru˘c bao go‡m nhie‡u ÒoaÔn ÒˆÙÔc saÈp ÒaÎt theo mo‰t trÏnh tˆÔ logic na¯o Òo˘, mo„i ÒoaÔn tˆÙng ˆ˘ng mo‰t chˆ˘c naÍng co˘ trong chˆÙng trÏnh. Mo‰t chˆÙng trÏnh ÒˆÙÔc xa‚y dˆÔng theo ca˘ch na¯y goÔi la¯ chˆÙng trÏnh ÒÙn the (modular programs). Mo„i ÒÙn the co˘ the sˆ˚ duÔng ca˘c ÒÙn the nho˚ hÙn goÔi la¯ modules. Trong C++ mo„i modules co˘ the la¯ lÙ˘p hoa‰c ha¯m. Ha¯m la¯ ÒÙn vÚ chˆ˘a mo‰t chuoÂi lie‚n tuÔc ca˘c toa˘n tˆ˚ Mo„i ha¯m co˘ mo‰t te‚n Òe pha‚n bie‰t, te‚n ha¯m trong C ÒˆÙÔc ÒaÎt theo qui taÈc sau:(cuıng la¯ qui taÈc ÒaÎt te‚n cho ca˘c danh ÒÚnh sau na¯y) + ChÊ ÒˆÙÔc du¯ng chˆı ca˘i, chˆı so· hoaÎc da·u _ Òe ÒaÎt te‚n ha¯m + Ky˘ tˆÔ Òa‡u tie‚n pha˚i la¯ mo‰t chˆı ca˘i hoaÎc da·u _ + Te‚n ha¯m kho‚ng ÒˆÙÔc tru¯ng te‚n vÙ˘i tˆ¯ kho˘a + Co˘ pha‚n bie‰t chˆı hoa, chˆı thˆÙ¯ng. Tho‚ng thˆÙ¯ng ta du¯ng chˆı thˆÙ¯ng Òe ÒaÎt te‚n cho ha¯m, bie‡n chˆı hoa ÒaÎt te‚n cho ha¯m. + So· ky˘ tˆÔ to·i Òa la¯ 31 Ha¯m m ain() Mo„i chˆÙng trÏnh trong C++ pha˚i co˘ mo‰t va¯ duy nha·t mo‰t ha¯m main. Ha¯m na¯y ÒˆÙÔc xem nhˆ ha¯m Òie‡u khieÂn, bÙ˚i vÏ no˘ ÒieÂu khieÂn(goÔi thˆÔc hie‰n) ca˘c module kha˘c. Ca·u tru˘c ha¯m main nhˆ sau: main() { program statements; return } VÌ duÔ: int main() { cout << ìHelloî; return 0; Trang 3
4. Ph
   ng Pháp Lp Trình Z Trong trˆÙ¯ng hÙÔp mo‰t ha¯m kho‚ng muo·n tra˚ gia˘ trÚ ve¯ ta sˆ˚ duÔng khai ba˘o: void main() { program statements; return; } TrˆÙ¯ng hÙÔp na¯y no˘ gio·ng nhˆ mo‰t thu˚ tuÔc trong pascal II. cout OBJECT cout la¯ mo‰t object ÒˆÙÔc cung ca·p bÙ˚i C++ va¯ no˘ ra·t thˆÙ¯ng ÒˆÙÔc sˆ˚ duÔng trong ca˘c chˆÙng trÏnh. object na¯y co˘ co‚ng duÔng la¯ xua·t dˆı lie‰u le‚n ma¯n hÏnh cu˘ pha˘p cu˚a cout nhˆ sau: cout vÏ cout thuo‰c lÙ˘p ostream vÌ duÔ: #include int main() { cout << îC++ programming languageî; cout << îC++ \nprogramming\n languageî; cout << ìC++î << endl << ìprogrammingî <<endl << ìlanguageî; return 0; } III. VIE¡T CH÷‘NG TRÃNH V‘ŸI C++ - GHI CHUŸ TRONG CH÷‘NG TRÃNH: Mo„i chˆÙng trÏnh trong C++ co˘ the co˘ mo‰t hoaÎc nhie‡u ha¯m, nhˆng pha˚i co˘ mo‰t va¯ chÊ mo‰t ha¯m main(). Ca˘c le‰nh cu˚a mo‰t ha¯m pha˚i ÒaÎt giˆıa caÎp da·u {}. Cuo·i mo„i le‰nh trong ha¯m pha˚i co˘ da·u cha·m phaÂy (;) Tre‚n mo‰t do¯ng co˘ the chˆ˘a nhie‡u le‰nh Mo‰t le‰nh co˘ the vie·t tre‚n nhie‡u do¯ng, ngoaÔi trˆ¯ ca˘c haËng chuoÂi, danh ÒÚnh, va¯ tˆ¯ kho˘a. Trang 4
5. Ph
   ng Pháp Lp Trình Tuy nhie‚n ta ne‚n trÏnh ba¯y chˆÙng trÏnh mo‰t ca˘ch ro˚ ra¯ng Òe de„ ÒoÔc va¯ sˆ˚a chˆ˚a, vÌ duÔ sau Òa‚y cuıng la¯ mo‰t chˆÙng trÏnh co˘ the thˆÔc hie‰n ÒˆÙÔc nhˆng no˘ la¯ ÒieÂn hÏnh cho mo‰t ca˘ch trÏnh ba¯y chˆÙng trÏnh vo‚ cu¯ng ke˘m: #include int main ( ) { cout << ìHelloî ; return 0; } Haıy trÏnh ba¯y laÔi chˆÙng trÏnh tre‚n. Ghi chu˘ trong chˆÙng trÏnh: —aÎt no‰i dung ghi chu˘ sau caÎp da·u // . CAŸC LO√I TH÷‘ÿNG GAÀP KHI VIE¡T CH÷‘NG TRÃNH: - Bo˚ so˘t () sau main - Bo˚ so˘t hoaÎc Òa˘nh kho‚ng chÌnh xa˘c da·u { Ù˚ taÔi vÚ trÌ baÈt Òa‡u tha‚n cu˚a mo‰t ha¯m. - Bo˚ so˘t hoaÎc Òa˘nh kho‚ng chÌnh xa˘c da·u } Ù˚ taÔi vÚ trÌ ke·t thu˘c cu˚a mo‰t ha¯m. - Go˚ thie·u hoaÎc sai te‚n cu˚a mo‰t Òo‰i Òo·i tˆÙÔng hoaÎc ha¯m vÌ duÔ cot thay vÏ cout hay Cout (chˆı C vie·t hoa) - Kho‚ng ÒaÎt haËng chuoÂi va¯o caÎp da·u nha˘y ke˘p ìî - Thie·u da·u : sau mo„i ca‚u le‰nh Trang 5
6. Ph
   ng Pháp Lp Trình BAÿI 2 : CAŸC KIE≈U D÷’ LIEƒU ñ KHAI BAŸO ñ HIE≈N TH“ I. CAŸC KIE≈U D÷’ LIEƒU: Co˘ ba loaÔi dˆı lie‰u cÙ ba˚n ÒˆÙÔc du¯ng trong C++: so· nguye‚n (integer), so· thˆÔc (floating point numbers) va¯ ky˘ tˆÔ (character). LoaÔi thˆ˘ tˆ la¯ kieÂu boolean (loaÔi na¯y ÒˆÙÔc Òˆa va¯o theo chuaÂn ANSI/ISO mÙ˘i). So· nguye‚n: So· nguye‚n la¯ mo‰t so· co˘ gia˘ trÚ baËng 0 hoaÎc ba·t ky¯ mo‰t gia˘ trÚ a‚m hoaÎc dˆÙng ma¯ kho‚ng co˘ pha‡n tha‰p pha‚n. VÌ duÔ: 0 5 -10 234 VÙ˘i kieÂu dˆı lie‰u nguye‚n trong C++ co˘ nhˆıng loaÔi nhˆ sau: Data Type Ranges C/C++ recognizes the types shown in the table below. Type Nam e Bytes Other Nam es Range of Values signed, int * System dependent signed int unsigned int * unsigned System dependent char 1 ñ128 to 127 signed char short int, short 2 ñ32,768 to 32,767 signed short int ñ2,147,483,648 to signed 4 signed int 2,147,483,647 Trong ha‡u he·t ca˘c ˆ˘ng duÔng kie‡u int giÙ˘i haÔn trong khoa˚ng ñ32,768 to 32,767 va¯ unsigned int giÙ˘i haÔn trong khoa˚ng 0 to 65535. Ne·u ca‡n sˆ˚ duÔng nhˆıng gia˘ trÚ so· nguye‚n vˆÙ˘t qua˘ ca˘c giÙ˘i haÔn tre‚n ta co˘ the‡ sˆ˚ duÔng kieÂu long int So· thˆÔc: La¯ ba·t ky¯ mo‰t gia˘ trÚ so· na¯o co˘ pha‡n tha‰p pha‚n phÌa sau. VÌ duÔ: 0.0 2.5 5.0 C++ co˘ 3 loaÔi so· thˆÔc: Type Nam e Bytes Other Nam es Range of Values float 4 none 3.4E +/- 38 (7 digits) double 8 none 1.7E +/- 308 (15 digits) long double 10 none 1.2E +/- 4932 (19 digits) Trang 6
7. Ph
   ng Pháp Lp Trình Khi ghi mo‰t so· thˆÔc trong chˆÙng trÏnh ta co˘ sˆÔ pha‚n bie‰t nhˆ sau: Co˘ ky˘ hie‰y f phÌa sau la¯ gia˘ trÚ thuo‰c kieÂu float Co˘ ky˘ hie‰y l phÌa sau la¯ gia˘ trÚ thuo‰c kieÂu long double VÌ duÔ: 9.234 thuo‰c kieÂu double 9.234f thuo‰c kieÂu float 9.234l thuo‰c kieÂu long double ca/5 ca˘ch trÏnh ba¯y so· thˆÔc: DaÔng tha‰p pha‚n DaÔng so· m uı DaÔng khoa chuaÂn hoÔc 1652. 1.625e3 1.625x103 63421. 6.3421e4 6.3421x104 .00731 7.31e-3 7.31x10-3 .000625 6.25e-4 6.25x10-4 Ky˘ tˆÔ: KieÂu ky˘ tˆÔ bao go‡m 256 ky˘ tˆÔ trong Òo˘ bao go‡m ca˘c chˆı ca˘i ( chˆı thˆÙ¯ng va¯ chˆı hoa), chˆı so·, ca˘c da·u, mo‰t so· ca˘c ky˘ hie‰u. Type Nam e Bytes Other Nam es Range of Values char 1 signed char ñ128 to 127 unsigned char 1 none 0 to 255 Trong chˆÙng trÏnh Òe trÏnh ba¯y mo‰t haËng ky˘ tˆÔ ta ÒaÎt va¯o da·u nha˘y ÒÙn: ëaí , ëDí ,,, Ca˘c ky˘ tˆÔ vÙ˘i y˘ nghÛa ÒaÎc bie‰t: Sequence Nam e \a Alert (bell) \b Backspace \f Next page \n Newline \r Carriage return \t Horizontal tab \' Single quotation mark \" Double quotation mark \\ Backslash \0 Null character Trang 7
8. Ph
   ng Pháp Lp Trình II. CAŸC PHEŸP TOAŸN SO¡ HOœC: Phe˘p co‰ng + Phe˘p trˆ¯ - Phe˘p nha‚n * Phe˘p chia / Phe˘p la·y pha‡n dˆ % Mo„i phe˘p toa˘n so· hoÔc seı ke·t hÙÔp 2 toa˘n haÔng. VÙ˘i ca˘c phe˘p toa˘n so· hoÔc chu˘ng ta pha˚i naÈm ÒˆÙÔc ke·t qua˚ cu˚a mo‰t bieÂu thˆ˘c thuo‰c kieÂu dˆı lie‰u na¯o. Co˘ hai qui lua‰t giu˘p chu˘ng ta xa˘c ÒÚnh: 1. Ne·u ca˚ hai toa˘n haÔng la¯ so· nguye‚n thÏ ke·t qua˚ thuo‰c kieÂu nguye‚n 2. Ne·u co˘ mo‰t toa˘n haÔng na¯o la¯ kieÂu so· thˆÔc thÏ ke·t qua˚ thuo‰c kieÂu thˆÔc rie‚ng phe˘p % chÊ a˘p duÔng cho hai so· nguye‚n. SˆÔ ke·t hÙÔp va¯ Òo‰ ˆu tie‚n cu˚a ca˘c toa˘n tˆ˚: Trong C++ khi vie·t ca˘c bieÂu thˆ˘c phu˘c taÔp ( co˘ nhie‡u hÙn mo‰t toa˘n tˆ˚)chu˘ng ta ca‡n pha˚i tua‚n theo ca˘c qui taÈc: • Hai phe˘p toa˘n 2 ngo‚i kho‚ng bao giÙ¯ Òˆ˘ng caÔnh nhau • Pha‡n bieÂu thˆ˘c ÒˆÙÔc ÒaÎt trong ngoaÎc seı ÒˆÙÔc ˆu tie‚n tÌnh toa˘n trˆÙ˘c • Co˘ the co˘ nhie‡u caÎp da·u ngoaÎc ÒˆÙÔc sˆ˚ duÔng lo‡ng va¯o nhau, khi Òo˘ bieÂu thˆ˘c ÒaÎt Ù˚ ngoaÎc trong cu¯ng co˘ ˆu tie‚n cao nha·t • Da·u ngoaÎc kho‚ng the thay the· cho ky˘ hie‰u * trong phe˘p nha‚n, vÌ duÔ ta kho‚ng the vie·t (3+4)(5+1) ma¯ pha˚i vie·t (3+4)*(5+1) • —o‰ ˆu tie‚n cu˚a ca˘c phe˘p toa˘n nhˆ sau: Operator Associativity unary – right to left * / % left to right + - left to right III. DUÿNG cout XUA¡T CAŸC GIAŸ TR“ SO¡: Ta co˘ the du¯ng cout Òe xua·t cac1 gia˘ trÚ so· le‚n ma¯n hÏnh theo cu˘ pha˘p cout <<gia˘ trÚ; VÌ duÔ: cout << 5; cout <<10; cout << (10+2.5); // Òo·i vÙ˘i bieÂu thˆ˘c ta ne‚n ÒaÎt va¯o da·u ngoaÎc Khi in mo‰t gia˘ trÚ so· sau khi in xong muo·n xuo·ng do¯ng ta co˘ the sˆ˚ duÔng ky˘ tˆÔ endl Trang 8
9. Ph
   ng Pháp Lp Trình VÌ duÔ: #include void main() { cout vÌ duÔ: #include #include void main() { cout <<setw(5) <<12 //ke·t qua˚ ì 12î cout <<setw(10) <<setiosflags(ios::left) <<12 // 12 cout <<hex <<15 //ke·t qua˚ f cout <<oct <<10 // ke·t qua˚ 12 cout <<dec <<0x10 // ke·t qua˚ 16 (lˆu y˘ Òe trÏnh ba¯y mo‰t so· trong he‰ tha‰p luÔc pha‚n ta //ÒaÎt the‚m 0x phÌa trˆÙ˘c) cout <<dec <<012 // ke·t qua˚ 10 (lˆu y˘ Òe trÏnh ba¯y mo‰t so· trong he‰ ba˘t pha‚n ta ÒaÎt //the‚m 0 phÌa trˆÙ˘c) return; } IV. BIE¡N VAÿ KHAI BAŸO BIE¡N: Trang 9
10. Ph
    ng Pháp Lp Trình Bie·n la¯ mo‰t ca˘i te‚n ma¯ ngˆÙ¯i la‰p trÏnh du¯ng Òe tham kha˚o tÙ˘i mo‰t vu¯ng nhÙ˘ trong ma˘y tÌnh. Mo‰t bie·n co˘ the chˆ˘a mo‰t gia˘ trÚ phu¯ hÙÔp vÙ˘i kieÂu dˆı lie‰u ma¯ ta Òaı khai ba˘o cho no˘, gia˘ trÚ trong bie·n co˘ the thay ÒoÂi ÒˆÙÔc. Te‚n bie·n ÒˆÙÔc ÒaÎt theo qui ÒÚnh cu˚a danh ÒÚnh. Cu˘ pha˘p Òe khai ba˘o bie·n: variable name; VÌ duÔ: int sum; long int datenum; foat a,b,c; Ta cuıng co˘ the ga˘n gia˘ trÚ cho bie·n ngay taÔi thÙ¯i ÒieÂm khai ba˘o (phe˘p ga˘n ky˘ hie‰u bÙ˚i da·u baËng =) int a=3,b=5; VÚ trÌ khai ba˘o bie·n trong chˆÙng trÏnh: #include void main() { declaration statements; other statements; return; } VÌ duÔ: #include void main() { float dmon1,dmon2,d_tb; dmon1=9.5; dmon2=8.0; d_tb=(dmon1+dmon2)/2; cout <<îdiem tb la: ì <<d_tb; return; } Toa˘n tˆ˚ sizeof: —a‚y la¯ mo‰t toa˘n tˆ˚ ÒˆÙÔc cung ca·p bÙ˚i C++ du¯ng Òe xa˘c ÒÚnh cu˚a mo‰t loaÔi dˆı lie‰u hoaÎc mo‰t bie·n. vÌ duÔ: Trang 10
11. Ph
    ng Pháp Lp Trình cout <<îkich thˆÙ˘c kieÂu int la¯:î <<sizeof(int); V. CAŸC LO√I TH÷‘ÿNG GAÀP: 1. Que‚n khai ba˘o ca˘c bie·n sˆ˚ duÔng trong chˆÙng trÏnh 2. Lˆu mo‰t gia˘ trÚ va¯o mo‰t bie·n nhˆng kho‚ng cu¯ng kieÂu dˆı lie‰u vÙ˘i bie·n. 3. Sˆ˚ duÔng bie·n trong mo‰t bieÂu thˆ˘c khi no˘ chˆa co˘ gia˘ trÚ. Lo„i na¯y thÌ kho‚ng ÒˆÙÔc pha˘t hie‰n bÙ˚i rÏnh bie‚n dÚch, khi Òo˘ gia˘ trÚ cu˚a bie·n la¯ mo‰t gia˘ trÚ ba·t ky¯ va¯ ke·t qua˚ cu˚a bieÂu thˆ˘c la¯ vo‚ nghÛa. 4. Sˆ˚ duÔng gia˘ trÚ cu˚a phe˘p chia kho‚ng chÌnh xa˘c. Lo„i na¯y thˆÙ¯ng xua·t hie‰n trong ca˘c bieÂu thˆ˘c co˘ nhie‡u toa˘n haÔng va¯ lo„i na¯y ra·t kho˘ pha˘t hie‰n. vÌ duÔ: 3.2+ 2/3+ 1.5 thÏ ke·t qua˚ seı baËng 4.7 thay vÏ pha˚i baËng 5.3 5. Sˆ˚ duÔng mo‰t bieÂu thˆ˘c ma¯ trong Òo˘ chˆ˘a nhie‡u loaÔi dˆı lie‰u nhˆng laÔi kho‚ng bie·t chaÈc chaÈn kieÂu dˆı lie‰u cu˚a ke·t qua˚ 6. Que‚n ky˘ hie‰u << trˆÙ˘c mo„i no‰i dung muo·n xua·t bÙ˚i cout Trang 11
12. Ph
    ng Pháp Lp Trình BAÿI 3 : LEƒNH GAŸN ñ NHAƒP D÷’ LIEƒU ñ HA»NG I. LEƒNH GAŸN: C++ cung ca·p mo‰t toa˘n tˆ˚ ky˘ hie‰u bÙ˚i da·u = ÒˆÙÔc goÔi la¯ le‰nh ga˘n. Co‚ng duÔng cu˚a le‰nh na¯y la¯ du¯ng Òe ga˘n dˆı lie‰u cho mo‰t bie·n. Cu˘ pha˘p le‰nh ga˘n nhˆ sau: Te‚n bie·n= bieÂu thˆ˘c; BieÂu thˆ˘c co˘ the la¯ mo‰t haËng, mo‰t bie·n hoaÎc mo‰t bieÂu thˆ˘c Khi sˆ˚ duÔng le‰nh ga˘n trong chˆÙng trÏnh ta pha˚i lˆu y˘ hai Òie‡u: 1. BieÂu thˆ˘c be‚n tra˘i da·u = ne·u co˘ sˆ˚ duÔng bie·n thÏ ca˘c bie·n na¯y pha˚i ÒˆÙÔc ga˘n ca˘c gia˘ trÚ hÙÔp le‰ trˆÙ˘c Òo˘ 2. Be‚n tra˘i da·u = pha˚i la¯ mo‰t te‚n bie·n va¯ chÊ mo‰t ma¯ tho‚i. VÌ duÔ: #include void main() { float length, width, area; area=length*width; length=27.2; width=13.6; cout << ìdien tich la: ì <<area; } ChˆÙng trÏnh tre‚n seı cho ke·t qua˚ kho‚ng chÌnh xa˘c vÏ bie·n length va¯ width chˆa co˘ gia˘ trÚ khi du¯ng trong bieÂu thˆ˘c ga˘n. Ca‚u le‰nh sau la¯ kho‚ng hÙÔp le‰: amount+128=1000+10+5; +. Mo‰t bieÂu thˆ˘c sˆ˚ duÔng toa˘n tˆ˚ ga˘n (=) goÔi la¯ bieÂu thˆ˘c ga˘n. Cuıng nhˆ nhˆıng bieÂu thˆ˘c kha˘c ba˚n tha‚n bieÂu thˆ˘c ga˘n cuıng co˘ mo‰t gia˘ trÚ, Òo˘ chÌnh la¯ gia˘ trÚ ga˘n cho bie·n. VÌ duÔ: ne·u ta co˘ bieÂu thˆ˘c ga˘n: a=5; thÏ ba˚n tha‚n bieÂu thˆ˘c (a=5) co˘ gia˘ trÚ la¯ 5. VÏ va‰y ca‚u le‰nh sau seı in le‚n ma¯n hÏnh so· 5 coun << (a=5); Trong mo‰t bieÂu thˆ˘c ga˘n co˘ the co˘ nhie‡u toa˘n tˆ˚ ga˘n, khi Òo˘ bieÂu thˆ˘c seı ÒˆÙÔc thˆÔc hie‰n tˆ¯ pha˚i qua tra˘i: vÌ duÔ a=b=c=5; Trang 12
13. Ph
    ng Pháp Lp Trình + Ne·u bieÂu thˆ˘c be‚n pha˚i phe˘p ga˘n kha˘c vÙ˘i kieÂu dˆı lie‰u cu˚a bie·n be‚n tra˘i thÏ ke·t qua˚ bieÂu thˆ˘c seı ÒˆÙÔc chuyeÂn ÒÙ˚i kieÂu cho phu¯ hÙÔp vÙ˘i bie·n be‚n tra˘i. Tuy nhie‚n khi ke·t qua˚ cu˚a bieÂu thˆ˘c be‚n pha˚i vˆÙ˘t qua˘ phaÔm vi cu˚a bie·n be‚n tra˘i thÏ gia˘ trÚ ga˘n va¯o bie·n seı kho‚ng chÌnh xa˘c. Ca˘c daÔng bie·n ÒoÂi cu˚a le‰nh ga˘n: 1. Khi vie·t chˆÙng trÏnh chu˘ng ta thˆÙ¯ng sˆ˚ duÔng ca˘c le‰nh ga˘n co˘ daÔng nhˆ sau: tong=tong+10; tich=tich*3; a=a-3; c=c%k; trong ca˘c trˆÙ¯ng hÙÔp tre‚n ta co˘ the sˆ˚ duÔng ca˘c toa˘n tˆ˚ ga˘n += -= *= /= %= ÒˆÙÔc cung ca·p bÙ˚i C++ goÔi la¯ shortcut assignment operators VÌ duÔ: tong=tong+10; ⇔ tong +=10; tich=tich*3; ⇔ tich *=3; a=a-3; ⇔ a -=3; c=c%k; ⇔ c %=k; Ve‡ y˘ nghÛa thÏ ca˘c le‰nh ga˘n trong hai trˆÙ¯ng hÙÔp tre‚n co˘ cu¯ng muÔc ÒÌch nhˆng ca˘ch du¯ng shortcut assignment operators seı giu˘p chˆÙng trÏnh chaÔy nhanh hÙn. 2 Toa˘n tˆ˚ m o‰t ngo‚i: Trong chˆÙng rÏnh chu˘ng ta cuıng thˆÙ¯ng sˆ˚ duÔng ca˘c le‰nh taÍng hoaÎc gia˚m gia˘ trÚ cu˚a bie·n Òe·m Òi 1, vÌ duÔ nhˆ: i=i+1; hoaÎc i=i-1; Thay vÏ vie·t tre‚n ta co˘ the vie·t: i++/++i hoaÎc i / i ca˘c phe˘p toa˘n ++, nhˆ tre‚n goÔi phe˘p toa˘n mo‰t ngo‚i. vie‰c ÒaÎt phe˘p toa˘n mo‰t ngo‚i trˆÙ˘c hoaÎc sau te‚n bie·n co˘ sˆÔ kha˘c nhau khi sˆ˚ duÔng phe˘p toa¯n na¯y chung vÙ˘i ca˘c phe˘p toa˘n kha˘c: a. Ne·u phe˘p toa˘n mo‰t ngo‚i ÒaÎt trˆÙ˘c te‚n bie·n thÏ gia˘ trÚ cu˚a bie·n seı taÍng/gia˚m 1 trˆÙ˘c khi thuÔc hie‰n nhˆıng phe˘p toa˘n kha˘c b. Ne·u phe˘p toa˘n mo‰t ngo‚i ÒaÎt sau te‚n bie·n thÏ gia˘ trÚ nhˆıng phe˘p toa˘n kha˘c seı ÒˆÙÔc thˆÔc hie‰n trˆÙ˘c sau Òo˘ mÙ˘i taÍng/gia˚m gia˘ trÚ cu˚a bie·n Òi 1. VÌ duÔ: #include void main(void) { int a=10,b, c; Trang 13
14. Ph
    ng Pháp Lp Trình b=++a; c=b++; cout Cu˘ pha˘p chung cu˚a mo‰t ha¯m la¯: functionName (arguments). Danh sa˘ch ca˘c ha¯m toa˘n hoÔc thˆÙ¯ng du¯ng: Te‚n Ha¯m Co‚ng DuÔng KieÂu dˆı lie‰u cu˚a ke·t qua˚ abs(x) TÌnh trÚ tuye‰t Òo·i cu˚a x int fabs() double labs(x) long int pow(x1,x2) tÌnh x1 luıy thˆ¯a x2 double sqrt(x) tÌnh caÍn ba‰c 2 cu˚a x double sin(x) tÌnh sin x (x tÌnh baËng radian) double cos(x) tÌnh cos x (x tÌnh baËng radian) double tan(x) tÌnh tan x (x tÌnh baËng radian) double log(x) ln(x) double log10(x) logarit cÙ so· 10 cu˚a x double exp(x) ex double —o·i so· cu˚a nhˆıng ha¯m tre‚n co˘ the la¯ so· nguye‚n hoaÎc so· thˆÔc. No˘ co˘ the la¯ haËng, bie·n hoaÎc mo‰t bieÂu thˆ˘c. Trang 14
15. Ph
    ng Pháp Lp Trình F.
    duÔ: sqrt(4) sqrt(4.2+5,3) #include #include void main() { int x=5, x=2; cout void main(void) { float a=3.5f,b=3.0f; cout > variable name1 >> variable name2 ; VÌ duÔ: chˆÙng trÏnh sau khi thˆÔc hie‰n cho phe˘p nha‰p va¯o 2 so· nguye‚n sau Òo˘ in ra tÌch cu˚a hai so· nguye‚n na¯y. Trang 15
16. Ph
    ng Pháp Lp Trình #include void main(void) { int so1,so2,tich; cout > so1; cout > so2; tich=so1*so2; cout >num1 >>num2; Khi chˆÙng trÏnh thˆÔc hie‰n gia˚ sˆ˚ ta muo·n nha‰p 5 cho num1 va¯ 10 cho num2 thÏ ta pha˚i nha‰p nhˆ sau: 5:10 ↵ #include void main(void) { float so1,so3; int so2; cout > so1; cout > so2; cout > so3; cout <<so1 <<î ì <<so2 <<" " <<so3; return; } Lˆu y˘: ta ca‡n quan ta‚m Òe·n 2 ÒaÎc ÒieÂm sau cu˚a cin: • TˆÔ Òo‰ng chuyeÂn ÒoÂi dˆı lie‰u cu˚a gia˘ trÚ nha‰p va¯o cho phu¯ hÙÔp vÙ˘i kieÂu dˆı lie‰u cu˚a bie·n khi ca‡n thie·t. • Khi cin ÒˆÙÔc goÔi thˆÔc hie‰n no˘ kieÂm tra vu¯ng Òe‰m da¯nh cho dˆı lie‰u nha‰p ne·u Òaı co˘ dˆı lie‰u thÏ no˘ la·y Òu˘ng pha‡n dˆı lie‰u ma¯ no˘ ca‡n (phuÔ Trang 16
17. Ph
    ng Pháp Lp Trình thuo‰c va¯o kieÂu dˆı lie‰u cu˚a bie·n ma¯ no˘ Òang nha‰p gia˘ trÚ), ne·u nhˆ chˆa co˘ thÏ no˘ seı chÙ¯ cho Òe·n khi dˆı lie‰u Òaı nha‰p. Do hai ÒaÎc ÒieÂm tre‚n khi nha‰p dˆı lie‰u ne·u ta nha‰p kho‚ng chÌnh xa˘c seı a˚nh hˆÙ˚ng Òe·n gia˘ trÚ cu˚a nhˆıng bie·n ÒˆÙÔc nha‰p sau Òo˘. Haıy xe˘t hai chˆÙng trÏnh sau; #include void main(void) { char kt1,kt2; int so; cout > kt1; cout > so; cout > kt2; cout void main(void) { Trang 17
18. Ph
    ng Pháp Lp Trình float so1,so3; int so2; cout > so1 >>so2 >> so3; cout >radius; circum=2*3.1416*radius cout vˆ¯a ma·t thÙ¯i gian vˆ¯a de sai so˘t. —e tra˘nh tÏnh traÔng na¯y C++ cung ca·p cÙ che· ÒaÎt te‚n cho mo‰t literal data tho‚ng qua tˆ¯ kho˘a const goÔi la¯ khai ba˘o haËng cu˘ pha˘p khai ba˘o nhˆ sau: const = ; vÌ duÔ: const float PI=3.1416; Trang 18
19. Ph
    ng Pháp Lp Trình VT trÌ khai ba˘o haËng trong chˆÙng trÏnh: oid main() { ca˘c khai ba˘o haËng; ca˘c khai ba˘o bie·n; ca˘c le‰nh kha˘c; return; } Trang 19
20. Ph
    ng Pháp Lp Trình BAÿI 4 : CA¡U TRUŸC IF - SWITCH I. Ca˘c toa˘n tˆ˚ quan he‰ (relational operators): Ca˘c toa˘n tˆ˚ quan he‰ du¯ng Òe taÔo ra ca˘c Òie‡u kie‰n ma¯ dˆÔa va¯o Òo˘ mo‰t chˆÙng trÏnh co˘ the gia˚i quye·t va·n Òe‡ me‡m de˚o, linh hoaÔt. Ca˘c bieÂu thˆ˘c sˆ˚ duÔng toa˘n tˆ˚ quan he‰ goÔi la¯ bieÂu thˆ˘c quan he‰ (relation expression). Mo‰t bieÂu thˆ˘c quan he‰ ÒÙn gia˚n go‡m mo‰t toa˘n tˆ˚ quan he‰ ke·t hÙÔp vÙ˘i hai bie·n hoaÎc hai gia˘ trÚ haËng. Ca˘c toa˘n tˆ˚ na¯y co˘ the a˘p duÔng tre‚n ca˘c kieÂu dˆı lie‰u: so· nguye‚n, so· thˆÔc, ky˘ tˆÔ. Trong C++ ta co˘ ca˘c toa˘n tˆ˚ quan he‰ sau: Toa˘n tˆ˚ Co‚ng duÔng VÌ duÔ So sa˘nh lÙ˘n hÙn chieucao >1.7 = So sa˘nh nho˚ hÙn hoaÎc soluong>=100 baËng == So sa˘nh baËng loai==íaí != So sa˘nh kha˘c loai!=íbí Mo‰t bieÂu thˆ˘c quan he‰ (Òie‡u kie‰n) seı co˘ mo‰t trong hai ke·t qua˚ Òu˘ng hoaÎc sai. Ne·u Òu˘ng thÏ bieÂu thˆ˘c co˘ gia˘ trÚ 1, ngˆÙÔc laÔi co˘ gia˘ trÚ 0. VÌ duÔ: cout 2) ; (bieÂu thˆ˘c pha˚i ÒaÎt trong ngoaÎc) #include void main(void) { char ch1,ch2; ch1='a'; ch2='b'; cout ch2) ; return; } mo‰t bieÂu thˆ˘c qua he‰ chÊ sˆ˚ duÔng mo‰t phe˘p toa˘n quan he‰ goÔi la¯ bieÂu thˆ˘c quan he‰ ÒÙn gia˚n. Toa˘n tˆ˚ logic: Trang 20
21. Ph
    ng Pháp Lp Trình Khi ca‡n taÔo ra ca˘c Òie‡u kie‰n phˆ˘c taÔp chu˘ng ta seı sˆ˚ duÔng ke·t hÙÔp giˆıa ca˘c toa˘n tˆ˚ quan he‰ va¯ ca˘c toa˘n tˆ˚ logic, Òo˘ la¯ ca˘c toa˘n tˆ˚ AND (&&) OR (||) va˘ NOT (!). Khi toa˘n tˆ˚ && ke·t hÙÔp vÙ˘i hai bieÂu thˆ˘c quan he‰ ÒÙn gia˚n seı taÔo tha¯nh mo‰t bieÂu thˆ˘c quan he‰ mÙ˘i (bieÂu thˆ˘c ghe˘p) . BieÂu thˆ˘c na¯y co˘ gia˘ trÚ true (1) khi ca˚ hai bieÂu thˆ˘c quan he‰ ÒÙn gia˚n Òe‡u co˘ gia˘ trÚ true. VÌ duÔ: Ta co˘ bieÂu thˆ˘c sau: (tuoi 1.50) //lˆu y˘ ca˘c bieÂu thˆ˘c quan he‰ ÒÙn gia˚n pha˚i naËm trong da·u () bie·u thˆ˘c tre‚n co˘ gia˘ trÚ baËng 1 khi gia˘ trÚ cu˚a bie·n tuoi >30 va¯ gia˘ trÚ cu˚a bie·n cao pha˚i >1.5. Toa˘n tˆ˚ || cuıng du¯ng Òe ke·t hÙÔp hai bieÂu thˆ˘c quan he‰ ÒÙn gia˚n Òe taÔo tha¯nh mo‰t bieÂu thˆ˘c ghe˘p, va¯ ke·t qua˚ bieÂu thˆ˘c ghe˘p chÊ gia˘ trÚ false (0) khi ca˚ hai bieÂu thˆ˘c quan he‰ ÒÙn gia˚n Òe‡u co˘ gia˘ trÚ false (0). VÌ duÔ: co˘ ÒoaÔn chˆÙng trÏnh nhˆ sau; int i,j; float a,b,c; a=12.0f; b=2.0f; i=15; j=30; c=0.0f cout b) 5) && (i b); cout << !(a); —o‰ ˆu tie‚n cu˚a ca˘c phe˘p toa˘n: Trang 21
22. Ph
    ng Pháp Lp Trình Toa˘n tˆ˚ Òo‰ ˆu tie‚n () 1 ! ++ - sizeof() 2 * / % 3 + - 4 > 5 >= 6 = = != 7 & 8 ^ 9 | 10 && 11 || 12 ?: 13 = += -= *= /= 14 —o‰ chÌnh xa˘c cu˚a m o‰t bieÂu thˆ˘c: Xe˘t chˆÙng trÏnh sau: #include #include void main(void) { const float EPSILON=0.001f; //const bb=6; //float so1,so3; float c1; double c2; fabs c1=0.01f; c2=0.01; cout << (c1==c2)<<endl; //in le‚n ma¯n hÏnh 0 cout << (fabs(c1-c2)<EPSILON); // in le‚n ma¯n hÏnh 1 return; } ‘¤ go˘c Òo‰ ngˆÙ¯i sˆ˚ duÔng ke·t qua˚ cu˚a bieÂu thˆ˘c (c1==c2) la¯ kho‚ng chÌnh xa˘c. Nguye‚n nha‚n la¯ do hÏnh thˆ˘c lˆu trˆı cu˚a c1 va¯ c2 kha˘c nhau. VÏ va‰y khi ca‡n xa˘c ÒÚnh sˆÔ baËng nhau cu˚a hai so· thˆÔc ngˆÙ¯i ta thˆÙng du¯ng ca˘ch thˆ˘ hai (fabs(c1- c2)<EPSILON). ha¯m fabs gio·ng nhˆ ha¯m abs nhˆng ke·t qua˚ thuo‰c kieÂu float. Trang 22
23. Ph
    ng Pháp Lp Trình II. Ca·u tru˘c if ñ else : Ca·u tru˘c if ñ else chÊ ÒaÔo cho ma˘y tÌnh choÔn thˆÔc hie‰n mo‰t trong hai daıy le‰nh dˆÔa va¯o ke·t qua˚ cu˚a mo‰t Òie‡u kie‰n (bieÂu thˆ˘c quan he‰ hay bieÂu thˆ˘c so sa˘nh) Cu˘ pha˘p: if (Òie‡u kie‰n) le‰nh 1; else le‰nh 2; ne·u Òie‡u kie‰n co˘ ke·t qua˚ #include void main() { float thunhap, thue; cout >thunhap; if (thunhap<=2000000) thue=thunhap*0.01f; else thue=thunhap*0.02f; cout <<îSo tien thue phai dong la: ì << setprecision(0)<<thue; return; } Le‰nh ghe˘p: VÏ cu˘ pha˘p cu˚a if ñelse chÊ cho phe˘p co˘ mo‰t le‰nh Ù˚ mo„i pha‡n cu˚a if ñ else. Nhˆng trong thˆÔc te· Òe thˆÔc hie‰n mo‰t co‚ng vie‰c na¯o Òo˘ co˘ the ca‡n pha˚i co˘ nhie‡u le‰nh, khi Òo˘ Òe C++ cha·p nha‰n co˘ nhie‡u le‰nh ta pha˚i ÒaÎt nhˆıng le‰nh na¯y va¯o caÎp da·u ngoaÎc {}, khi Òo˘ toa¯n bo‰ kho·i le‰nh na¯y ÒˆÙÔc xem nhˆ mo‰t le‰nh ghe˘p (compound statements) if (Òie‡u kie‰n) { le‰nh 1; Trang 23
24. Ph
    ng Pháp Lp Trình le‰nh 2; le‰nh 3; } else { le‰nh 4; le‰nh 5; le‰nh n; } Ca·u tru˘c if kho‚ng else: —a‚y la¯ daÔng bie·n ÒoÂi cu˚a ca·u tru˘c tre‚n, Ù˚ daÔng na¯y kho‚ng co˘ pha‡n else. Cu˘ pha˘p: if (Òie‡u kie‰n) le‰nh; theo cu˘ pha˘p na¯y thÏ khi Òie‡u kie‰n co˘ gia˘ trÚ kha˘c 0 thÏ le‰nh seı ÒˆÙÔc thˆÔc hie‰n. Cuıng nhˆ tre‚n le‰nh cuıng co˘ the la¯ mo‰t le‰nh ghe˘p. VÌ duÔ: ChˆÙng trÏnh sau cho phe˘p nha‰p mo‰t so· nguye‚n, sau Òo˘ cho bie·t so· vˆ¯a nha‰p co˘ pha˚i la¯ so· cha˙n hay kho‚ng. #include void main() { int num; cout >num; if !(num%2) cout =5000000 375000+16% doanh thu 4000000=<doanh thu<5000000 350000+14% doanh thu 3000000=<doanh thu<4000000 325000+12% doanh thu 2000000=<doanh thu<3000000 300000+9% doanh thu Trang 24
25. Ph
    ng Pháp Lp Trình 1000000= #include void main() { float doanhthu,thunhap; cout > doanhthu; if (doanhthu>=5000000) thunhap=375000+doanhthu*0.16; else if (doanhthu>=4000000) thunhap=350000+doanhthu*0.14f; else if (doanhthu>=3000000) thunhap=325000+doanhthu*0.12f; else if (doanhthu>=2000000) thunhap=300000+doanhthu*0.09f; else if (doanhthu>=1000000) thunhap=250000+doanhthu*0.05f; else thunhap=200000+doanhthu*0.03f; cout <<setiosflags(ios::fixed)<<setprecision(0)<<thunhap; return; } Trang 25
26. Ph
    ng Pháp Lp Trình III. Ca·u tru˘c switch: VÙ˘i ca˘c ba¯i toa˘n pha˚i choÔn mo‰t trong nhie‡u trˆÙ¯ng hÙÔp ne·u vie·t theo ca·u tru˘c if ñ else ta nha‰n tha·y chˆÙng trÏnh kho˘ ÒoÔc va¯ theo doıi maÔch chˆÙng trÏnh, trong trˆÙ¯ng hÙÔp na¯y ta ne‚n sˆ˚ duÔng ca·u tru˘c switch cu˘ pha˘p: switch (bieÂu thˆ˘c) { case gia˘_trÚ_1: le‰nh1; le‰nh2; break; case gia˘_trÚ _2: le‰nhn; le‰nhm; Nhaõn break; case gia˘_trÚ_n: le‰nhx; le‰nhy; break; default: le‰nh_aa; le‰nh_bb; ÖÖ } Trong ca·u tru˘c switch co˘ 4 tˆ¯ kho˘a: switch, case, break, default HoaÔt Òo‰ng cu˚a switch: Ne·u ke·t qua˚ cu˚a bieÂu thˆ˘c sau switch baËng vÙ˘i gia˘ trÚ sau case na¯o thÏ thˆÔc hie‰n ca˘c le‰nh thuo‰c ve‡ case Òo˘ (baÈt Òa‡u tˆ¯ do¯ng le‰nh ngay dˆÙ˘i case cho Òe·n khi gaÎp Trang 26
27. Ph
    ng Pháp Lp Trình le‰nh break),ne·u nhˆ gia˘ trÚ cu˚a bieÂu thˆ˘c kho‚ng baËng mo‰t gia˘ trÚ na¯o trong ca˘c gia˘ trÚ co˘ trong ca·u tru˘c switch thÏ ca˘c le‰nh thuo‰c default seı ÒˆÙÔc thˆÔc hie‰n. : - BieÂu thˆ˘c sau switch co˘ the la¯ bie·n hoaÎc bieÂu thˆ˘c. - Le‰nh break co˘ co‚ng duÔng thoa˘t kho˚i ca·u tru˘c thoa˘t kho˚i mo‰t ca·u tru˘c taÔi thÙ¯i ÒieÂm no˘ ÒˆÙÔc goÔi. Trong trˆÙ¯ng hÙÔp na¯y no˘ ÒˆÙÔc du¯ng Òe tho˘at kho˚i switch sau khi Òaı thˆÔc hie‰n mo‰t nho˘m le‰nh thuo‰c ve‡ mo‰t nhaın na¯o Òo˘. Ne·u kho‚ng co˘ le‰nh na¯y thÌ sau khi thˆÔc hie‰n xong ca˘c le‰nh ca‡n thie·t no˘ seı thˆÔc hie‰n tie·p ca˘c le‰nh cu˚a ca˘c trˆÙ¯ng hÙÔp be‚n dˆÙ˘i. VÌ duÔ: ChˆÙng trÏnh nha‰p va¯o mo‰t so· nguye‚n (1 void main() { unsigned short int num; cout > num; switch (num) { case 1: cout <<"Mot"; break; case 2: cout <<"Hai"; break; case 3: cout <<"Ba"; break; case 4: cout <<"Bon"; break; case 5: cout <<"Nam"; break; case 6: cout <<"Sau"; break; case 7: cout <<"Bay"; break; Trang 27
28. Ph
    ng Pháp Lp Trình case 8: cout void main() { char ch; cout > ch; switch (ch) { case 'a': case 'e': case 'i': case 'o': case 'u': cout <<"\n Ky tu vua nhap la mot nguyen am\n"; break; default : cout <<"\nKy tu vua nhap khong phai la mot nguyen am\n"; } return; } IV. Ca˘c lo„i thˆÙ¯ng gaÎp: Trang 28
29. Ph
    ng Pháp Lp Trình 1. Du¯ng toa˘n tˆ˚ ga˘n trong bieÂu thˆ˘c quan he‰ 2. khi co˘ nhie‡u le‰nh thuo‰c ve‡ if hoaÎc else kho‚ng ÒaÎt giˆıa { } 3. Trong ca·u tru˘c switch thie·u break Ù˚ nhˆıng vÚ trÌ ca‡n thie·t. BAÿI 5 : CAŸC CA¡U TRUŸC LAÀP Sˆ˘c maÔnh tha‰t sˆÔ cu˚a ma˘y tÌnh la¯ kha˚ naÍng laÎpÔ laÔi ca˘c phe˘p tÌnh gio·ng nhau, hoaÎc mo‰t daıy ca˘c ca‚u le‰nh. Trong ba¯i na¯y chu˘ng ta seı tÏm hieÂu ca˘c ca·u tru˘c laÎp trong C++. I. Ca·u tru˘c while: Cu˘ pha˘p cu˚a while nhˆ sau: while (Òie‡u kie‰n) le‰nh; BieÂu thˆ˘c Òie‡u kie‰n pha˚i ÒˆÙÔc ÒaÎt trong caÎp da·u ngoaÎc. Le‰nh be‚n dˆÙ˘i bieÂu thˆ˘c seı ÒˆÙÔc thˆÔc hie‰n laÎp Òi laÎp laÔi khi ma¯ bieÂu thˆ˘c va„n co˘ gia˘ trÚ kha˘c kho‚ng, nhˆ va‰y ta·t nhie‚n Ù˚ Òa‚u Òo˘ trong ÒoaÔn le‰nh cu˚a while pha˚i co˘ mo‰t le‰nh la¯m thay ÒoÂi gia˘ trÚ cu˚a bieÂu thˆ˘c Òie‡u kie‰n. Ca‚u le‰nh be‚n dˆÙ˘i Òie‡u kie‰n pha˚i la¯ mo‰t le‰nh duy nha·t hoaÎc la¯ mo‰t le‰nh ghe˘p (nhie‡u le‰nh ÒaÎt va¯o trong {}) HoaÔt Òo‰ng cu˚a while nhˆ sau: 1. kieÂm tra gia˘ trÚ cu˚a bieÂu thˆ˘c Òie‡u kie‰n (BT—K) 2. Ne·u BT—K co˘ gia˘ trÚ kha˘c kho‚ng a. ThˆÔc hie‰n le‰nh be‚n dˆÙ˘i b. Quay laÔi bˆÙ˘c 1 NgˆÙÔc laÔi: ke·t thu˘c ca·u tru˘c while HÏnh minh hoÔa tie·n trÏnh hoaÔt Òo‰ng cu˚a while —ieÂm va¯o vo¯ng laÎp while Gia˘ trÚ cu˚a Kieåm Tra giaù BT—K baËng 0 trò cuûa BTDK Ke·t thu˘c vo¯ng laÎp Gia˘ trÚ cu˚a BT—K kha˘c 0 ThˆÔc hie‰n le‰nh cu˚a while Trang 29
30. Ph
    ng Pháp Lp Trình VÌ du 1Ô: #include #include void main() { int count; count=1; //KhÙ˚i taÔo gia˘ trÚ cho bie·n count while (count ke·t thu˘c //vo¯ng laÎp } return; } ChˆÙng trÏnh tre‚n khi thˆÔc hie‰n seı in ra ke·t qua˚ : 1 2 3 4 5 6 7 8 9 10 Vo¯ng while tre‚n co˘ the vie·t laÔi nhˆ sau while (count #include #include void main() { int i; Trang 30
31. Ph
    ng Pháp Lp Trình clrscr(); cout #include #include void main() { const int MAX_C=50; const int START=5; const int STEP=5; int do_c; float do_fa; clrscr(); cout <<" Do c Do Fa\n" <<" \n"; do_c=START; cout<<setiosflags(ios::showpoint)<<setprecision(2); while (do_c <=MAX_C) { do_fa=(9.0/5.0)*do_c+32; cout <<setw(4) <<do_c <<setw(12) <<do_fa<<endl; Trang 31
32. Ph
    ng Pháp Lp Trình do_c +=STEP; } getch(); return; } Le‰nh break va¯ continue: break: Thoa˘t kho˚i ca˘c ca·u tru˘c switch, while, for, do-while taÔi thÙ¯i ÒieÂm break ÒˆÙÔc goÔi thi ha¯nh ma¯ kho‚ng ca‡n kieÂm tra ke·t qua˚ cu˚a BT—K. Cu˘ pha˘p : break; VÌ duÔ 4: Vie·t chˆÙng trÏnh tÌnh toÂng ca˘c so· nguye‚n ÒˆÙÔc nha‰p tˆ¯ ba¯n phÌm chˆÙng trÏnh ke·t thu˘c khi co˘ m o‰t so· a‚m ÒˆÙÔc nha‰p. #include #include void main() { int so,tong=0; clrscr(); while (1) { cout >so; if (so =0) { cout >so; if (so>=0) tong +=so; } Trang 32
33. Ph
    ng Pháp Lp Trình continue: la¯ le‰nh ÒˆÙÔc sˆ˚ duÔng trong ca˘c vo¯ng laÎp nhˆ while, for ,do-while. Khi le‰nh continue ÒˆÙÔc goÔi thÏ chˆÙng trÏnh seı quay trÙ˚ ve‡ Òa‡u vo¯ng laÎp Òe baÈt Òa‡u la‡n laÎp mÙ˘i. VÌ du 5Ô: Vie·t chˆÙng trÏnh tÌnh toÂng ca˘c so· nguye‚n dˆÙng ÒˆÙÔc nha‰p tˆ¯ ba¯n phÌm chˆÙng trÏnh ke·t thu˘c khi co˘ m o‰t so· =0 ÒˆÙÔc nha‰p. #include #include void main() { int so,tong=0; clrscr(); while (1) { cout =0: "; cin >>so; if (so=0) break; if (so<0) { cout <<îDu lieu khong hop leî; continue; } tong +=so; } cout <<"\nTong cac gia tri da nhap la: "<<tong; getch(); return; } II. Ca·u tru˘c for : Ca·u tru˘c for cuıng co˘ chˆ˘c naÍng gio·ng nhˆ while la¯ laÎp Òi laÎp laÔi mo‰t ÒoaÔn le‰nh na¯o Òo˘ nhˆng theo mo‰t ma„u kha˘c. Trong ca˘c trˆÙ¯ng hÙÔp so· la‡n laÎp cu˚a vo¯ng laÎp la¯ co· ÒÚnh thÏ vie‰c sˆ˚ duÔng for seı thua‰n lÙÔi va¯ de da¯ng hÙn. VÌ duÔ chˆÙng trÏnh in n so· nguye‚n dˆÙng Òa‡u tie‚n le‚n ma¯n hÏnh (vÙ˘i n la¯ mo‰t so· nguye‚n) thÏ du¯ng for phu¯ hÙÔp hÙn. Cu˘ pha˘p: for (ca˘c le‰nh khÙ˚i taÔo ; bieÂu thˆ˘c Òie‡u kie‰n ; ca˘c le‰nh ta˘c Òo‰ng Òe·n Òie‡u kie‰n) le‰nh; sau tˆ¯ kho˘a for ta tha·y co˘ 3 nho˘m le‰nh trong ngoaÎc. le‰nh cu˚a for pha˚i la¯ mo‰t le‰nh duy nha·t hoaÎc la¯ mo‰t le‰nh ghe˘p. Trang 33
34. Ph
    ng Pháp Lp Trình HoaÔt Òo‰ng cu˚a for: —ieÂm va¯o vo¯ng laÎp FOR ThˆÔc hie‰n ca˘c le‰nh khÙ˚i taÔo Gia˘ trÚ cu˚a Kieåm Tra giaù BT—K baËng 0 trò cuûa BTDK Ke·t thu˘c vo¯ng laÎp for Gia˘ trÚ cu˚a BT—K kha˘c 0 ThˆÔc hie‰n le‰nh cu˚a for ThˆÔc nho˘m le‰nh ta˘c Òo‰ng BT—K VÌ duÔ 6:ChˆÙng trÏnh in le‚n m a¯n hÏnh 10 so· nguye‚n dˆÙng Òa‡u tie‚n: #include #include void main() { int count; for (count =1;count<=10;count++) cout <<setw(3)<<count; return; } Theo chˆÙng trÏnh tre‚n ta nha‰n tha·y: - count=1 thuo‰c ve‡ nho˘m ca˘c le‰nh khÙ˚i taÔo. Trang 34
35. Ph
    ng Pháp Lp Trình - BieÂu thˆ˘c (count #include void main() { int count=2; for (;count #include void main() { int count=2; for (;;) { cout 20) break; } return; } HoaÎc: #include #include void main() { int count; for (count =2;count<=20; cout <<setw(3)<<count,count++); return; } Qua ca˘c vÌ duÔ ta tha·y mo„i nho˘m le‰nh trong ngoaÎc cu˚a for Òe‡u co˘ the vaÈng maÎt, nhˆng chaÈc chaÈn raËng no˘ pha˚i naËm Òa‚u Òo˘ trong chˆÙng trÏnh. VÏ va‰y ca˘c trˆÙ¯ng hÙÔp vo¯ng for vaÈng maÎt ca˘c tha¯nh pha‡n ÒˆÙÔc sˆ˚ duÔng khi no˘ tha‰t sˆÔ ca‡n thie·t. Trang 35
36. Ph
    ng Pháp Lp Trình III. Ca·u tru˘c do-while: Ca˚ hai vo¯ng laÎp while va¯ for Òie‡u kieÂm tra BT—K trˆÙ˘c khi baÈt Òa‡u thˆÔc hie‰n le‰nh cu˚a vo¯ng laÎp nhˆ the· co˘ kha˚ naÍng le‰nh cu˚a vo¯ng laÎp kho‚ng ÒˆÙÔc thˆÔc hie‰n la‡n na¯o vÏ ngay la‡n kieÂm tra Òa‡u tie‚n ke·t qua˚ cu˚a BT—K Òaı baËng 0. Trong mo‰t va¯i trˆÙ¯ng hÙÔp khi sˆ˚ duÔng vo¯ng laÎp ta ca‡n no˘ thˆÔc hie‰n Ìt nha·t la¯ mo‰t la‡n, vÌ duÔ nhˆ ta muo·n mo‰t chˆÙng trÏnh co˘ the thˆÔc hie‰n nhie‡u la‡n theo y˘ muo·n cu˚a ngˆÙ¯i sˆ˚ duÔng. VÌ duÔ 8: #include #include void main() { char tiep; int so; tiep=ící; while (tiep==ící || tiep==íCí) { cout >so; if (so%2==0) cout >tiep; } return; } ChˆÙng trÏnh tre‚n do du¯ng vo¯ng laÎp while ta pha˚i co˘ le‰nh tiep=ící trˆÙ˘c vo¯ng laÎp Òe ba˚o Òa˚m vo¯ng laÎp seı thˆÔc hie‡n ÒˆÙÔc mo‰t la‡n. Muo·n bo˚ le‰nh na¯y thÏ vie‰c kieÂm tra BT—K pha˚i ÒˆÙÔc thˆÔc hie‰n Ù˚ cuo·i vo¯ng laÎp va¯ vo¯ng laÎp do ñ while la¯ vo¯ng laÎp co˘ ÒaÎc tÌnh tre‚n. Cu˘ pha˘p cu˚a do ñwhile nhˆ sau: do{ le‰nh; }while (bieÂu thˆ˘c Òie‡u kie‰n); Le‰nh cu˚a do-while pha˚i la¯ mo‰t le‰nh hoaÎc la¯ le‰nh ghe˘p. Trang 36
37. Ph
    ng Pháp Lp Trình HoaÔt Òo‰ng cu˚a do ñ while: —ieÂm va¯o vo¯ng laÎp do - while ThˆÔc hie‰n le‰nh cu˚a do-while Gia˘ trÚ cu˚a BT—K baËng 0 Kieåm Tra Ke·t thu˘c giaù trò cuûa vo¯ng laÎp BTDK do-while Gia˘ trÚ cu˚a BT—K kha˘c 0 VÌ duÔ 9: void main() { char tiep; int so; do { cout >so; if (so%2==0) cout >tiep; } while (tiep=='c' || tiep=='C'); return; } Trang 37
38. Ph
    ng Pháp Lp Trình IV. Ca˘c ca·u tru˘c lo‡ng nhau: Toa¯n bo‰ mo‰t ca·u tru˘c while, for, do-while ÒˆÙÔc xen nhˆ mo‰t ca‚u le‰nh vÏ va‰y ta co˘ the lo‡ng ghe˘p ca˘c ca·u tru˘c na¯y va¯o nhau VÌ duÔ 10: Vie·t chˆÙng trÏnh in ca˘c ba˚ng cˆ˚u chˆÙng 2,3,4 le‚n m a¯n hÏnh Ca˘ch 1: #include #include void main() { int i,j; for (i=1;i #include void main() { int i=1,j; while (i<=10) { for (j=2;j<=4;j++) cout <<setw(3)<<j<<" * " <<setw(2)<<i <<"="<< setw(4)<<i*j; cout <<endl; i++; } return; } V. Ca˘c lo„i thˆÙ¯ng gaÎp: 1. Lˆu y˘ Òe·n pha‡n khÙ˚i taÔo gia˘ trÚ va¯ pha‡n bieÂu thˆ˘c Òe‡u kie‰n tra˘nh tÏnh traÔng vo¯ng laÎp co˘ the thˆÔc hie‰n thie·u hoaÎc dˆ mo‰t la‡n. VÌ duÔ nhˆ for (i=1; i<11 ; i++) seı thˆÔc hie‰n 10 la‡n for (i=1; i<=10 ; i++) cuıng thˆÔc hie‰n 10 la‡n for (i=0; i<11 ; i++) thˆÔc hie‰n 11 la‡n Trang 38
39. Ph
    ng Pháp Lp Trình 2. Sˆ0 duÔng toa˘n tˆ˚ ga˘n (=) thay vÏ toa˘n tˆ˚ quan he‰ baËng (==) trong ca˘c bieÂu thˆ˘c Òie‡u kie‰n, hay ngˆÙÔc laÔi vÙ˘i bieÂu thˆ˘c khÙ˚i taÔo trong for. 3. —aÎt da·u ; ngay sau bieÂu thˆ˘c Òie‡u kie‰n cu˚a while (ga‚y treo ma˘y) hoaÎc ngay sau daÈu ngoaÎc ì ) ìcu˚a vo¯ng for co˘ le‰nh be‚n dˆÙ˘i vÌ duÔ: total=0; for (i=1;i<=10;i++); total +=num; 4. Sˆ˚ duÔng da·u phaÂy ngaÍn ca˘ch giˆıa 3 nho˘m le‰nh trong ngoaÎc cu˚a for thay vÏ cha·m phaÂy. 5. Que‚n da·u cha·m phaÂy sau while (BT—K) cu˚a do - while Trang 39
40. Ph
    ng Pháp Lp Trình BAÿI 6 : CH÷‘NG TRÃNH CON Mo‰t chˆÙng trÏnh mang tÌnh chuye‚n nghie‰p (ÒˆÙÔc vie·t Òe sˆ˚ duÔng trong thˆÔc te·) thÏ ÒˆÙÔc thie·t ke·, vie·t chˆÙng trÏnh va¯ kieÂm tra ra·t kyı. Va·n Òe‡ ÒaÎt ra la¯ la¯m the· na¯o Òe vie‰c vie·t chˆÙng trÏnh, kieÂm tra chˆÙng rÏnh ÒˆÙÔc thua‰n lÙÔi ÒaÔt hie‰u qua˚ cao, cuıng nhˆ vie‰c pha˘t trieÂn chˆÙng trÏnh khi ca‡n thie·t seı de„ da¯ng. —ie‡u na¯y phuÔ thuo‰c Ù˚ kha‚u thie·t ke· to chˆ˘c chˆÙng trÏnh. Mo‰t chˆÙng trÏnh tho‚ng thˆÙ¯ng seı co˘ nhie‡u chˆ˘c naÍng ta ne‚n thie·t ke· mo„i chˆ˘c naÍng nhˆ va‰y la¯ mo‰t ha¯m. Trong mo„i ha¯m na¯y co˘ the seı ÒˆÙÔc chia nho˚ tha¯nh nhie‡u ha¯m nˆıa Khi ca˘c ha¯m chˆ˘c naÍng Òaı ÒˆÙÔc xa‚y dˆÔng hoa¯n chÊnh ta·t ca˚ nhˆıng ha¯m na¯y seı ÒˆÙÔc ke·t no·i bÙ˚i ha¯m main, taÔi thÙ¯i ÒieÂm na¯y chu˘ng ta seı kho‚ng quan ta‚m Òe·n chi tie·t cu˚a ca˘c ha¯m chˆ˘c naÍng nˆıa ma¯ chÊ ca‡n bie·t Òa‡u ra cu˚a nhˆıng ha¯m na¯y. —e taÔo mo‰t ha¯m trong C++chu˘ng ta pha˚i quan ta‚m hai Òie‡u: no‰i dung cu˚a ha¯m va¯ sˆÔ tˆÙng ta˘c cu˚a no˘ vÙ˘i nhˆıng ha¯m kha˘c, bao go‡m vie‰c truye‡n dˆı lie‰u chÌnh xa˘c va¯o trong ha¯m khi goÔi ha¯m thˆÔc hie‰n va¯ gia˘ trÚ ma¯ ha¯m seı tra˚ ve‡ khi thˆÔc hie‰n xong. I .Khai ba˘o ha¯m va¯ tham so·: 1. Khai ba˘o nguye‚n ma„u ha¯m (prototype): Nguye‚n ma„u cu˚a ha¯m du¯ng Òe mo‚ ta˚ kieÂu dˆı lie‰u tra˚ ve‡ cu˚a ha¯m, te‚n ha¯m, so· tham so· , tra‰t tˆÔ cu˚a ca˘c tham so· va¯ kieÂu dˆı lie‰u cu˚a nhˆıng tham so· ma¯ no˘ seı nha‰n khi ÒˆÙÔc goÔi thˆÔc hie‰n. NgoaÔi trˆ¯ ha¯m main ta·t ca˚ ca˘c ha¯m kha˘c(kho‚ng pha˚i ha¯m cu˚a C++) co˘ trong chˆÙng trÏnh Òie‡u pha˚i khai ba˘o nguye‚n ma„u. —ie‡u na¯y giu˘p cho trÏnh bie‚n dÚch pha˘t hie‰n ra ca˘c lo„i sai so˘t ve‡ kieÂu dˆı lie‰u tra˚ ve‡ cu˚a ha¯m cuıng nhˆ so· gia˘ trÚ va¯ kieÂu dˆı lie‰u cuıa ca˘c gia˘ trÚ truye‡n cho ha¯m khi no˘ ÒˆÙÔc goÔi thˆÔc hie‰n. Cu˘ pha˘p khai ba˘o mo‰t nguye‚n ma„u: Data_type function_name (list of parameter data type); Lˆu y˘: Khi mo‰t ha¯m co˘ nhie‡u tham so· thÏ danh sa˘ch kieÂu dˆı lie‰u ca˘c ca˘c tham so· pha˚i co˘ da·u phaÂy giˆıa hai kieÂu. VÌ duÔ: int fmax(int, int);// co˘ da·u cha·m phaÂy float swap(int, char, char, double); // void display(double, double); Trang 40
41. Ph
    ng Pháp Lp Trình Ca˘c prototype thˆÙ¯ng ÒˆÙÔc khai ba˘o Ù˚ Òa‡u chˆÙng trÏnh sau ca˘c do¯ng #include 2. —Únh nghÛa ha¯m: —Únh nghÛa mo‰t ha¯m co˘ nghÛa vie·t no‰i dung cu˚a ha¯m Òo˘. Mo„i ha¯m seı ÒˆÙÔc ÒÚnh nghÛa mo‰t la‡n trong chˆÙng trÏnh va¯ co˘ the ҈ÙÔc goÔi thˆÔc hie‰n bÙ˚i mo‰t ha¯m kha˘c co˘ trong chˆÙng trÏnh. No‰i dung cu˚a ha¯m ÒˆÙÔc ÒÚnh nghÛa tho‰ng thˆÙ¯ng ÒaÎt sau ha¯m main va¯ ca˘c ha¯m naËm rÙ¯i nhau (kho‚ng co˘ trˆÙ¯ng hÙÔp mo‰t ha¯m naËm trong ha¯m kha˘c). Gio·ng nhˆ ha¯m main mo„i ha¯m trong C++ go‡m hai pha‡n: pha‡n tie‡u Òe‡ cu˚a ha¯m (function header) va¯ pha‡n tha‚n ha¯m (function body). function header line Function header { statements; } Function body } + Tie‚u Òe‡ cu˚a ha¯m co˘ cu˘ pha˘p nhˆ sau: Data_type function_name ( parameter list) kho‚ng co˘ da·u ; VÌ duÔ :Ca˘c khai ba˘o nguye‚n ma„u ha¯m va¯ tie‚u Òe‡ ha¯m tˆÙng ˆ˘ng; int fmax( int , int); int fmax(int x, int y) te‚n tham so· hÏnh thˆ˘c void display(double, double); void display(double m, double n) te‚n tham so· hÏnh thˆ˘c void mess(void); hoaÎc void mess(); void mess(void) Nha‰n xe˘t: Tie‚u Òe‡ cu˚a mo‰t ha¯m thÏ ga‡n tˆÙng tˆÔ nhˆ nguye‚n ma„u chÊ kha˘c la¯ Ù˚ cuo·i do¯ng kho‚ng co˘ da·u ; va¯ danh sa˘ch ca˘c tham so· trong tie‚u Òe‡ pha˚i co˘ te‚n tham so·. Trang 41
42. Ph
    ng Pháp Lp Trình Te‚n ca˘c tham so· hÏnh thˆ˘c do ngˆÙ¯i la‰p trÏnh ÒaÎt, va¯ no˘ du¯ng Òe nha‰n ca˘c gia˘ trÚ truye‡n tˆ¯ be‚n ngoa¯i va¯o khi ha¯m thˆÔc hie‰n. + Tha‚n ha¯m: Bao go‡m ca˘c le‰nh ca˘c phe˘p toa˘n seı ta˘c Òo‰ng le‚n ca˘c gia˘ trÚ ÒˆÙÔc truye‚n cho ha¯m tho‚ng qua ca˘c tham so· hÏnh thˆ˘c, Òe taÔo ra ke·t qua˚. VÌ duÔ 1: Xem xe˘t chˆÙng trÏnh sau, chˆÙng trÏnh in le‚n m a¯n hÏnh gia˘ trÚ lÙ˘n nha·t cu˚a hai so· nguye‚n ÒˆÙÔc nha‰p tˆ¯ ba¯n phÌm , trong chˆÙng trÏnh co˘ m o‰t ha¯m findm ax du¯ng Òe tÏm gia˘ trÚ lÙ˘n nha·t trong hai so·: #include int findmax(int, int); //prototype void main() { int num1, num2; cout >num1; cout > num2; cout =y) return x; Function body else return} y; } 3. LÙ¯i goÔi ha¯m: LÙ¯i goÔi ha¯m gio·ng nhˆ mo‰t le‰nh, no˘ xua·t hie‰n trong chˆÙng trÏnh khi co˘ ye‚u ca‡u goÔi thˆÔc hie‰n ma‰t ha¯m na¯o Òo˘ thˆÔc hie‰n. LÙ¯i goÔi ha¯m bao go‡m te‚n ha¯m ca˘c dˆı lie‰u truye‡n cho ha¯m ÒˆÙÔc goÔi (ne·u nguye‚n ma„u cu˚a ha¯m co˘ tham so· thÏ khi goÔi ha¯m pha˚i truye‡n gia˘ trÚ) trong vÌ duÔ tre‚n do¯ng le‰nh findm ax(num 1,num 2) trong ha¯m main la¯ mo‰t lÙ¯i goÔi ha¯m. Dˆı lie‰u truye‡n cho ha¯m Te‚n ha¯m ÒˆÙÔc goÔi Trang 42
43. Ph
    ng Pháp Lp Trình - So· dˆı lie‰u truye‡n cho ha¯m pha˚i baËng so· tham so· khi khai ba˘o nguye‚n ma„u va¯ Òu˘ng thˆ˘ tˆÔ Òaı khai ba˘o (cu¯ng kieÂu dˆı lie‰u cu˚a tham so·) - VÙ˘i ca˘ch khai ba˘o tham so· nhˆ ha¯m findmax thÏ ta goÔi ca˘c tham so· na¯y la¯ tham trÚ vÏ kho‚ng co˘ da·u & hoaÎc * trˆÙ˘c te‚n tham so·(co¯n co˘ mo‰t loaÔi tham so· kha˘c la¯ tham bie·n). Khi Òo˘ cÙ che· truye‡n dˆı lie‰u die„n ra nhˆ sau: ° Ha¯m goÔi (cha˙ng haÔnÔ nhˆ ha¯m main trong vÌ duÔ tre‚n) co˘ the du¯ng haËng hoaÎc bie·n Òe truye‡n gia˘ trÚ cho tham so· cu˚a chˆÙng trÏnh ÒˆÙÔc goÔi, vÌ duÔ nhˆ ta co˘ the goÔi ha¯m findmax nhˆ sau: findmax(10,5) (gia˘ trÚ truye‡n cho tham so· x,y la¯ haËng) ° Ha¯m ÒˆÙÔc goÔi (cha˙ng haÔn nhˆ ha¯m findmax trong vÌ duÔ tre‚n) seı nha‰n gia˘ trÚ truye‡n cho no˘ va¯ lˆu nhˆıng gia˘ trÚ na¯y va¯o mo‰t vu¯ng nhÙ˘ goÔi la¯ vu¯ng nhÙ˘ taÔm. Khi Òo˘ moÔi le‰nh ta˘c Òo‰ng le‚n tham so· trong chˆÙng trÏnh con na¯y seı ta˘c Òo‰ng le‰n vu¯ng nhÙ˘ taÔm. Vu¯ng nhÙ˘ taÔm seı bÚ xo˘a ngay num1 num2 10 5 findmax(num1,num2) Bo‰ nhÙ˘ RAM x y Vu¯ng nhÙ˘ taÔm da¯nh cho x,y 10 5 sau khi Ha2m —ˆÙ45 GoÔi ke·t thu˘c. II. Ha¯m m a„u (function tem plate): —ˆÙÔc sˆ˚ duÔng khi gaÎp trˆÙ¯ng hÙÔp thay vÏ pha˚i vie·t nhie‡u ha¯m co˘ no‰i dung gio·ng nhau nhˆng a˘p duÔng tre‚n nhˆıng loaÔi dˆı lie‰u kha˘c nhau. VÌ duÔ nhˆ ca‡n pha˚i vie·t ha¯m tra˚ ve‡ trÚ tuye‰t Òo·i cu˚a mo‰t gia˘ trÚ ÒˆÙÔc truye‡n cho no˘. Va¯ gia˘ tri tra˚ ve‡ cu˚a ha¯m pha¯i cu¯ng kieÂu vÙ˘i gia˘ trÚ Òaı truye‡n cho no˘. Ta nha‰n tha·y gia˘ trÚ truye‡n cho ha¯m co˘ the‡ la¯ int, float hoaÎc double thay vÏ pha˚i vie·t ba ha¯m cho ba kieÂu dˆı lie‰u kha˘c nhau ta thÏ ta vie·t mo‰t ha¯m daÔng template nhˆ sau: VÌ duÔ 2: #include Trang 43
44. Ph
    ng Pháp Lp Trình _include template // do¯ng na¯y goÔi la¯ template prefix, template, class la¯ tˆ¯ kho˘a, T // la¯ te‚n do ngˆÙ¯i sˆ˚ duÔng ÒaÎt T u_abs(T value); // prototype void main(void) { int n1=5; float n2=-1.2345; double n3=-4.23456; cout T u_abs(T value) { if (value #include template T1 xmy(T1 x,T2 y); void main(void) { int i=5; float f=2.25; double d=4.2; Trang 44
45. Ph
    ng Pháp Lp Trình cout T1 xmy(T1 x,T2 y) { T1 result; result=(x+y)*(x-y); return result; } III. Sˆ˚ duÔng tham so· cu˚a ha¯m la¯ tham chie·u: Chu˘ng ta Òaı bie·t qua mo‰t loaÔi tham so· cu˚a ha¯m la¯ tham trÚ. —aÎc ÒieÂm cu˚a ca˘ch du¯ng tham so· na¯y la¯: Khi ha¯m goÔi truye‡n gia˘ trÚ cho ca˘c tham so· cu˚a ha¯m ÒˆÙÔc goÔi (trˆÔc tie·p baËng haËng hoa‰c tho‚ng qua ca˘c bie·n), thÏ nhˆıng tham so· na¯y seı nha‰n gia˘ trÚ ÒˆÙÔc truye‡n cho no˘ va¯ lˆu Ù˚ mo‰t vÚ trÌ kha˘c trong bo‰ nhÙ˘. Do Òo˘ vie‰c ta˘c Òo‰ng le‚n ca˘c tham so· cu˚a ha¯m ÒˆÙÔc goÔi tuye‰t Òo·i kho‚ng la¯m a˚nh hˆÙ˚ng Òe·n gia˘ trÚ cu˚a ca˘c Òo·i tˆÙÔng ma¯ ha¯m goÔi Òaı du¯ng Òe truye‡n cho no˘. Trong thˆÔc te· Òo‚i khi ta mong muo·n mo‰t ha¯m co˘ the ta˘c Òo‰ng trˆÔc tie·p le‚n ca˘c bie·n ma¯ ha¯m goÔi Òaı du¯ng Òe truye‡n gia˘ trÚ cho ca˘c tham so· cu˚a no˘. —e la¯m ÒˆÙÔc Òie‡u na¯y thÏ ta pha˚i sˆ˚ duÔng tham so· cu˚a ha¯m la¯ tham chie·u. Theo ca˘ch na¯y thÏ khi goÔi thˆÔc hie‰n mo‰t ha¯m co˘ tham so· thÏ ha¯m goÔi pha˚i du¯ng bie·n Òe truye‡n dˆı lie‰u cho ca˘c tham so· cu˚a ha¯m ÒˆÙÔc goÔi. Lu˘c na¯y tham so· seı nha‰n ÒÚa chÊ trong bo‰ nhÙ˘ RAM cu˚a bie·n Òaı truye‡n cho no˘, va¯ moÔi ta˘c Òo‰ng le‚n tham so· cu˚a ha¯m ÒˆÙÔc goÔi seı ta˘c Òo‰ng trˆÔc tie·p le‚n bie·n tˆÙng ˆ˘ng cu˚a chˆÙng trÏnh goÔi. Cu˘ pha˘p Òe khai ba˘o mo‰t tham so· daÔng tham chie·u trong do¯ng prototype va¯ do¯ng header line cu˚a ha¯m nhˆ sau: data_type& //khai ba˘o tre‚n do¯ng prototype data_type& reerence_name //Khai ba˘o tre‚n header line Trang 45
46. Ph
    ng Pháp Lp Trình VÌ duÔ 4: Haıy xem xe˘t chˆÙng trÏnhÔ sau. trong chˆÙng trÏnh co˘ m o‰t ha¯m swap co˘ co‚ng duÔng ÒoÂi gia˘ trÚ cu˚a hai bie·n ÒˆÙÔc du¯ng Òe truye‡n dˆı lie‰u cho ca˘c tham so· cu˚a no˘. #include #include void swap(int&, int&); void main() { int i=5,j=10; clrscr(); cout <<"\n Truoc khi goi ham swap\n" <<"i= "<<i<<" " <<"j= "<<j <<endl; //I=5 j=10 swap(i,j); cout <<"Sau khi goi ham swap\n" <<"i= "<<i<<" " <<"j= "<<j <<endl; //I=10 j=5 getch(); return; } void swap(int& x,int& y) { int tam; tam=x; x=y; y=tam; return; } i j 10 5 swap( i , j) Bo‰ nhÙ˘ RAM x y Trang 46
47. Ph
    ng Pháp Lp Trình ChˆÙng trÏnh tre‚n ne·u kho‚ng sˆ˚ duÔng tham chie·u thÏ ke·t qua˚ seı nhˆ the· na¯o? VÌ duÔ 5 :Xem xe˘t m o‰t vÌ duÔ kha˘c. ChˆÙng trÏnh sau co˘ m o‰t ha¯m tÌnh toÂng va¯ tÌch cu˚a ba so· thˆÔc. Ha¯m co˘ naÍm tham so· trong Òo˘ co˘ ba tham trÚ du¯ng Òe nha‰n ca˘c gia˘ trÚ m uo·n tÌnh toÂng va¯ tÌch, hai tham so· co¯n laÔi la¯ tham chie·u du¯ng Òe ke·t qua˚ toÂng va¯ tÌch tÌnh ÒˆÙÔc. #include #include void calc(float, float, float ,float&, float&); void main() { float n1,n2,n3,sum,product; clrscr(); cout >n1>>n2>>n3; calc(n1,n2,n3,sum,product); cout <<"\nTong ba so la: "<<sum <<"\nTich ba so la: "<<product; getch(); return; } void calc(float f1,float f2, float f3, float& s, float& p) { s=f1+f2+f3; p=f1*f2*f3; return; } Haıy veı hÏnh minh hoÔa cho vie‰c truye‡n, nha‰n tham so· cu˚a chˆÙng trÏnh tre‚n. Gia˚ sˆ˚ gia˘ trÚ nha‰p cho ba bie·n n1,n2,n3 la¯ 2.5, 4.5, 3.0 IV. PhaÔm vi cu˚a bie·n: Bie·n cuÔc bo‰: La¯ ca˘c bie·n ÒˆÙÔc khai ba˘o trong tha‚n cu˚a mo‰t ha¯m na¯o Òo˘. Ca˘c bie·n na¯y chÊ co˘ gia˘ trÚ trong phaÔm vÚ ha¯m khai ba˘o no˘. Bie·n toa¯n cuÔc: La¯ ca˘c bie·n ÒˆÙÔc khai ba˘o be‚n ngoa¯i ca˘c ha¯m. Nhˆıng bie·n na¯y co˘ gia˘ trÚ vÙ˘i ta·t ca˚ ca˘c ha¯m ÒˆÙÔc khai ba˘o sau no˘. Trang 47
48. Ph
    ng Pháp Lp Trình VÌ duÔ 6:: #include #include int n1; void sub_fun(); void main() { int n2; clrscr(); n1=10; n2=20; cout <<"Trong ham main() n1= "<<n1<<endl //10 <<"Trong ham main() n2= "<<n2<<endl; //20 sub_fun(); cout <<"Trong ham main() sau khi goi sub_fun n1= "<<n1<<endl //40 <<"Trong ham main() sau khi goi sub_fun n2= "<<n2<<endl;//20 getch(); return; } void sub_fun() { int n2; n2=30; cout <<"Trong ham sub_fun() n1= " <<n1<<endl //10 <<"Trong ham sub_fun() n2= " <<n2<<endl; //30 n1=40; return; } Trong vÌ duÔ tre‚n n1 la¯ bie·n toa¯n cuÔc, va¯ n2 la¯ bie·n cuÔc bo‰ co˘ ca˚ trong main va¯ sub_fun. Hai do¯ng le‰nh cout Òa‡u cu˚a ha¯m main seı in le‚n ke·t qua˚: Trong ham main() n1= 10 Trong ham main() n2= 20 gia˘ trÚ na¯y la¯ cu˚a n2 trong ha¯m main Khi ha¯m sub_fun ÒˆÙÔc goÔi no˘ seı in le‚n ke·t qua˚ Trong ham sub_fun() n1= 10 Trong ham sub_fun() n2= 30 gia˘ trÚ na¯y la¯ cu˚a n2 trong ha¯m sub_fun Hai do¯ng le‰nh cout cuo·i cu˚a ha¯m main seı in le‚n ke·t qua˚: Trong ham main() sau khi goi sub_fun n1= 40 ( n1 Òaı bÚ ÒoÂi trong ha¯m sub_fun) Trang 48
49. Ph
    ng Pháp Lp Trình Trong ham main() sau khi goi sub_fun n2= 20 (n2 cu˚a ha¯m main) Chu˘ng ta co˘ the minh hoÔa vie‰c lˆu trˆı va¯ phaÔm vÚ cu˚a ca˘c bie·n trong chˆÙng trÏnh tre‚n nhˆ sau: n1 Lˆu trˆı n1 main() n2 Lˆu trˆı n2 trong m ain sub_fun() n2 Lˆu trˆı n2 trong sub_fun Trong vÌ duÔ tre‚n ne·u ta khai ba˘o n1 dˆÙ˘i ha¯m main thÏ ha¯m main seı kho‚ng hieÂu ÒˆÙÔc bie·n na¯y. Lˆu y˘: Khi bie·n toa¯n cuÔc va¯ bie·n cuÔc bo‰ tru¯ng te‚n thÏ ca˘c bie·n cuÔc bo‰ seı ˆu tie‚n ÒˆÙÔc hieÂu trong ha¯m khai ba˘o no˘. VÌ du 7Ô: #include #include float n=42.8; void sub(); void main() { float n=30.5; cout <<îGia˘ trÚ cu˚a n= ì <<n<<endl; //30.5; sub(); getch(); Trang 49
50. Ph
    ng Pháp Lp Trình return; } void sub(); { cout <<îtrong sub n= ì<<n <<endl; //42.8 } Trong trˆÙ¯ng hÙÔp tre‚n ne·u ta muo·n ha¯m main pha˚i in ra gia˘ trÚ cu˚a bie·n toa¯n cuÔc thÏ ta pha˚i sˆ˚ duÔng toa˘n tˆ˚ scope resolution ky˘ hie‰u bÙ˚i :: ngay trˆÙ˘c te‚n bie·n. cout <<îGia˘ trÚ cu˚a n= ì <<::n<<endl; //42.8; Chu˘ng ta kho‚ng ne‚n laÔm duÔng bie·n toa¯n cuÔc bÙ˚i khi Òo˘ no˘ seı pha˘ vÙ˚ sˆÔ ba˚o ve‰ an toa¯n ma¯ C++ Òaı cung ca·p, Òo˘ la¯ sˆÔ Òo‰c la‰p cu˚a ca˘c ha¯m, no˘ cuıng la¯m ma·t Òi sˆÔ caÂn tha‰n ca‡n thie·t cu˚a ngˆÙ¯i la‰p trÏnh Òo˘ la¯ vie‰c pha˚i xa˘c ÒÚnh roı kieÂu dˆı lie‰u cu˚a tham so· ,bie·n cuÔc bo‰, va¯ gia˘ trÚ tra˚ ve‡ cu˚a ha¯m. HÙn nˆıa gia˘ trÚ cu˚a bie·n toa¯n cuÔc co˘ the thay ÒoÂi bÙ˚i ba·t cˆ˘ mo‰t ha¯m na¯o khai ba˘o sau no˘, vÏ va‰y vie‰c pha˘t hie‰n ra nhˆıng lo„i gia˚i thua‰t co˘ trong chˆÙng trÏnh la¯ ra·t kho˘ khaÍn. V. LÙ˘p lˆu trˆı ca˘c bie·n: Ngoa¯i vie‰c mo„i bie·n co˘ mo‰t kieÂu dˆı lie‰u va¯ phaÔm vi co˘ hie‰u lˆÔc cu˚a no˘, mo„i bie·n co¯n thuo‰c ve‡ mo‰t lÙ˘p lˆu trˆı na¯o Òo˘. Trong C++ co˘ bo·n lÙ˘p lˆu trˆı Òo˘ la¯: auto, static, extern va¯ register. Khi khai ba˘o mo‰t bie·n ta co˘ the chÊ roı lÙ˘p lˆu trˆı cu˚a bie·n na¯y, vÌ duÔ nhˆ: auto int num; static int mile; register int volts; auto float yrs; TrˆÙ˘c he·t chu˘ng ta seı tÏm hieÂu ca˘c lÙ˘p lˆu trˆı da¯nh cho bie·n cuÔc bo‰. 1. Ca˘c lÙ˘p lˆu trˆı bie·n cuÔc bo‰: Bie·n cuÔc bo‰ co˘ the lˆu trˆı Ù˚ mo‰t trong 3 lÙ˘p auto, static hoaÎc register. Ne·u mo‰t bie·n cuÔc bo‰ khi khai ba˘o kho‚ng co˘ mo‚ ta˚ lÙ˘p thÏ xem nhˆ bie·n na¯y thuo‰c lÙ˘p auto vÏ Òa‚y la¯ lÙ˘p maÎc nhie‚n. Ca˘c bie·n cuÔc bo‰ thuo‰c lÙ˘p auto seı xua·t hie‰n trong bo‰ nhÙ˘ khi ha¯m khai ba˘o no˘ ÒˆÙÔc goÔi thˆÔc hie‰n va¯ xo˘a kho˚i bo‰ nhÙ˘ khi ha¯m na¯y Òaı thˆÔc hie‰n xong. VÌ duÔ 8: Trang 50
51. Ph
    ng Pháp Lp Trình _include #include void sub(); void main() { int i; clrscr(); for (i=0; i #include void sub(); void main() { int i; clrscr(); for (i=0; i<5;i++) sub(); getch(); Trang 51
52. Ph
    ng Pháp Lp Trình return; } void sub() { static int num=1; cout <<num<<" ";; num++; return; } ChˆÙng trÏnh tre‚n seı in le‚n ma¯n hÏnh: 1 2 3 4 5 Ne·u trong chˆÙng trÏnh lu˘c khai ba˘o ta kho‚ng khÙ˚i taÔo gia˘ trÚ cho bie·n cuÔc bo‰ static thÏ bie·n na¯y seı ÒˆÙÔc khÙ˚i taÔo baËng 0. LÙ˘p lˆu trˆı co¯n laÔi da¯nh cho bie·n cuÔc bo‰ la¯ register. ThÙ¯i gian to‡n taÔi cu˚a mo‰t bie·n register cuıng gio·ng nhˆ bie·n thuo‰c lÙ˘p auto. SˆÔ kha˘c nhau duy nha·t giˆıa register va¯ auto la¯ nÙi lˆu trˆı. NÙi lˆu trˆı ca˘c ta·t ca˚ ca˘c bie·n ngoaÔi trˆ¯ bie·n register la¯ RAM, co¯n bie·n register thÏ ÒˆÙÔc lˆu trˆı vu¯ng nhÙ˘ trˆÔc tie·p cu˚a CPU vÏ va‰y vie‰c truy xua·t ca˘c bie·n kieÂu register nhanh hÙn ca˘c bie·n kha˘c. Tuy nhie‚n kho‚ng pha˚i ba·t ky¯ ma˘y tÌnh na¯o cuıng ho trÙÔ loaÔi bie·n na¯y va¯ ne·u co˘ thÏ vu¯ng nhÙ˘ trong CPU da¯nh lˆu trˆı bie·n cuıng nho˚, vÏ va‰y bie·n ÒˆÙÔc khai ba˘o register seı tˆÔ Òo‰ng chuyeÂn sang lÙ˘p auto ne·u ma˘y tÌnh Òang du¯ng kho‚ng ho trÙÔ loaÔi dˆı lie‰u na¯y hoaÎc khai ba˘o cu˚a bie·n register vˆÙ˘t qua˘ sˆ˘c chˆ˘a cu˚a ma˘y tÌnh. 2. Ca˘c lÙ˘p lˆu trˆı bie·n toa¯n cuÔc: Bie·n toa¯n cuÔc la¯ nhˆıng bie·n ÒˆÙÔc khai ba˘o be‚n ngoa¯i ha¯m Ca˘c bie·n na¯y to‡n taÔi trong bo‰ nhÙ˘ tˆ¯ khi chˆÙng trÏnh baÈt Òa‡u thˆÔc hie‰n cho Òe·n khi chˆÙng trÏnh ke·t thu˘c. Mo‰t bie·n toa¯n cuÔc thÏ co˘ the thuo‰c lÙ˘p extern,hoaÎc static. Ca˘c lÙ˘p extern, static chÊ a˚nh hˆÙ˚ng Òe·n phaÔm vi chˆ˘ kho‚ng a˚nh hˆÙ˚ng Òe·n thÙ¯i gian to‡n taÔi cu˚a bie·n. MuÔc ÒÌch cu˚a extern la¯ mÙ˚ ro‰ng vie‰c sˆ˚ duÔng cu˚a mo‰t bie·n toa¯n cuÔc sang mo‰t ta‰p tin chˆÙng trÏnh kha˘c (khi chˆÙng trÏnh ÒˆÙÔc lˆu trˆı tre‚n nhie‡u file) Trang 52
53. Ph
    ng Pháp Lp Trình File 1 File 2 int volts; double factor; float current; extern int volts; static double power; void main() void fun3(); { fun1(); { fun2(); . fun3(); . fun4(); . } } extern double factor; void fun4() void fun1(); { { . . . . . . } } void fun2() { . . . } theo hÏnh minh hoÔa tre‚n ta tha·y no‰i dung chˆÙng trÏnh ÒˆÙÔc lˆu trˆı tre‚n 2 ta‰p tin. Bie·n volts Ù˚ la‡n khai ba˘o Òa‡u trong file 1 kho‚ng co˘ extern (Òa‚y la¯ qui ÒÚnh). ‘¤ la‡n khai ba¯o thˆ˘ hai trong file 2 co˘ extern vÙ˘i muÔc ÒÌch ba˘o cho trÏnh bie‚n dÚch bie·t Òa‚y kho‚ng pha˚i la¯ mo‰t bie·n mÙ˘i ma¯ la¯ mo‰t bie·n Òaı to‡n taÔi trong bo‰ nhÙ˘. Khi ta khai ba˘o extern trˆÙ˘c mo‰t te‚n bie·n thÏ baÈt buo‰t bie·n na¯y Òaı ÒˆÙÔc khai ba˘o trˆÙ˘c Òo˘ Ù˚ mo‰t nÙi kha˘c trong chˆÙng trÏnh va¯ chÊ mo‰t la‡n ma¯ tho‚i Òo‡ng thÙ¯i kho‚ng co˘ tˆ¯ extern phÌa trˆÙ˘c. TˆÙng tˆÔ nhˆ va‰y cho bie·n factor LÙ˘p static da¯nh cho bie·n toa¯n cuÔc thÏ du¯ng Òe ngaÍn chaÎn vie‰c mÙ˚ ro‰ng phaÔm vi sˆ˚ suÔng cu˚a bie·n na¯y ra mo‰t file kha˘c. Cha˙ng haÔn trong hÏnh minh hoÔa tre‚n bie·n power Òaı khai ba˘o trong file 1 thuo‰c lÙ˘p static khÏ trong file 2 ta kho‚ng the khai ba˘o extern double power Trang 53
54. Ph
    ng Pháp Lp Trình VI. Ca˘c lo„i thˆÙ¯ng gaÎp trong chˆÙng trÏnh: 1. Mo‰t lo„i ra·t thˆÙ¯ng gaÎp trong laÎp trÏnh la¯ truye‡n dˆı lie‰u cho tham so· khi goÔi ha¯m thˆÔc hie‰n kho‚ng chÌnh xa˘c cha˙ng haÔn nhˆ truye‡n thie·u/thˆ¯a, du¯ng haËng Òe truye‡n cho tham chie·u 2. Ca‡n lˆu y˘ khi co˘ hai bie·n co˘ cu¯ng te‚n cu¯ng xua·t hie‰n trong ha¯m goÔi la„n la¯m ÒˆÙÔc goÔi 3. Thie·u ca˘c nguye‚n ma„u cu˚a ca˘c ha¯m co˘ trong chˆÙng trÏnh. 4. Thie·u da·u cha·m phaÂy Ù˚ cuo·i ca˘c do¯ng nguye‚n ma„u 5. Dˆ da·u cha·m phaÂy Ù˚ cuo·i do¯ng tie‚u Òe‡ cu˚a mo„i ha¯m 6. Kho‚ng ghi kie‡u dˆı lie‰u cu˚a tham so· trong nguye‚n ma„u cuıng nhˆ tie‚u Òe‡ ha¯m. Trang 54
55. Ph
    ng Pháp Lp Trình BAÿI 7 : LAƒP TRÃNH —Eƒ QUI Khoa hoÔc tin hoÔc co˘ mo‰t kyı thua‰t ÒaÎc trˆng Òe gia˚i quye·t va·n Òe‡ so vÙ˘i ca˘c khoa hoÔc kha˘c Òo˘ la¯ kyı thua‰t Òe‰ qui. —e‰ qui kho‚ng nhˆıng la¯ ca˘ch Òe tˆ duy (tÏm thua‰t toa˘n) ra·t tˆÔ nhie‚n ma¯ co¯n la¯ mo‰t co‚ng cuÔ ra·t hie‰u qua˚ Òe gia˚i quye·t va·n Òe‡. Co˘ ra·t nhie‡u ba¯i toa˘n ne·u kho‚ng du¯ng Òe‰ qui thÏ kho‚ng the tÏm ra lÙ¯i gia˚i; hoaÎc ne·u tÏm ra, thÏ Òo˘ la¯ lÙ¯i gia˚i gˆÙÔng e˘p, kho˘ hieÂu mang naÎng tÌnh kyı thua‰t. Nhie‡u phˆÙng pha˘p gia˚i quye·t va·n Òe‡ nhˆ quay lui, quy hoaÔch Òo‰ng, nha˘nh ca‰n, . . . dˆÔa va¯o kyı thua‰t Òe‰ qui. —e‰ qui maÔnh Ù˚ ÒieÂm co˘ the ÒÚnh nghÛa mo‰t ta‰p vo‚ haÔn ca˘c Òo·i tˆÙÔng chÊ baËng mo‰t so· hˆıu haÔn ca˘c me‰nh Òe‡. Tˆ tˆÙ˚ng gia˚i ba¯i toa˘n baËng thua‰t toa˘n Òe‰ quy la¯ Òˆa ba¯i toa˘n ban Òa‡u ve‡ mo‰t ba¯i toa˘n cu¯ng loaÔi, cu¯ng tÌnh cha·t nhˆng Ù˚ ca·p Òo‰ tha·p hÙn, qua˘ trÏnh na¯y tie·p tuÔc cho Òe·n khi ba¯i toa˘n ÒˆÙÔc Òˆa ve‡ ca·p Òo‰ ma¯ taÔi Òo˘ co˘ the gia˚i ÒˆÙÔc de„ da¯ng. Tˆ¯ ke·t qua˚ Ù˚ ca·p Òo‰ na¯y ta seı la‡n ngˆÙÔc Òe gia˚i ba¯i toa˘n Ù˚ ca·p Òo‰ cao hÙn, cho Òe·n khi gia˚i ÒˆÙÔc ba¯i toa˘n Ù˚ ca·p Òo‰ ban Òa‡u va¯ Òa‚y cuıng chÌnh la¯ ˆu ÒieÂm ra·t noÂi ba‰t cu˚a thua‰t toa˘n Òe‰ qui. 2.1.KHAŸI NIEƒM —Eƒ QUI Mo‰t ha¯m ÒˆÙÔc goÔi la¯ co˘ tÌnh Òe‰ qui ne·u trong tha‚n cu˚a no˘ co˘ le‰nh goÔi laÔi chÌnh no˘ mo‰t ca˘ch trˆÔc tie·p hay gia˘n tie·p. Mo‰t chˆÙng trÏnh ÒˆÙÔc goÔi la¯ co˘ tÌnh Òe‰ qui ne·u no˘ co˘ chˆ˘a Ìt nha·t mo‰t ha¯m Òe‰ qui. Mo‰t ha¯m Òe‰ qui go‡m co˘ hai pha‡n: Pha‡n cÙ sÙ˚ va¯ pha‡n Òe‰ qui. Pha‡n cÙ sÙ˚ (hay co¯n goÔi la¯ pha‡n dˆ¯ng) mo‚ ta˚ ca·p Òo‰ gia˚i ÒˆÙÔc cu˚a ba¯i toa˘n, pha‡n Òe‰ quy la¯ pha‡n goÔi laÔi chÌnh no˘ nhˆng vÙ˘i ca·p Òo‰ tha·p hÙn. Ba˚n cha·t cu˚a la‰p trÏnh Òe‰ qui nhˆ the· na¯o? Trong la‰p trÏnh Òe‰ qui, khi mo‰t ha¯m (hay thu˚ tuÔc) goÔi Òe‰ qui Òe·n chÌnh no˘, thÏ Ù˚ mo„i la‡n goÔi tÙ˘i, ma˘y seı taÔo ra mo‰t ta‰p ca˘c bie·n cuÔc bo‰ hoa¯n toa¯n Òo‰c la‰p vÙ˘i ca˘c ta‰p bie·n cuÔc bo‰ Òaı ÒˆÙÔc taÔo ra trong ca˘c la‡n goÔi trˆÙ˘c Òo˘, co˘ bao nhie‚u la‡n goÔi tÙ˘i ha¯m Òe‰ quy thÏ cuıng co˘ ba·y nhie‚u la‡n thoa˘t ra kho˚i ha¯m, cˆ˘ mo„i la‡n thoa˘t ra kho˚i ha¯m thÏ mo‰t ta‰p ca˘c bie·n cuÔc bo‰ seı ÒˆÙÔc gia˚i pho˘ng, sˆÔ tˆÙng ˆ˘ng giˆıa ca˘c la‡n goÔi tÙ˘i ha¯m va¯ thoa˘t ra kho˚i Trang 55
56. Ph
    ng Pháp Lp Trình ha¯m ÒˆÙÔc thˆÔc hie‰n theo thˆ˘ tˆÔ ngˆÙÔc, nghÛa la¯ la‡n ra Òa‡u tie‚n ˆ˘ng vÙ˘i la‡n va¯o cuo·i cu¯ng va¯ la‡n ra kho˚i ha¯m cuo·i cu¯ng ˆ˘ng vÙ˘i la‡n Òa‡u tie‚n goÔi tÙ˘i ha¯m (cÙ che· va¯o sau ra trˆÙ˘c) Ca˘c chˆÙng trÏnh Òe‰ quy thˆÙ¯ng gaÎp co˘ the thuo‰c trong ba loaÔi sau: —e‰ quy tuye·n tÌnh, Òe‰ quy nhÚ pha‚n va¯ Òe‰ quy phi tuye·n. Trong muÔc dˆÙ˘i Òa‚y, chu˘ng ta la‡n lˆÙÔt xe˘t mo‰t so· loaÔi Òe‰ quy ke tre‚n, Ù˚ mo„i loaÔi chu˘ng ta minh hoÔa baËng mo‰t so· vÌ duÔ ÒieÂn hÏnh. 2.2.PHA¬N LOAœI —Eƒ QUY 2.2.1.—e‰ quy tuye·n tÌnh (co¯n goÔi la¯ Òe‰ quy Òuo‚i): Mo‰t ha¯m ÒˆÙÔc goÔi la¯ Òe‰ quy tuye·n tÌnh ne·u mo‰t la‡n goÔi ha¯m no˘ chÊ pha˘t sinh to·i Òa mo‰t lÙ¯i goÔi Òe‰ quy. VÌ duÔ 2.1 Vie·t chˆÙng trÏnh tÌnh n!, vÙ˘i n la¯ mo‰t so· nguye‚n kho‚ng a‚m. Giai thˆ¯a ÒˆÙÔc ÒÚnh nghÛa theo kieÂu quy naÔp: n! = n*(n-1)! Sau Òa‚y la¯ mo‰t lÙ¯i gia˚i Òe‰ quy: #include #include //Prototype long GiaiThua(int N); //Ha¯m chÌnh void main() { clrscr(); cout<<GiaiThua(5)<<endl; getch(); } //—Únh nghÛa ca˘c ha¯m long GiaiThua(int N) { Trang 56
57. Ph
    ng Pháp Lp Trình if (n==0|| n==1) return 1; else return (N* GiaiThua (N-1)); } //=== ChaÔy tˆ¯ng bˆÙ˘c chˆÙng trÏnh na¯y. giaithua(5)=5* giaithua(4)=5*4* giaithua(3)=5*4*3* giaithua(2)=5*4*3*2* giaithua(1)= 5*4*3*2*1=120 2.2.2.—e‰ quy nhÚ pha‚n Mo‰t ha¯m ÒˆÙÔc goÔi la¯ Òe‰ quy nhÚ pha‚n ne·u mo„i la‡n goÔi ha¯m no˘ pha˘t sinh to·i Òa hai lÙ¯i goÔi Òe‰ quy. VÌ duÔ 2.2.TÌnh so· haÔng thˆ˘ n cu˚a daıy Fibonasci F(n) bie·t F(1)=1, F(2)=1, F(n)= F(n-1) + F(n-2) #include #include // Prototype int f(int N); //Ha¯m chÌnh void main() { clrscr(); cout<<f(7)<<endl; getch(); } //Ca˘c ha¯m Trang 57
58. Ph
    ng Pháp Lp Trình int f(int N) { if (n==1 || n==2) return 1; else return f(n-1)+f(n-2); } VÌ duÔ 2.3. Ba¯i toa˘n tÏm kie·m nhÚ pha‚n Ba¯i toa˘n: cho daıy n so· nguye‚n taÍng da‡n ai. Va¯ mo‰t so· nguye‚n x. Haıy kieÂm tra xem x co˘ thuo‰c daıy so· tre‚n hay kho‚ng ? ne·u co˘ haıy in ra chi so· i ma¯ a[i]=x. ne·u kho‚ng haıy in ra so· ñ1. int BinarySearch_Recursive(int a[],int N,int x,int left,int right) { if (left>right) return -1; int mid=(left+right)/2; if (x==a[mid]) return mid; if (x<a[mid]) return BinarySearch_Recursive(a,N,x,left,mid-1); return BinarySearch_Recursive(a,N,x,mid+1,right); } 2.2.4.—e‰ quy phi tuye·n (Òe‰ quy phˆ˘c): Mo‰t ha¯m ÒˆÙÔc goÔi la¯ Òe‰ quy phi tuye·n ne·u mo„i la‡n goÔi Òe‰ quy no˘ pha˘t sinh ra khoa˚ng n la‡n goÔi Òe‰ quy - tho‚ng thˆÙ¯ng lÙ¯i goÔi Òe‰ quy ÒˆÙÔc ÒaÎt trong vo¯ng la‰p. VÌ duÔ 2.4: ba¯i toa˘n tÏm ta·t ca˚ ca˘c daıy nhÚ pha‚n chie‡u da¯i n Cha˙ng haÔn vÙ˘i n=3 thÏ ke·t qua˚ la¯: 0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 Trang 58
59. Ph
    ng Pháp Lp Trình 1 0 1 1 1 0 1 1 1 ChˆÙng trÏnh: #include #include #include int x[1000]; int m,dem=0; //Prototype void Xuat(); void DuyetNhiPhan(int i); //Ha¯m chÌnh void main() { clrscr(); cout >m; DuyetNhiPhan(1); getch(); } //Ca˘c ha¯m void Xuat() { cout<<++dem<<setw(4); for (int i=1;i<=m;i++) cout<<x[i]<<setw(4); cout<<endl; } //=== void DuyetNhiPhan(int i) Trang 59
60. Ph
    ng Pháp Lp Trình X for (int j=0;j #include //Prototype long GiaiThuaKDQ(int N); void main() { clrscr(); cout<< GiaiThuaKDQ(5)<<endl; getch(); } Trang 60
61. Ph
    ng Pháp Lp Trình OOCa˘c ha¯m GiaiThuaKDQ(int N) { long temp=1; for (int i=1 ; i #include void main() { clrscr(); int f[100]; int N; cout >N; f[1]=f[2]=1; for (int i=3;i<=n;i++) f[i]=f[i-1]+f[i-2]; cout<<f[n]<<endl; getch(); } BaÔn ÒoÔc haıy thˆ˚ tÌnh f(n) ne·u n=100.000 Trang 61
62. Ph
    ng Pháp Lp Trình VÌ duÔ 2.3.a. Ca¯i ÒaÎt kho‚ng Òe‰ quy gia˚i ba¯i toa˘n tÏm kie·m nhÚ pha‚n. int BinarySearch(int a[],int N,int x) { int left=0,right=N-1,mid; do { mid=(left+right)/2; if (x==a[mid]) return mid; else if (x<a[mid]) right=mid -1; else left=mid+1; } while (left<=right); return -1; } Trang 62
63. Ph
    ng Pháp Lp Trình PHA¿N II D÷’ LIEƒU COŸ CA¡U TRUŸC Trang 63
64. Ph
    ng Pháp Lp Trình BAÿI 8 : MA¤NG (ARRAY) Ca˘c loaÔi bie·n ma¯ chu˘ng ta Òaı gaÎp qua co˘ mo‰t ÒaÎc ÒieÂm chung la¯: Mo„i bie·n co˘ the du¯ng Òe lˆu duy nha·t mo‰t gia˘ trÚ taÔi mo‰t thÙ¯i ÒieÂm nhˆng loaÔi bie·n na¯y goÔi la¯ bie·n nguye‚n tˆ˚ hay bie·n vo‚ hˆÙ˘ng bÙ˚i gia˘ cu˚a no˘ kho‚ng the chia nho˚ hÙn nˆıa. Chu˘ng ta thˆÙ¯ng gaÎp mo‰t ta‰p hÙÔp nhie‡u gia˘ trÚ ma¯ ta·t ca˚ chu˘ng Òe‡u co˘ cu¯ng mo‰t kieÂu dˆı lie‰u, vÌ duÔ nhˆ: —ieÂm mo‰t mo‚n hoÔc cu˚a sinh vie‚n trong mo‰t lÙ˘p So· ba˘o danh cu˚a thÌ sinh trong mo‰t ky˘ thi Khi Òo˘ Òe lˆu nhˆıng gia˘ na¯y ne·u chu˘ng ta sˆ˚ duÔng ca˘c bie·n vo‚ hˆÙ˘ng thÏ ra·t kho˘ trong va·n Òe‡ la‰p trÏnh (pha˚i khai ba˘o nhie‡u bie·n  pha¯i nhÙ˘ te‚n, kho‚ng kha˚ thi). —e gia˚i quye·t va·n Òe‡ na¯y C++ cung ca·p mo‰t loaÔi bie·n Array (Ma˚ng). Array: La¯ mo‰t danh sa˘ch chˆ˘a ca˘c gia˘ trÚ co˘ cu¯ng loaÔi dˆı lie‰u. Mo‰t danh sa˘ch nhˆ va‰y seı co˘ te‚n Òe pha‚n bie‰t, va¯ Òe truy xua·t Òe·n mo‰t pha‡n tˆ˚ na¯o trong danh sa˘ch ta seı dˆÔa va¯o te‚n danh sa˘ch va¯ chÊ so·. I. Ma˚ng m o‰t chie‡u (one dim ensional array): 1. Khai ba˘o ma˚ng: Cu˘ pha˘p: data_type array_name [number-of-items]; Trang 64
65. Ph
    ng Pháp Lp Trình data type: KieÂu dˆı lie‰u cu˚a ma˚ng array_name: Te‚n ma˚ng number-of-item: so· pha‡n tˆ˚ cu˚a ma˚ng. VÌ duÔ: int diem[5]; float dtb[10]; Tho‚ng thˆÙ¯ng trong la‰p trÏnh ngˆÙ¯i ta thˆÙ¯ng ÒÚnh nghÛa trˆÙ˘c mo‰t haËng chˆ˘a so· pha‡n tˆ˚ cu˚a maıng. —ie‡u na¯y ra·t co˘ lÙÔi khi ta ca‡n thay ÒoÂi so· pha‡n tˆ˚ cu˚a ma˚ng. Nhˆ va‰y ta co˘ the khai ba˘o mo‰t ma˚ng nhˆ sau: const int SIZE=5; int diem[SIZE]; Hay const int SIZE=8; char code[SIZE]; Khi khai ba˘o nhˆ tre‚n thÏ mo„i ma˚ng seı ÒˆÙÔc cung ca·p Òu˚ so· o‚ nhÙ¯ ca‡n thie·t Òe lˆu trˆı ca˘c pha‡n tˆ˚ cu˚a ma˚ng. Va¯ ca˘c pha‡n tˆ˚ cu˚a mo‰t ma˚ng thÏ ÒˆÙÔc lˆu trˆı lie‚n tuÔc vÙ˘i nhau. code[0] code[1] code[2] code[3] code[4] code[5] code[6] code[7] HÏnh a˚nh cu˚a m a˚ng code ÒˆÙÔc lˆu trong bo‰ nhÙ˘ —e truy xua·t tÙ˘i mo‰t pha‡n tˆ˚ na¯o Òo˘ cu˚a ma˚ng ta theo cu˘ pha˘p: array_name[offset] vÌ duÔ nhˆ code[2] (truy xua·t de·n pha‡n tˆ¯ thˆ˘ hai cu˚a ma˚ng code). Lˆu y˘: Trong C++ vÚ trÌ (chÊ so·) cu˚a ca˘c pha‡n tˆ˚ trong ma˚ng ÒˆÙÔc Òa˘nh so· tˆ¯ 0. —ie‡u na¯y giu˘p taÍng to·c Òo‰ xˆ˚ ly˘ cu˚a ma˘y tÌnh khi truy xua·t ma˚ng, bÙ˚i vÚ trÌ na¯y ba˘o cho ma˘y tÌnh bie·t pha˚i bo˚ qua ma·y pha‡n tˆ˚ ke tˆ¯ pha‡n tˆ˚ Òa‡u tie‚n Òe truy xua·t ÒˆÙÔc pha‡m tˆ˚ mong muo·n. Mo„i mo‰t pha‡n tˆ˚ cu˚a ma˚ng co˘ the sˆ˚ duÔng ba·t cˆ˘ Ù˚ vÚ trÌ na¯o ma¯ mo‰t bie·n vo‚ hˆÙ˘ng hÙÔp le‰ xua·t hie‰n. VÌ duÔ ca˘c vÚ trÌ xua·t hie‰n cu˚a ma˚ng code sau Òa‚y la¯ hÙÔp le‰: code[0]= ëAí; code[i]=code[0]+32 ChÊ so· cu˚a mo‰t pha‡n tˆ˚ ÒaÎt trong [] la¯ mo‰t haËng so· nguye‚n hoaÎc ba·t ky¯ mo‰t bieÂu thˆ˘c na¯o ma¯ gia˘ trÚ cu˚a no˘ la¯ mo‰t so· nguye‚n. VÌ duÔ nhˆ: code[i] , code[i+1], code[i*2] Trang 65
66. Ph
    ng Pháp Lp Trình Co˘ mo‰t thua‰n lÙÔi ra·t lÙ˘n khi ta sˆ˚ duÔng mo‰t bieÂu thˆ˘c nhˆ la¯ chÊ so· cu˚a ma˚ng, bÙ˚i khi Òo˘ no˘ cho phe˘p ta co˘ the truy xua·t tˆ¯ Òa‡u de·n cuo·i ma˚ng baËng mo‰t vo¯ng laÎp. VÌ duÔ: ta co˘ ma‰t ma˚ng ÒˆÙÔc khai ba˘o nhˆ sau: const int SIZE=5; int a[SIZE]; gia˚ sˆ˚ nhˆ ma˚ng Òaı co˘ gia˘ trÚ va¯ ta ca‡n tÌnh toÂng gia˘ trÚ cu˚a ma˚ng Òˆa va¯o bie·n sum , thay vÏ pha˚i vie·t le‰nh: sum= a[0]+a[1]+a[2]+a[3]+a[4]; thÏ ta co˘ the vie·t: for (i=0;i >code[1]>>code[3]. Khi ca‡n nha‰p dˆı lie‰u la‡n lˆÙÔt cho nhie‡u pha‡n tˆı cu˚a ma˚ng ta co˘ the du¯ng vo¯ng laÎp VÌ duÔ: for (i=0;i 9, Òie‡u na¯y co˘ the ga‚y ra sˆÔ Òo vÙ˚ cu˚a chˆÙng trÏnh. VÌ duÔ 1: ChˆÙng trÏnh dˆÙ˘i Òa‚y thˆÔc hie‰n nhˆıng co‚ng vie‰c sau: Nha‰p gia˘ trÚ va¯o m o‰t m a˚ng 10 pha‡n tˆ˚. In m a˚ng le‚n m a¯n hÏnh Trang 66
67. Ph
    ng Pháp Lp Trình In toÂng gia˘ trÚ cu˚a ca˘c pha‡n tˆ˚ trong m a˚ng In gia˘ trÚ lÙ˘n nha·t cu˚a m a˚ng le‚n m a¯n hÏnh #include #include #include void main() { const int SIZE=5; int i,a[SIZE],tong,max,min; clrscr(); cout >a[i]; } cout max) max=a[i]; cout <<"\nGia tri lon nhat trong mang: "<<max; for (i=1; i<SIZE; i++) if (a[i]<min)min=a[i]; cout <<"\nGia tri nho nhat trong mang: "<<min; getch(); return; } 3. Sˆ˚ duÔng ha¯m taÔo so· nga„u nhie‚n: Trong mo‰t va¯i trˆÙ¯ng hÙÔp khi vie·t chˆÙng trÏnh chu˘ng ta chÊ quan ta‚m la¯m sao chˆÙng trÏnh Òˆa ÒˆÙÔc ke·t qua˚ chÌnh xa˘c, co¯n so· lie‚u thÏ (kieÂu so· nguye‚n) kho‚ng ra¯ng buo‰t pha˚i theo mo‰t mo‰t ma„u cho Trang 67
68. Ph
    ng Pháp Lp Trình trˆÙ˘c, thÏ ta co˘ the du¯ng ha¯m random cu˚a C++ cung ca·p Òe taÔo ra ca˘c so· nga„u nhie‚n, tra˘nh pha˚i ma·t thÙ¯i gian cho nha‰p lie‰u. Ha¯m random co˘ cu˘ pha˘p nhˆ sau: int random(int n) Ke·t qua˚ cu˚a ha¯m la¯ mo‰t so· nguye‚n tˆ¯ 0 Òe·n n-1 TrˆÙ˘c khi sˆ˚ duÔng random ta pha˚i goÔi randomize() Òe khÙ˚i taÔo che· Òo‰ taÔo so· nga„u nhie‚n. Muo·n sˆ˚ duÔng ca˘c ha¯m tre‚n thÏ trong chˆÙng trÊnh ta pha˚i khai ba˘o #include VÌ duÔ 2: ChˆÙng trÏnh sau taÔo gia˘ trÚ nga„u nhie‚n cho m o‰t m a˚ng 50 pha‡n tˆ˚ in m a˚ng le‚n m a¯n hÏnh. #include #include #include #include void main() { const int SIZE=50; long int i,a[SIZE],tong,max,min; clrscr(); randomize; cout <<"Tao gia tri cho mang\n"; for (i=0; i<SIZE; i++) a[i]=random(100); cout <<"\n Mang da tao \n"; for (i=0; i<SIZE; i++) cout <<setw(10)<<a[i]; getch(); return; } 4. KhÙ˚i taÔo gia˘ trÚ cho ma˚ng: TaÔi thÙ¯i ÒieÂm khai ba˘o ta cuıng co˘ the khÙ˚i taÔo gia˘ tri cho ma˚ng baËng ca˘ch ÒaÎt ca˘c gia˘ trÚ na¯y va¯o da·u {} VÌ duÔ: const int SIZE=5; int a[SIZE]={2,95,9,6,3}; ca˘c gia˘ trÚ khÙ˚i taÔo cho ma˚ng cuıng co˘ the ÒaÎt tre‚n nhie‡u do¯ng const int SIZE=10; int b[10]= {2,6,1,7,8,5,3,9,10,12}; Trang 68
69. Ph
    ng Pháp Lp Trình Ne·u ca˘c gia˘ trÚ lie‰t ke‚ trong {} Ìt hÙn so· pha‡n tˆ˚ cu˚a ma˚ng thÏ chÊ co˘ ca˘c pha‡n tˆ˚ Òa‡u ÒˆÙÔc khÙ˚i taÔo tˆÙng ˆ˘ng vÙ˘i ca˘c gia˘ trÚ trong {} ca˘c pha‡n tˆ˚ co¯n laÔi seı ÒˆÙÔc khÙ˚i taÔo vÙ˘i gia˘ trÚ =0. indicating repetition unique feature reserve 5. Tham so· cu˚a ha¯m la¯ ma˚ng: Khi mo‰t ma˚ng ÒˆÙÔc truye‡n cho mo‰t ha¯m tho‚ng qua tham so·, thÏ ÒÚa chÊ baÈt Òa‡u cu˚a vu¯ng nhÙ˘ da¯nh cho ma˚ng seı ÒˆÙÔc truye‡n cho tham so· vÏ va‰y ha¯m ÒˆÙÔc goÔi seı ta˘c Òo‰ng trˆÔc tie·p le‚n vu¯ng nhÙ˘ cu˚a ma˚ng truye‡n cho no˘. VÌ duÔ 3: #include #include #include #include const int SIZE=5; void input(int arr[SIZE]); void main() { int i,a[SIZE]; clrscr(); randomize(); input(a); cout <<"\n Mang da nhap \n"; for (i=0; i<SIZE; i++) cout <<setw(3)<<a[i]; getch(); return; } void input(int arr[SIZE]) { int i; for (i=0; i<SIZE; i++) arr[i]=random(100); } Trong chˆÙng trÏnh na¯y ta tha·y SIZE ÒˆÙÔc khai ba˘o be‚n ngoa¯i ha¯m va¯ Ù˚ tre‚n ca˘c ha¯m co˘ trong chˆÙng trÏnh do va‰y no˘ co˘ phaÔm vi sˆ˚ duÔng trong ta·t ca˚ ca˘c ha¯m. Trong ha¯m main() co˘ khai ba˘o ma˚ng a va¯ khi no˘ goÔi ha¯m input thÏ truye‡n ma˚ng a cho ha¯m na¯y. Trong thÙ¯i gian ha¯m input thˆÔc hie‰n no˘ seı ta˘c Òo‰ng trˆÔc tie·p le‚n vu¯ng nhÙ˘ da¯nh cho ma˚ng a cu˚a ha¯m main, tho‚ng qua te‚n arr. Ta co˘ hÏnh minh hoÔa sau: const int SIZE=5 void main() { int a[SIZE] m a˚ng ÒˆÙÔc taÔo . Trang 69 input(a) . } void input(int arr[SIZE])
70. Ph
    ng Pháp Lp Trình Qua chˆÙng trÏnh tre‚n ta tha·y cu˘ pha˘p khai ba˘o tham so· kieÂu ma˚ng trong mo‰t ha¯m nhˆ sau: Khai ba˘o prototype : void input(int arr[SIZE]); Khai ba˘o do¯ng tie‚u Òe‡: void input(int arr[SIZE]) Nhˆ va‰y ta tha·y ca˘ch khai ba˘o tham so· la¯ ma˚ng trong prototype va¯ do¯ng tie‚u Òe‡ ha¯m la¯ gio·ng nhau. Trong pha‡n khai ba˘o tre‚n co˘ the vaÈng maÎt gia˘ trÚ cho bie·t so· pha‡n tˆ˚ cu˚a ma˚ng trong caÎp da·u ngoaÎc [] va¯ Òˆa gia˘ trÚ na¯y ra ngoa¯i nhˆ la¯ mo‰t tham so· nghÛa la¯: void input(int arr[], int n)// n seı nha‰n gia˘ trÚ cho bie·t so· pha‡n tˆ˚ cu˚a ma˚ng khi ha¯m ÒˆÙÔc goÔi. Ca˘ch khai ba˘o na¯y co˘ lÙÔi la¯ no˘ cho phe˘p truye‚n mo‰t ma˚ng ba·t ky¯ (kho‚ng bÚ giÙ˘i haÔn bÙ˚i so· pha‡n tˆ˚ cu˚a ma˚ng). ChˆÙng trÏnh tre‚n co˘ the vie·t laÔi nhˆ sau: VÌ duÔ 4: #include #include #include #include void input(int arr[],int); void main() { const int SIZE=5; int i,a[SIZE]; Trang 70
71. Ph
    ng Pháp Lp Trình clrscr(); randomize(); input(a,SIZE); cout <<"\n Mang da nhap \n"; for (i=0; i<SIZE; i++) cout <<setw(3)<<a[i]; getch(); return; } void input(int arr[],int n) { int i; for (i=0; i<n; i++) arr[i]=random(100); } Haıy vie·t laÔi chˆÙng trÏnh tre‚n vÙ˘i ye‚u ca‡u: Co‚ng vie‰c xua·t ma˚ng ÒˆÙÔc thˆÔc hie‰n bÙ˚i mo‰t ha¯m, va¯ ha¯m na¯y ÒˆÙÔc goÔi bÙ˚i ha¯m main. II. Ma˚ng hai chie‡u (one dim ensional array): Mo‰t ma˚ng hai chie‡u la¯ mo‰t ba˚ng ma¯ trong Òo˘ co˘ nhie‡u pha‡n tˆ˚, mo„i pha‡n tˆ˚ seı thuo‰c mo‰t co‰t , mo‰t do¯ng na¯o Òo˘. VÌ duÔ: Co‰t 0 1 2 3 Do¯ng 0 8 16 9 92 1 1 15 4 3 2 12 17 6 2 Cu˘ pha˘p Òe khai bie·n ma˚ng 2 chie‡u nhˆ sau: data_type array_name [number of rows][number of columns]; VÌ duÔ: int arr[3][4]; —e truy xua·t Òe·n mo‰t pha‡n tˆ˚ cu˚a ma˚ng ta theo cu˘ pha˘p sau: array_name[row][col]. Trang 71
72. Ph
    ng Pháp Lp Trình aia˚ sˆ˚ ma˚ng arr co˘ gia˘ trÚ nhˆ ba˚ng tre‚n thÏ: arr[0][0] co˘ gia˘ trÚ la¯ 0 arr[2][0] co˘ gia˘ trÚ la¯ 12 arr[0][3] co˘ gia˘ trÚ la¯ 92. - Cuıng nhˆ ma˚ng mo‰t chie‡u ma˚ng hai chie‡u cuıng co˘ the khÙ˚i taÔo khi khai ba˘o. VÌ duÔ: int val[2][3]= r 1,3,5,4,7,6st L;. y˘: Mo‰t ma˚ng hai chie‡u xem thÏ xem nhˆ co˘ m ma˚ng mo‰t chie‡u ghe˘p laÔi, mo„i ma˚ng mo‰t chie‡u co˘ n pha‡n tˆ˚. VÏ va‰y vie‰c khÙ˚i taÔo gia˘ trÚ cho ma˚ng hai chie‡u ÒˆÙÔc thˆÔc hie‰n theo theo tˆ¯ng do¯ng tˆ¯ tre‚n xuo·ng dˆÙ˘i. Ta·t ca˚ ca˘c ca˘c gia˘ trÚ khÙ˚i taÔo ÒˆÙÔc ÒaÎt trong {}, VÙ˘i ca˘ch khÙ˚i taÔo ma˚ng val nhˆ tre‚n thÏ gia˘ trÚ ca˘c pha‡n tˆ˚ la¯: val[0][0]=1, val[0][1]=3, val[0][2]=5 val[1][0]=4, val[1][1]=7, val[1][2]=6 Vie‰c nha‰p xua·t ma˚ng hai chie‡u nhÙ¯ hai ca·u tru˘c laÎp lo‡ng va¯o nhau. VÌ du 5Ô: chˆÙng trÏnh sau nha‰p va¯ in m o‰t m aıng hai chie‡u le‚n m a¯n hÏnh. #include #include #include #include void main() { const int ROW S=5; const int COLS=5; int i,j,a[ROW S][COLS]; clrscr(); randomize(); for (i=0; i<n; i++) for (j=0;j<COLS;j++) a[i][j]=random(100); cout <<"\n Mang da nhap \n"; for (i=0; i<ROW S; i++) {for(j=0;j<COLS;j++) cout <<setw(5)<<a[i][j]; cout<<endl; } getch(); return; Trang 72
73. Ph
    ng Pháp Lp Trình } + Tham so· cu˚a ha¯m la¯ ma˚ng hai chie‡u: Nguye‚n ta·c truye‡n va¯ nha‰n dˆı lie‰u giˆıa ha¯m goÔi va¯ ha¯m ÒˆÙÔc goÔi cho ma˚ng hai chie‡u cuıng gio·ng nhˆ ha¯m mo‰t chie‡u nghÛa la¯ ha¯m ÒˆÙÔc goÔi seı ta˘c Òo‰ng trˆÔc tie·p le‚n ma˚ng truye‡n cho no˘. Tuy nhie‚n vie‰c khai ba˘o co˘ kha˘c nhau. VÌ duÔ 6: chˆÙng trÏnh sau nha‰p va¯ in m o‰t m aıng hai chie‡u le‚n m a¯n hÏnh. Vie‰c nha‰p va¯ xua·t m a˚ng ÒˆÙÔc thˆÔc hie‰n bÙ˚i hai ha¯m input va¯ output #include #include #include #include const int COLS=5; const int ROW S=5; void input(int a[][COLS],int); void output(int a[][COLS],int); void main() { int i,j,a[ROW S][COLS]; clrscr(); randomize(); input(a,ROW S); cout <<"\n Mang da nhap \n"; output(a,ROW S) getch(); return; } void input(int a[][COLS],int n) { int i,j; for (i=0; i<n; i++) for (j=0;j<COLS;j++) a[i][j]=random(100); } void output(int a[][COLS],int n) { int i,j; for (i=0; i<n; i++) {for(j=0;j<COLS;j++) Trang 73
74. Ph
    ng Pháp Lp Trình cout #include #include #include const int ROW S=5; const int COLS=5; void input(int a[][COLS],int); void output(int a[][COLS],int); Trang 74
75. Ph
    ng Pháp Lp Trình oid sort(int a[ROW S][COLS]); void main() { int i,j,a[ROW S][COLS]; clrscr(); randomize(); input(a,ROW S); cout b[j]) { tam=b[i]; b[i]=b[j]; b[j]=tam; } for (i=0;i<ROW S;i++) for(j=0;j<COLS;j++) a[i][j]=b[j+i*COLS]; return; } IV. Ca˘c lo„i thˆÙ¯ng gaÎp: 1. Que‚n khai ba˘o ma˚ng trˆÙ˘c khi du¯ng Trang 75
76. Ph
    ng Pháp Lp Trình 2. Truy xua·t Òe·n mo‰t pha‡n tˆ˚ ma¯ kho‚ng to‡n taÔi trong ma˚ng (chÊ so· vuÙÔt qua phaÔm vi cu˚a ma˚ng). Lo„i na¯y kho‚ng bÚ trÏnh bie‚n dÚch pha˘t hie‰n nhˆng no˘ co˘ the ga‚y ra nhˆıng nha‡m la„n trong chˆÙng trÏnh ra·t tai haÔi. 3. Que‚n khÙ˚i taÔo gia˘ trÚ phu¯ hÙÔp cho ma˚ng trˆÙ˘c khi du¯ng. BAÿI 9: CON TRO¤ (POINTERS) I. —Úa chÊ va¯ con tro˚ (addresses and pointers): Mo„i mo‰t bie·n sˆ˚ duÔng trong chˆÙng trÏnh thÏ co˘ 3 chi te·t lie‚n quan quan vÙ˘i no˘. + KieÂu dˆı lie‰u cu˚a no˘ + Gia˘ trÚ lˆu trong bie·n + —Úa chÊ lˆu trˆı cu˚a bie·n trong bo‰ nhÙ˘. Trong ha‡u he·t ca˘c chˆÙng trÏnh vie‰c sˆ˚ duÔng bie·n la¯ cho chˆÙng trÏnh de„ hieÂu bÙ˚i te‚n cu˚a no˘ no˘i le‚n y˘ nghÛa sˆ˚ duÔng cu˚a no˘ trong chˆÙng trÏnh. Mo„i te‚n bie·n nhˆ va‰y seı tˆÙ˘ng ˆ˘ng vÙ˘i mo‰t vÚ trÌ na¯o Òo˘ trong o‚ nhÙ˘, va¯ vie‰c xa˘c ÒÌnh sˆÔ tˆÙng ˆ˘ng na¯y seı do trÏnh bie‚n dÚch va¯ ma˘y tÌnh hoa¯n ta·t mo„i khi chˆÙng trÏnh ÒˆÙÔc thˆÔc hie‰n. VÌ duÔ 1: #include #include void main() { int num; num=22; Trang 76
77. Ph
    ng Pháp Lp Trình cout <<"Gia tri luu trong bien num la: "<<num<<endl <<"So byte trong bo nho danh cho bien nay la: "<<sizeof(num)<<endl <<"Dia chi cua o nho danh cho bien num la: "<<# getch(); return; } Phe˘p & trong chˆÙng trÏnh tre‚n la¯ Òe la·y ÒÚa chÊ cu˚a mo‰t bie·n hay co¯n goÔi la¯ tham chie‡u tÙ˘i bie·n. ChˆÙng trÏnh tre‚n khi thˆÔc hie‰n seı in le‚n ma¯n hÏnh: Gia trÚ lˆu trong bie·n num la: 22 So· byte trong bo‰ nhÙ˘ da¯nh cho bie·n na¯y la¯: 2 —Úa chi cu˚a o‚ nhÙ˘ da¯nh cho bie·n num la: 0xfff4 —e hieÂu ro˚ hÙn ve‡ ca˘c no‰i dung Òaı xua·t trong chˆÙng trÏnh tre‚n ta haıy xem hÏnh minh hoÔa sau: vu¯ng 2 byte da¯nh cho bie·n num . O¬ 22 Mo‰t pha‡n bo‰ nhÙ˘ Òa‡u cu˚a nhÙ˘ RAM vu¯ng nhÙ˘ na¯y co˘ ÒÚa chÊ 0xfff4 —Úa chÊ cu˚a bie·n num co˘ th e thay Òo·i khi thˆÔc hie‰n tre‚n ma˘y tÌnh kha˘c hoaÎc Ù˚ nhˆıng la‡n thˆÔc hie‰n sau Òo˘. - Lˆu giˆı ÒÚ chÊ: Be‚n caÔnh vie‰c hieÂn thÚ ÒÚa chÊ cu˚a bie·n, chu˘ng ta cuıng co˘ the lˆu trˆı ÒT chÊ cu˚a mo‰t bie·n va¯o mo‰t bie·n Òaı ÒˆÙÔc khai ba˘o phu¯ hÙÔp vÌ duÔ nhˆ: numaddr= # //lˆu ÒÚa chÊ bie·n num va¯o bie·n numaddr d= &m; //lˆu ÒÚa chÊ bie·n m va¯o bie·n d chrpoint= &ch; //lˆu ÒÚa chÊ bie·n ch va¯o bie·n chrpoint Ca˘c bie·n numaddr, d, chrpoint ÒˆÙÔc goÔi la¯ bie·n con tro˚. Bie·n loaÔi na¯y du¯ng Òe lˆu ÒÚa chÊ cu˚a mo‰t vu¯ng nhÙ˘ hoaÎc ÒÚa chÊ bie·n na¯o Òo˘. Bie·n No‰i dung num addr ÒÚa chÊ bie·n num d ÒÚa chÊ cu˚a bie·n m chrpoint ÒÚa chÊ cu˚a bie·n ch - Sˆ3 duÔng ÒÚa chÊ: Òe sˆ˚ duÔng ca˘c ÒÚa chÊ Òaı lˆu va¯o bie·n (nhˆ ga˘n gia˘ trÚ va¯o vu¯ng nhÙ˘ ma¯ bie·n Òang tro˚ tÙ˘i, hoaÎc la·y gia˘ trÚ Òang lˆu trong vu¯ng nhÙ˘ na¯y). C++ cung ca·p toa˘n tˆ˚ *. Ne·u toa˘n tˆ˚ na¯y Òi trˆÙ˘c mo‰t te‚n bie·n con tro˚ vÌ duÔ Trang 77
78. Ph
    ng Pháp Lp Trình Dnhˆ *numaddr, *chrpoint) co˘ nghÛa la¯ no˘i Òe·n gia˘ trÚ Òang lˆu taÔi vu¯ng nhÙ˘ co˘ ÒÚa chÊ Òang lˆu trong bie·n con tro˚. VÌ duÔ gia˚ sˆ˚ ta co˘ mo‰t bie·n con tro˚ y. gia˘ trÚ cu˚a bie·n hie‰n la¯ 0xFFAA (ÒÚa chÊ cu˚a o‚ nhÙ˘ thˆ˘ FFAA trong RAM) gia˘ trÚ Òang lˆu trˆı taÔi o‚ nhÙ˘ na¯y la¯ 100, thÏ ta co˘ hÏnh minh hoÔa bo‰ nhÙ˘ nhˆ sau: Vu˘ng nhÙ˘ da¯nh cho bie·n y FFAA Mo‰t pha‡n bo‰ vu¯ng nhÙ˘ 2 byte nhÙ˘ RAM co˘ ÒÚa chÊ 100 0xFFAA nhˆ va‰y ta co˘: gia˘ trÚ cu˚a y la¯ 0xFFAA gia˘ trÚ cu˚a *y la¯ 100 (gia˘ trÚ lˆu taÔi vu¯ng nhÙ˘ 0xFFAA), Òa‚y la¯ mo‰t ca˘ch la·y gia˘ trÚ gia˘n tie·p, theo ca˘ch na¯y ma˘y tÌnh pha˚i do¯ Òe·n hai ÒÚa chÊ thÏ mÙ˘i nha‰n ÒˆÙÔc gia˘ trÚ 100.(Òa‡u tie‚n do¯ Òe·n ÒÚa chÊ chˆ˘a trong y, sau Òo˘ tˆ¯ ÒÚa chÊ na¯y mÙ˘i do¯ Òe·n o‚ nhÙ˘ co˘ ÒÚa chÊ tˆÙng ˆ˘ng Òe nha‰n ÒÚa chÊ. Ca‚u ho˚i ÒaÎt ra: Pha˚i bo˚ co‚ng nhˆ va‰y, tai sao chu˘ng ta laÔi pha˚i sˆ˚ duÔng con tro˚. Ne‡n ta˚ng tra˚ lÙ¯i cho ca‚u na¯y la¯ dˆÔa tre‚n mo·i quan he‰ ma‰t thie·t giˆıa con tro˚ ma˚ng, cuıng nhˆ vie‰c sˆ˚ duÔng con tro˚ Òe taÔo va¯ xo˘a ca˘c bie·n Òo‰ng khi chˆÙng trÏnh Òang thˆÔc hie‰n. Khai ba˘o con tro˚: Cuıng nhˆ ta·t ca˚ ca˘c bie·n kha˘c, bie·n con tro˚ pha˚i ÒˆÙÔc khai ba˘o trˆÙ˘c khi chu˘ng ÒˆÙÔc sˆ˚ duÔng Òe lˆu ca˘c ÒÚa chÊ. Khi khai ba˘o bie·n con tro˚ chu˘ng ta pha˚i cho bie·t con tro˚ na¯y seı lˆu ÒÚa chÊ cu˚a vu¯ng nhÙ˘ lˆu loaÔi dˆı lie‰u na¯o. VÏ va‰y cu˘ pha˘p Òe khai ba˘o bie·n con tro˚ nhˆ sau: datatype *pointer name; VÌ duÔ: int *numaddr; char *chrpoint; Khai ba˘o int *numaddr chÊ ra hai Òie‡u: trˆÙ˘c he·t nummaddr la¯ mo‰t bie·n con tro˚, thˆ˘ hai la¯ vu¯ng nhÙ˘ ÒˆÙÔc lˆu trong numaddr pha˚i la¯ vu¯ng nhÙ˘ lˆu trˆı mo‰t so· nguye‚n kieÂu int (hay bie·n ma¯ numaddr tro˚ Òe·n pha˚i la¯ mo‰t bie·n kieÂu int), VÌ duÔ 2: #include #include void main() { int *addr; int n=158,m=22; clrscr(); Trang 78
79. Ph
    ng Pháp Lp Trình addr=&n; cout <<"Dia chi luu trong addr hien gio la: "<<addr<<endl //0xfff4 <<"Gia tri luu tai vung nho co dia chi chua trong addr : " <<*addr<<endl; //158 addr=&m; cout <<"Dia chi luu trong addr hien gio la: "<<addr<<endl //0xfff2 <<"Gia tri luu tai vung nho co dia chi chua trong addr : " <<*addr<<endl; //22 getch(); return; } Mo‰t bie·n con tro˚ co˘ kÌch thˆÙ˘c hai byte va¯ phuÔ thuo‰c va¯o khai ba˘o ban Òa‡u no˘ seı chˆ˘a ÒÚa chÊ cu˚a vu¯ng nhÙ˘ 1byte ,2 byte ,4byteÖ Trong thˆÔc te· du¯ la¯ con tro˚ kieÂu char, int , float, hay double thÏ con tro˚ cuıng chÊ chˆ˘a o‚ nhÙ˘ Òa‡u tie‚n cu˚a vu¯ng nhÙ˘ ma¯ no˘ chÊ tÙ˘i, nhˆng nhÙ¯ va¯o sˆÔ khai ba˘o na¯y ma˘y tÌnh seı bie·t ca‡n pha˚i la·y bao nhie‚u o‚ nhÙ˘ khi truy xua·t tÙ˘i con tro˚ na¯y. Ta xem hÏnh minh hoÔa sau: 0xff00 Con tro˚ 0xff00 kieÂu char 0xff01 Con tro˚ 0xff01 kieÂu int 0xff03 con tro˚ 0xff03 kieÂu float - Bie·n tham chie·u va¯ bie·n con tro˚: Bie·n tham chie·u la¯ mo‰t bie·n khi khai ba˘o co˘ the‚m da·u & phÌa trˆÙ˘c. Bie·n na¯y cuıng la¯ mo‰t loaÔi con tro˚ nhˆng co˘ nhie‡u haÔn che· so vÙ˘i con tro˚. + Bie·n tham chie·u du¯ng Òe tham chie·u tÙ˘i ÒÚa chÊ cu˚a mo‰t bie·n va¯ chÊ mo‰t ma¯ tho‚i (—Úa chÊ lˆu trong bie·n tham chie·u kho‚ng the thay ÒoÂi ÒˆÙÔc). + —Úa chÊ ma¯ bie·n na¯y tham chie·u tÙ˘i pha˚i ÒˆÙÔc khÙ˚i taÔo ngay taÔi thÙ¯i ÒieÂm khai ba˘o ngay tˆ¯ Òa‡u Trang 79
80. Ph
    ng Pháp Lp Trình + Sau khi Òaı tham kha˚o tÙ˘i mo‰t bie·n thÏ vie‰c sˆ˚ duÔng bie·n tham chie·u gio·ng nhˆ mo‰t bie·n tho‚ng thˆÙ¯ng va¯ nhˆıng le‰nh ta˘c Òo‰ng le‚n bie·n tham chie·u na¯y seı a˚nh hˆÙ˚ng tÙ˘i bie·n ma¯ no˘ tham chie·u tÙ˘i. VÌ duÔ 3: #include #include void main() { int n=158, &x=n; clrscr(); cout <<"Gia tri trong vung nho ma x tham chieu toi"<<x; //158 x=100; cout <<"\nGia tri cua n hien tai la: "<<n; //100 getch(); return; } Trong vÌ duÔ tre‚n ta tha·y bie·n ÒÚa chÊ chˆ˘ trong con tro˚ addr co˘ the thay ÒoÂi ÒˆÙÔc, co¯n trong vÌ duÔ na¯y bie·n tham chie·u x thÏ chÊ tham chie·u tÙ˘i bie·n n ma¯ tho‚i. VÙ˘i bie·n tham chie·u x sau khi Òaı khÙ˚i taÔo ta chÊ co˘ the truy xua·t Òe·n gia˘ trÚ lˆu taÔi vu¯ng nhÙ˘ ma¯ no˘ tham chie·u tÙ˘i va¯ trong trˆÙ¯ng hÙÔp na¯y ta cuıng kho‚ng ca‡n ghi da·u * be‚n caÔnh te‚n bie·n II. Te‚n m a˚ng la¯ con tro˚: Giˆıa te‚n ma˚ng va¯ con tro˚ co˘ mo·i quan ma‰t thie·t vÙ˘i nhau. Trong pha‡n na¯y chu˘ng ta seı tÏm hieÂu chi tie·t mo·i quan he‰ Òo˘. Trong ba¯i trˆÙ˘c chu˘ng ta Òaı sˆ˚ duÔng chÊ so· Òe truy xua·t tÙ˘i mo‰t pha‡n tˆ˚ cu˚a ma˚ng. vÌ duÔ nhˆ khi ta ghi grade[3] nghÛa la¯ truy xua·t tÙ˘i pha‡n tˆ˚ thˆ˘ tˆ trong ma˚ng grade. Vie‰c sˆ˚ duÔng chÊ so· Òe truy xua·t ma˚ng seı la¯m cho ngˆÙ¯i vie·t chˆÙng trÏnh ca˚m tha·y bÙ˚i no˘ Òaı che Òa‰y vie‰c sˆ˚ duÔng ÒÚa chÊ be‚n trong ma˘y tÌnh. Khi ta sˆ˚ duÔng chÊ so· thÌ ma˘y tÌnh seı dˆÔa va¯o chÊ so· na¯y va¯ ÒÚa chÊ baÈt Òa‡u cu˚a vu¯ng nhÙ˘ da¯nh cho ma˚ng Òe xa˘c ÒÚnh ÒÚa chÊ cu˚a pha‡n tˆ˚ ma¯ ta muo·n truy xua·t tÙ˘i, VÌ duÔ Òe truy xua·t pha‡n tˆ˚ grade[3](gia˚ sˆ˚ grade la¯ mo‰t ma˚ng so· nguye‚n) thÏ ma˘y tÌnh seı xa˘c ÒÚnh ÒÚa chÊ cu˚a pha‡n tˆ˚ na¯y nhˆ sau: &grade[3]= &grade[0] + (3*2) gia˚ sˆ˚ kieÂu int chie·m 2 byte trong bo‰ nhÙ˘. grade[0] grade[1] grade[2] grade[3] grade[4] (2 byte) (2 byte) (2 byte) (2 byte) (2 byte) Trang 80 4grade[0] &grade[0] +(3*2)
81. Ph
    ng Pháp Lp Trình Theo ca˘ch tre‚n ta cuıng co˘ the du¯ng mo‰t con tro˚ lˆu ÒÚa chÊ baÈt Òa‡u cu˚a mo‰t ma˚ng sau Òo˘ baÈt chˆÙ˘c ca˘ch la¯m cu˚a ma˘y Òe truy xua·t Òe·n mo‰t pha‡n tˆ˚ cu˚a ma˚ng. Ta haıy xem xe˘t chˆÙng trÏnh sau: VÌ duÔ 4: #include #include void main() { const int SIZE=5; int i, *addr, grade[SIZE]={98,87,76,65,54}; clrscr(); addr=&grade[0]; for (i=0;i<SIZE;i++) cout<<grade[i]<<" "; (a) cout <<endl; for (i=0;i<SIZE;i++) cout<<*(addr+i)<<" "; (b) getch(); return; } Trong chˆÙng trÏnh tre‚n ca˚ hai ÒoaÔn le‰nh (a) va¯ (b) Òe‡u co˘ co‚ng duÔng in ca˘c gia˘ trÚ cu˚a ma˚ng le‚n ma¯n hÏnh. Trong Òo˘ ta lˆu y˘ ÒoaÔn le‰nh (b): ‘¤ Òa‡u chˆÙng trÏnh vÙ˘i le‰nh addr=&grade[0] thÏ ÒÚa chÊ baÈt Òa‡u cu˚a ma˚ng ÒˆÙÔc ga˘n va¯o con tro˚ addr. Khi Òo˘ (addr+i) seı lˆu ÒÚa chÊ cu˚a pha‡n tˆ˚ thˆ˘ i trong ma˚ng va¯ *(addr+i) la¯ gia˘ trÚ cu˚a pha‡n tˆ˚ thˆ˘ i trong ma˚ng. Ta co˘ xem ba˚ng y˘ nghÛa giˆıa ca˘c hÏnh thˆ˘c truy xua·t tre‚n: Pha‡n tˆ˚ —Úa chi cu˚a pha‡n tˆ˚ thˆ˘ i Gia˘ trÚ cu˚a pha‡n tˆ˚ thˆ˘ i Trang 81
82. Ph
    ng Pháp Lp Trình thˆ˘ i cu˚a Sˆ˚ duÔng toa˘n Sˆ˚ duÔng con Sˆ˚ duÔng chÊ Sˆ˚ duÔng con ma˚ng tˆ˚ tro˚ addr so· tro˚ grade grade tham chie·u & 0 &grade[0] addr grade[0] *(addr) 1 &grade[1] addr+1 grade[1] *(addr+1) 2 &grade[2] addr+2 grade[2] *(addr+2) 3 &grade[3] addr+3 grade[3] *(addr+3) 4 &grade[4] addr+4 grade[4] *(addr+4) Lˆu y˘ raËng *(addr+3) hoa¯n toa¯n co˘ y˘ nghÛa kha˘c vÙ˘i *addr+3. *(addr+3)= gia˘ trÚ pha‡n tˆ˚ grade[3] *addr+3= gia˘ trÚ cu˚a pha‡n tˆ˚ grade[0]+3 Qua chˆÙng trÏnh tre‚n ta tha·y hoa¯n toa¯n co˘ the truy xua·t ma˚ng tho‚ng qua mo‰t con tro˚. Tuy nhie‚n vie‰c khai ba˘o con tro˚ addr Òe sˆ˚ duÔng trong vie‰c na¯y tha‰t sˆÔ kho‚ng ca‡n thie·t, bÙ,i no˘ co˘ the ҈ÙÔc thay the· bÙ˚i te‚n ma˚ng grade. Trong C++ khi ta khai ba˘o mo‰t ma˚ng thÏ te‚n cu˚a ma˚ng seı chˆ˘a ÒÚa chÊ khÙ˚i Òa‡u cu˚a ma˚ng Òo˘ va¯ ta kho‚ng the thay ÒoÂi ÒÚa chÊ chˆ˘a trong te‚n ma˚ng na¯y vÏ va‰y te‚n ma˚ng ÒˆÙÔc goÔi la¯ mo‰t haËng con tro˚. Nhˆ the· ÒoaÔn le‰nh (b) cu˚a chˆÙng trÏnh tre‚n ÒˆÙÔc vie·t laÔi nhˆ sau: VÌ duÔ 5: #include #include void main() { const int SIZE=5; int i, grade[SIZE]={98,87,76,65,54}; clrscr(); for (i=0;i<SIZE;i++) cout<<grade[i]<<" "; (a) cout <<endl; for (i=0;i<SIZE;i++) cout<<*(grade+i)<<" "; (b) getch(); return; } III. Phe˘p toa˘n so· hoÔc tre‚n con tro˚: Gia˘ trÚ lˆu trong bie·n con tro˚ la¯ mo‰t ÒÚa chÊ, vÏ va‰y khi ta thˆÔc hie‰n phe˘p co‰ng hoaÎc trˆ¯ tre‚n mo‰t bie·n con tro˚ ta seı nha‰n ÒˆÙÔc mo‰t ÒÚa chÊ kha˘c trong bie·n con tro˚ na¯y. Trang 82
83. Ph
    ng Pháp Lp Trình F.
    duÔ: co khai ba˘o sau int nums[100]; int *point; point=&nums[0]; // Ílu˘c na¯y gia˘ trÚ cu˚a point la¯ ÒÚa chÊ cu˚a pha‡n tˆ˚ nums[0] HoaÎc point=num; Ne·u co˘ le‰nh ga˘n point=point+2; thÏ lu˘c na¯y gia˘ trÚ cu˚a point la¯ ÒÚa chÊ cu˚a pha‡n tˆ˚ nums[2] (gia˘ trÚ trong con tro˚ point Òaı thay ÒoÂi). Khi ta co‰ng hoaÎc trˆ¯ mo‰t gia˘ trÚ tre‚n bie·n con tro˚ thÏ gia˘ trÚ na¯y pha˚i la¯ haËng, bie·n hoaÎc bieÂu thˆ˘c co˘ gia˘ trÚ kieÂu so· nguye‚n, va¯ pha˚i chaÈc raËng sau khi co‰ng hoaÎc trˆ¯ thÏ gia˘ trÚ cu˚a bie·n con tro˚ va„n tro˚ tÙ˘i mo‰t ÒÚa chÊ co˘ nghÛa. VÌ duÔ ne·u ta co˘ le‰nh point=point+200, le‰nh na¯y la¯m thay ÒoÂi gia˘ trÚ trong point va¯ ÒÚa chÊ mÙ˘i la¯ mo‰t ÒÚa chÊ kho‚ng co˘ nghÛa Òo‚i vÙ˘i ma˚ng nums. Ta cuıng co˘ the a˘p duÔng ca˘c phe˘p toa˘n taÍng/gia˚m (++/ )mo‰t ngo‚i tre‚n bie·n con tro˚. Haıy xem xe˘t vÌ duÔ sau: VÌ duÔ 6: #include #include void main() { const int SIZE=5; int i, *point, grade[SIZE]={98,87,76,65,54}; clrscr(); point=&grade[0]; // point=grade for (i=0;i<SIZE;i++) cout<<*(grade+i)<<" "; (a) cout<<endl; for (i=0;i<SIZE;i++) cout<<*(point+i)<<" "; (b) cout<<endl; for (i=0;i<SIZE;i++) cout<<*(point)++<<" "; (c) Trang 83
84. Ph
    ng Pháp Lp Trình getch(); return; } Ca˚ 3 ÒoaÔn le‰nh (a), (b), (c) Òe‡u co˘ co‚ng duÔng in gia˘ trÚ ca˘c pha‡n tˆ˚ trong ma˚ng grade. —oa‰n le‰nh (a) ta Òaı gaÎp Ù˚ vÌ duÔ trˆÙ˘c, Lˆu y˘ la¯ ca˘ch ghi *(point+i) kho‚ng la¯m thay Òo·i gia˘ trÚ trong point co¯n ca˘ch ghi *point++ thÏ la¯m thay ÒoÂi gia˘ trÚ cu˚a point sau mo„i la‡n thˆÔc hie‰n. Ca‚u ho˚i: - Ne·u ÒaÎt ÒoaÔn le‰nh (c) le‚n tre‚n cu¯ng thÏ ke·t qua˚ co˘ gio·ng nhˆ trˆÙ˘c Òo˘ kho‚ng. - Vie·t ÒoaÔn chˆÙng trÏnh tÌnh toÂng cu˚a ma˚ng grade baËng 3 ca˘ch: sˆ˚ duÔng chÊ so·, sˆ˚ duÔng con tro˚ nhˆng kho‚ng la¯m thay ÒoÂi gaÌ trÚ trong con tro˚, sˆ˚ duÔng con tro˚ vÙ˘i ca˘c phe˘p toa˘n mo‰t ngo‚i. Vie‰c sˆ˚ duÔng con tro˚ Òe truy xua·t ma˚ng co˘ the kho˘ hÙn du¯ng chÊ so· tuy nhie‚n trong mo‰t so· trˆÙ¯ng hÙÔp ne·u bie·t sˆ˚ duÔng con tro˚ seı ra·t hie‰u qua˚, cha˙ng haÔn trong ba¯i toa˘n saÈp xe·p ma˚ng hai chie‡u. Chu˘ng haıy xem xe˘t chˆÙng trÏnh sau: VÌ duÔ 7: #include #include #include #include const int ROW S=5; const int COLS=5; void input(int a[][COLS],int); void output(int a[][COLS],int); void sort(int a[ROW S][COLS]); void main() { int i,j,a[ROW S][COLS]; clrscr(); randomize(); input(a,ROW S); cout <<"\n Mang da nhap \n"; output(a,ROW S); sort(a); Trang 84