Giáo trình Phương pháp lập trình
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
Chươngꢀ1ꢀ
ꢀ
TꢁNGꢀQUANꢀVꢂꢀNGÔNꢀNGꢃꢀLꢄPꢀTRÌNHꢀC/C++ꢀ
1.ꢀLꢅchꢀsꢆꢀcꢇaꢀngônꢀngꢈꢀlꢉpꢀtrìnhꢀC/C++ꢀ
CꢀñưꢁcꢀtꢂoꢀbꢃiꢀDennisꢀRitchieꢀꢃꢀBellꢀTelephoneꢀLaboratoriesꢀvàoꢀ
nămꢀ1972ꢀñꢄꢀchoꢀphépꢀlꢅpꢀtrìnhꢀviênꢀphátꢀtriꢄnꢀcácꢀꢆngꢀdꢇngꢀhiꢈuꢀ
quꢉꢀhơnꢀcácꢀngônꢀngꢊꢀlꢅpꢀtrìnhꢀhiꢈnꢀcóꢀtꢂiꢀthꢋiꢀñiꢄmꢀñó.ꢀ
ðiꢄmꢀmꢂnhꢀvàꢀmꢌmꢀdꢍoꢀcꢎaꢀCꢀchoꢀphépꢀcácꢀnhàꢀphátꢀtriꢄnꢀꢃꢀBellꢀ
LabsꢀtꢂoꢀnênꢀcácꢀꢆngꢀdꢇngꢀphꢆcꢀtꢂpꢀnhưꢀhꢈꢀñiꢌuꢀhànhꢀUnix.ꢀVàoꢀ
nămꢀ 1983,ꢀ hꢏcꢀ viꢈnꢀ chuꢐnꢀ quꢑcꢀ giaꢀ Mꢒꢀ (Americanꢀ Nationalꢀ
StandardsꢀInstituteꢀꢓꢀANSI)ꢀthànhꢀlꢅpꢀmꢔtꢀtiꢄuꢀbanꢀñꢄꢀchuꢐnꢀhóaꢀCꢀ
ñưꢁcꢀbiꢕtꢀñꢕnꢀnhưꢀANSIꢀStandardꢀC.ꢀNgàyꢀnay,ꢀtꢖtꢀcꢉꢀtrìnhꢀbiênꢀ
dꢗchꢀC/C++ꢀñꢌuꢀtuânꢀtheoꢀANSIꢀStandardꢀC.ꢀC++ꢀñưꢁcꢀxâyꢀdꢘngꢀ
trênꢀnꢌnꢀtꢉngꢀcꢎaꢀANSIꢀStandardꢀC.ꢀ
C++ꢀlàꢀmꢔtꢀngônꢀngꢊꢀlꢅpꢀtrìnhꢀhưꢙngꢀñꢑiꢀtưꢁngꢀmàꢀbaoꢀhàmꢀngônꢀ
ngꢊꢀ Cꢀ ꢃꢀ trongꢀ nó.ꢀ Trongꢀ giáoꢀ trìnhꢀ nàyꢀ chưaꢀ khꢉoꢀ sátꢀ phꢚnꢀ lꢅpꢀ
trìnhꢀhưꢙngꢀñꢑiꢀtưꢁngꢀcꢎaꢀC++.ꢀ
2.ꢀKꢊꢀthuꢉtꢀñꢋꢀgiꢌiꢀquyꢍtꢀmꢎtꢀbàiꢀtoánꢀ
Mꢔtꢀchươngꢀtrìnhꢀmáyꢀtínhꢀñưꢁcꢀthiꢕtꢀkꢕꢀñꢄꢀgiꢉiꢀquyꢕtꢀmꢔtꢀbàiꢀtoánꢀ
nàoꢀñó.ꢀVìꢀvꢅy,ꢀnhꢊngꢀbưꢙcꢀcꢚnꢀñꢄꢀtìmꢀkiꢕmꢀlꢋiꢀgiꢉiꢀchoꢀmꢔtꢀbàiꢀ
toánꢀ cũngꢀ giꢑngꢀ nhưꢀ nhꢊngꢀ bưꢙcꢀ cꢚnꢀ ñꢄꢀ viꢕtꢀ mꢔtꢀ chươngꢀ trình.ꢀ
Cácꢀbưꢙcꢀgꢛm:ꢀ
ꢓ Xácꢀñꢗnhꢀyêuꢀcꢚuꢀcꢎaꢀbàiꢀtoán.ꢀ
ꢓ Nghĩꢀraꢀmꢔtꢀphươngꢀcáchꢀ(algorithm)ꢀñꢄꢀtìmꢀlꢋiꢀgiꢉi.ꢀ
ꢓ Thꢘcꢀhiꢈnꢀphươngꢀcáchꢀñó.ꢀ
ꢓ Kiꢄmꢀtraꢀkꢕtꢀquꢉꢀñꢄꢀxemꢀlꢋiꢀgiꢉiꢀcóꢀñúngꢀvꢙiꢀyêuꢀcꢚuꢀcꢎaꢀbàiꢀ
toán.ꢀ
ꢀ
1/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
KhiꢀviꢕtꢀmꢔtꢀchươngꢀtrìnhꢀtrongꢀC/C++,ꢀñâyꢀlàꢀnhꢊngꢀbưꢙcꢀñưꢁcꢀ
ñꢌꢀnghꢗ:ꢀ
1. Xácꢀñꢗnhꢀmꢇcꢀñíchꢀcꢎaꢀchươngꢀtrìnhꢀ
2. Nghĩꢀraꢀthuꢅtꢀtoánꢀphùꢀhꢁpꢀñꢄꢀgiꢉiꢀquyꢕtꢀbàiꢀtoánꢀ(dùngꢀmãꢀ
giꢉ,ꢀlưuꢀñꢛ,ꢀ...)ꢀ
3. Càiꢀñꢜtꢀ(viꢕt)ꢀthuꢅtꢀtoánꢀdùngꢀngônꢀngꢊꢀlꢅpꢀtrìnhꢀC/C++ꢀ
4. Thꢘcꢀthiꢀchươngꢀtrìnhꢀvàꢀkiꢄmꢀthꢝꢀ(testing).ꢀ
3.ꢀCácꢀbưꢏcꢀtrongꢀchuꢀtrìnhꢀphátꢀtriꢋnꢀchươngꢀtrìnhꢀ
Chuꢀtrìnhꢀphátꢀtriꢄnꢀchươngꢀtrìnhꢀ(programꢀdevelopmentꢀcycle)ꢀcóꢀ
nhꢊngꢀbưꢙcꢀsauꢀñây.ꢀ1.ꢀMꢔtꢀtrìnhꢀsoꢂnꢀthꢉoꢀvănꢀbꢉnꢀñưꢁcꢀdùngꢀñꢄꢀ
nhꢅpꢀ mãꢀ nguꢛnꢀ (sourceꢀ code).ꢀ 2.ꢀ Mãꢀ nguꢛnꢀ ñưꢁcꢀ biênꢀ dꢗchꢀ
(compile)ꢀñꢄꢀtꢂoꢀnênꢀtꢅpꢀtinꢀñꢑiꢀtưꢁngꢀ(objectꢀfile).ꢀ3.ꢀCácꢀtꢅpꢀtinꢀ
ñꢑiꢀ tưꢁngꢀ ñưꢁcꢀ liênꢀ kꢕtꢀ (link)ꢀ ñꢄꢀ tꢂoꢀ nênꢀ tꢅpꢀ tinꢀ cóꢀ thꢄꢀ thꢘcꢀ thiꢀ
(executableꢀfile).ꢀ4.ꢀThꢘcꢀhiꢈnꢀ(run)ꢀchươngꢀtrìnhꢀñꢄꢀchꢞꢀraꢀchươngꢀ
trìnhꢀcóꢀlàmꢀviꢈcꢀñúngꢀnhưꢀñãꢀñꢗnhꢀkhông.ꢀ
ꢀ
Useꢀ
editorꢀ
(Cꢃfree,ꢀBorlandꢀC/C++ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
Sourceꢀ
codeꢀ
(.c;ꢀ.cppꢀfiles)ꢀ
(bc.exe)ꢀ
Compileꢀ
Objectꢀ
codeꢀ
(.hꢀfiles)ꢀ
(.exeꢀfile)ꢀ
Linkꢀ
objectꢀfileꢀ
Executableꢀ
programꢀ
Libraryꢀ
filesꢀ
2/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
ꢀ
3.1.ꢀSoꢐnꢀthꢌoꢀmãꢀnguꢑnꢀ(sourceꢀcodeꢀeditor)ꢀ
Mãꢀnguꢛnꢀlàꢀmꢔtꢀtꢅpꢀcácꢀlꢈnhꢀdùngꢀñꢄꢀchꢞꢀdꢟnꢀmáyꢀtínhꢀthꢘcꢀhiꢈnꢀ
côngꢀviꢈcꢀmongꢀmuꢑn.ꢀTꢅpꢀtinꢀmãꢀnguꢛnꢀñưꢁcꢀlưuꢀtrꢊꢀvꢙiꢀphꢚnꢀ
phânꢀloꢂiꢀ.cꢀ(C)ꢀhoꢜcꢀ.cppꢀ(C++).ꢀ
3.2.ꢀBiênꢀdꢅchꢀ(compile)ꢀ
TꢅpꢀtinꢀmãꢀnguꢛnꢀñưꢁcꢀviꢕtꢀbꢠngꢀnhꢊngꢀtꢡꢀgiꢑngꢀtiꢕngꢀAnhꢀnênꢀdꢢꢀ
dàngꢀñꢄꢀñꢏcꢀvàꢀhiꢄu.ꢀTuyꢀnhiên,ꢀmáyꢀtínhꢀkhôngꢀthꢄꢀhiꢄuꢀnhꢊngꢀtꢡꢀ
này.ꢀMáyꢀtínhꢀyêuꢀcꢚuꢀcácꢀchꢞꢀdꢟnꢀnhꢗꢀphânꢀ(binary)ꢀtrongꢀdꢂngꢀ
thꢆcꢀ cꢎaꢀ ngônꢀ ngꢊꢀ máyꢀ (machineꢀ language).ꢀ Trưꢙcꢀ khiꢀ mꢔtꢀ
chươngꢀtrìnhꢀñưꢁcꢀviꢕtꢀbꢠngꢀngônꢀngꢊꢀcꢖpꢀcaoꢀnhưꢀC/C++ꢀcóꢀthꢄꢀ
thꢘcꢀthiꢀtrênꢀmáyꢀtính,ꢀnóꢀphꢉiꢀñưꢁcꢀbiênꢀdꢗchꢀtꢡꢀmãꢀnguꢛnꢀsangꢀ
mãꢀmáy.ꢀViꢈcꢀdꢗchꢀnàyꢀñưꢁcꢀthꢘcꢀhiꢈnꢀbꢃiꢀmꢔtꢀchươngꢀtrìnhꢀgꢏiꢀlàꢀ
trìnhꢀbiênꢀdꢗchꢀ(compiler).ꢀ
Cácꢀchꢞꢀdꢟnꢀngônꢀngꢊꢀmáyꢀñưꢁcꢀtꢂoꢀbꢃiꢀtrìnhꢀbiênꢀdꢗchꢀñưꢁcꢀgꢏiꢀlàꢀ
mãꢀñꢑiꢀtưꢁngꢀ(objectꢀcode)ꢀvàꢀtꢅpꢀtinꢀchꢆaꢀchúngꢀgꢏiꢀlàꢀtꢅpꢀtinꢀñꢑiꢀ
tưꢁng.ꢀTꢅpꢀtinꢀñꢑiꢀtưꢁngꢀcóꢀcùngꢀtênꢀnhưꢀtꢅpꢀtinꢀmãꢀnguꢛnꢀnhưngꢀ
cóꢀphꢚnꢀphânꢀloꢂiꢀ.obj.ꢀ
3.3.ꢀTꢐoꢀtꢉpꢀtinꢀthꢒcꢀthiꢀ(executableꢀfiles)ꢀ
C/C++ꢀcóꢀmꢔtꢀthưꢀviꢈnꢀhàmꢀchꢆaꢀmãꢀñꢑiꢀtưꢁngꢀchoꢀnhꢊngꢀhàmꢀñãꢀ
ñưꢁcꢀtꢂoꢀsꢣn.ꢀNhꢊngꢀhàmꢀnàyꢀthꢘcꢀhiꢈnꢀcácꢀtácꢀvꢇꢀthưꢋngꢀdùngꢀ
nhưꢀ xóaꢀ mànꢀ hìnhꢀ (clrscr()),ꢀ nhꢅpꢀ mꢔtꢀ chuꢤiꢀ kýꢀ tꢘꢀ tꢡꢀ bànꢀ phímꢀ
(gets()),ꢀtínhꢀcănꢀbꢅcꢀhaiꢀ(sqrt()),ꢀ...ꢀmàꢀchươngꢀtrìnhꢀñưꢁcꢀviꢕtꢀcóꢀ
thꢄꢀsꢝꢀdꢇngꢀmàꢀkhôngꢀphꢉiꢀviꢕtꢀlꢂi.ꢀ
Tꢅpꢀtinꢀñꢑiꢀtưꢁngꢀñưꢁcꢀtꢂoꢀraꢀbꢃiꢀtrìnhꢀbiênꢀdꢗchꢀsꢥꢀkꢕtꢀhꢁpꢀvꢙiꢀmãꢀ
ñꢑiꢀtưꢁngꢀcꢎaꢀcácꢀhàmꢀthưꢀviꢈnꢀñꢄꢀtꢂoꢀnênꢀtꢅpꢀtinꢀthꢘcꢀthi.ꢀQuáꢀ
trìnhꢀ nàyꢀ ñưꢁcꢀ gꢏiꢀ làꢀ liênꢀ kꢕtꢀ (linking),ꢀ ñưꢁcꢀ thꢘcꢀ hiꢈnꢀ bꢃiꢀ mꢔtꢀ
chươngꢀtrìnhꢀgꢏiꢀlàꢀbꢔꢀliênꢀkꢕtꢀ(linker).ꢀ
3.4.ꢀThꢒcꢀthiꢀchươngꢀtrìnhꢀ
3/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
Khiꢀchươngꢀtrìnhꢀnguꢛnꢀñưꢁcꢀbiênꢀdꢗchꢀvàꢀliênꢀkꢕtꢀñꢄꢀtꢂoꢀnênꢀtꢅpꢀ
tinꢀthꢘcꢀthiꢀ(cóꢀphꢚnꢀphânꢀloꢂiꢀ.exe),ꢀnóꢀcóꢀthꢄꢀthꢘcꢀthiꢀtrênꢀmáyꢀ
tínhꢀtꢂiꢀdꢖuꢀnhꢦcꢀhꢈꢀthꢑng.ꢀ
Nꢕuꢀchươngꢀtrìnhꢀhoꢂtꢀñꢔngꢀkhôngꢀñúngꢀnhưꢀyêuꢀcꢚu,ꢀvꢖnꢀñꢌꢀcóꢀ
thꢄꢀlàꢀdoꢀlꢧiꢀlꢅpꢀtrình.ꢀTrongꢀtrưꢋngꢀhꢁpꢀnày,ꢀchꢞnhꢀsꢝaꢀchươngꢀ
trìnhꢀnguꢛn,ꢀbiênꢀdꢗchꢀlꢂiꢀvàꢀliênꢀkꢕtꢀlꢂiꢀñꢄꢀtꢂoꢀnênꢀphiênꢀbꢉnꢀmꢙiꢀ
cꢎaꢀtꢅpꢀtinꢀchươngꢀtrình.ꢀ
Quáꢀtrìnhꢀbꢑnꢀbưꢙcꢀnàyꢀñưꢁcꢀlꢅpꢀñiꢀlꢅpꢀlꢅiꢀchoꢀñꢕnꢀkhiꢀtꢅpꢀtinꢀthꢘcꢀ
thiꢀthꢘcꢀhiꢈnꢀñúngꢀyêuꢀcꢚuꢀcꢎaꢀbàiꢀtoán.ꢀ
4.ꢀKhꢌoꢀsátꢀmꢎtꢀchươngꢀtrìnhꢀC/C++ꢀñơnꢀgiꢌnꢀ
ꢀ
Khꢉoꢀ sátꢀ mꢔtꢀ chươngꢀ trìnhꢀ ñơnꢀ giꢉnꢀ dùngꢀ ñꢄꢀ xuꢖtꢀ raꢀ mànꢀ hìnhꢀ
dòngꢀchꢊꢀHelloꢀWorld!ꢀ
ꢀ
//ꢀmyꢀfirstꢀprogramꢀinꢀC/C++ꢀ
#includeꢀ<conio.h>ꢀ
#includeꢀ<iostream.h>ꢀ
intꢀmain()ꢀ
{ꢀ
ꢀꢀꢀ coutꢀ<<ꢀ"HelloꢀWorld!";ꢀ//Outputꢀ“HelloꢀWorld!”ꢀ
getch();ꢀ
returnꢀ0;ꢀ
ꢀ
}ꢀ
ðâyꢀlàꢀchươngꢀtrìnhꢀñơnꢀgiꢉnꢀnhưngꢀnóꢀñãꢀbaoꢀhàmꢀnhꢊngꢀthànhꢀ
phꢚnꢀcơꢀbꢉnꢀmàꢀmꢏiꢀchươngꢀtrìnhꢀC/C++ꢀñꢌuꢀcó.ꢀVꢙiꢀýꢀnghĩaꢀcꢎaꢀ
tꢡngꢀdòngꢀnhưꢀsau:ꢀ
ꢀ
// my first program in C/C++
ðâyꢀlàꢀdòngꢀchúꢀthích,ꢀtꢖtꢀcꢉꢀcácꢀdòngꢀbꢦtꢀñꢚuꢀbꢠngꢀhaiꢀdꢖuꢀ//ꢀñưꢁcꢀ
coiꢀlàꢀcácꢀdòngꢀchúꢀthích,ꢀnóꢀkhôngꢀꢉnhꢀhưꢃngꢀñꢕnꢀhoꢂtꢀñꢔngꢀcꢎaꢀ
chươngꢀtrình,ꢀchꢞꢀdùngꢀñꢄꢀgiꢉiꢀthíchꢀmãꢀnguꢛnꢀcꢎaꢀchươngꢀtrình.ꢀꢀ
ꢀ
#include < iostream.h>
4/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
Cácꢀlꢈnhꢀbꢦtꢀñꢚuꢀbꢠngꢀdꢖuꢀ#ꢀñưꢁcꢀdùngꢀchoꢀcácꢀchꢞꢀthꢗꢀtiꢌnꢀxꢝꢀlýꢀ
(preprocessor).ꢀTrongꢀvíꢀdꢇꢀnày,ꢀcâuꢀlꢈnhꢀ#includeꢀbáoꢀchoꢀtrìnhꢀ
biênꢀdꢗchꢀbiꢕtꢀcꢚnꢀphꢉiꢀgꢔpꢀthưꢀviꢈnꢀiostream.hꢀlàꢀtꢅpꢀtinꢀheaderꢀ
chuꢐnꢀcꢎaꢀC/C++,ꢀchꢆaꢀcácꢀñꢗnhꢀnghĩaꢀvꢌꢀnhꢅpꢀvàꢀxuꢖt.ꢀ
ꢀ
int main()
ðꢗnhꢀnghĩaꢀhàmꢀmain().ꢀHàmꢀmain()ꢀlàꢀñiꢄmꢀmàꢀtꢖtꢀcꢉꢀcácꢀchươngꢀ
trìnhꢀC/C++ꢀbꢦtꢀñꢚuꢀthꢘcꢀhiꢈn.ꢀNóꢀkhôngꢀphꢇꢀthuꢔcꢀvàoꢀvꢗꢀtríꢀcꢎaꢀ
hàm,ꢀ nꢔiꢀ dungꢀ cꢎaꢀ nóꢀ luônꢀ ñưꢁcꢀ thꢘcꢀ hiꢈnꢀ ñꢚuꢀ tiênꢀ khiꢀ chươngꢀ
trìnhꢀthꢘcꢀthi.ꢀMꢔtꢀchươngꢀtrìnhꢀC/C++ꢀñꢌuꢀphꢉiꢀtꢛnꢀtꢂiꢀmꢔtꢀhàmꢀ
main().ꢀHàmꢀmain()ꢀcóꢀthꢄꢀcóꢀhoꢜcꢀkhôngꢀcóꢀthamꢀsꢑ.ꢀNꢔiꢀdungꢀ
cꢎaꢀhàmꢀmain()ꢀtiꢕpꢀngayꢀsauꢀphꢚnꢀkhaiꢀbáoꢀchínhꢀthꢆcꢀñưꢁcꢀñꢜtꢀ
trongꢀcꢜpꢀdꢖuꢀngoꢜcꢀ{ꢀ}.ꢀꢀ
ꢀ
cout << "Hello World!";
ðâyꢀlàꢀmꢔtꢀlꢈnhꢀnꢠmꢀtrongꢀphꢚnꢀthânꢀcꢎaꢀhàmꢀmain.ꢀcoutꢀlàꢀmꢔtꢀ
dòngꢀ(stream)ꢀxuꢖtꢀchuꢐnꢀtrongꢀC/C++ꢀñưꢁcꢀñꢗnhꢀnghĩaꢀtrongꢀthưꢀ
viꢈnꢀiostream.h.ꢀKhiꢀdòngꢀlꢈnhꢀnàyꢀñưꢁcꢀthꢘcꢀthi,ꢀkꢕtꢀquꢉꢀlàꢀchuꢤiꢀ
"HelloꢀWorld!"ꢀñưꢁcꢀxuꢖtꢀraꢀmànꢀhình.ꢀDòngꢀlꢈnhꢀñưꢁcꢀkꢕtꢀthúcꢀ
bꢠngꢀdꢖuꢀchꢖmꢀphꢐyꢀ(;).ꢀꢀ
ꢀ
getch();
ðâyꢀlàꢀmꢔtꢀhàmꢀthưꢀviꢈnꢀdùngꢀñꢄꢀchꢋꢀnhꢅpꢀmꢔtꢀkýꢀtꢘꢀtꢡꢀbànꢀphím.ꢀꢀ
ꢀ
return 0;
Lꢈnhꢀ returnꢀ kꢕtꢀ thúcꢀ hàmꢀ mainꢀ vàꢀ trꢉꢀ vꢌꢀ mãꢀ ñiꢀ sauꢀ nó,ꢀ trongꢀ
trưꢋngꢀ hꢁpꢀ nàyꢀ làꢀ 0.ꢀ ðâyꢀ làꢀ mꢔtꢀ kꢕtꢀ thúcꢀ bìnhꢀ thưꢋngꢀ cꢎaꢀ mꢔtꢀ
chươngꢀtrìnhꢀkhôngꢀcóꢀlꢧiꢀtrongꢀquáꢀtrìnhꢀthꢘcꢀhiꢈn.ꢀꢀ
ꢀ
Chươngꢀtrìnhꢀtrênꢀcóꢀthꢄꢀviꢕtꢀlꢂiꢀnhưꢀsau:ꢀ
intꢀmain()ꢀ{ꢀcoutꢀ<<ꢀ"ꢀHelloꢀWorld!ꢀ";ꢀgetch();ꢀreturnꢀ0;}ꢀ
cũngꢀchoꢀcùngꢀmꢔtꢀkꢕtꢀquꢉ.ꢀꢀ
ꢀ
5/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
5.ꢀCácꢀchúꢀthíchꢀ(comments)ꢀ
Cácꢀchúꢀthíchꢀñưꢁcꢀcácꢀlꢅpꢀtrìnhꢀviênꢀsꢝꢀdꢇngꢀñꢄꢀghiꢀchúꢀhayꢀmôꢀtꢉꢀ
trongꢀcácꢀphꢚnꢀcꢎaꢀchươngꢀtrình.ꢀTrongꢀC/C++ꢀcóꢀhaiꢀcáchꢀñꢄꢀchúꢀ
thích:ꢀꢀꢀ
Chúꢀthíchꢀdòng:ꢀdùngꢀcꢜpꢀdꢖuꢀ//.ꢀTꢡꢀvꢗꢀtríꢀ//ꢀñꢕnꢀcuꢑiꢀdòngꢀñưꢁcꢀ
xemꢀlàꢀchúꢀthíchꢀ
Chúꢀ thíchꢀ khꢑiꢀ (chúꢀ thíchꢀ trênꢀ nhiꢌuꢀ dòng)ꢀ dùngꢀ cꢜpꢀ /*ꢀ ...ꢀ */.ꢀ
Nhꢊngꢀgìꢀnꢠmꢀgiꢊaꢀcꢜpꢀdꢖuꢀnàyꢀñưꢁcꢀxemꢀlàꢀchúꢀthích.ꢀ
ꢀ
Víꢀdꢁ:ꢀ
/*ꢀꢀ MyꢀsecondꢀprogramꢀinꢀC/C++ꢀwithꢀmoreꢀcommentsꢀꢀ
ꢀ
ꢀ
Author:ꢀNoviceꢀprogrammerꢀ
Date:ꢀ01/01/2008ꢀ
*/ꢀ
#includeꢀ<conio.h>ꢀ
#includeꢀ<iostream.h>ꢀ
intꢀmain()ꢀ
{ꢀ
ꢀꢀꢀcoutꢀ<<ꢀ"HelloꢀWorld!ꢀ";ꢀ//ꢀoutputꢀHelloꢀWorld!ꢀ
ꢀꢀꢀcoutꢀ<<ꢀ"IꢀhateꢀC/C++.";ꢀ//ꢀoutputꢀIꢀhateꢀC/C++.ꢀ
ꢀꢀꢀgetch();ꢀꢀ
ꢀꢀꢀreturnꢀ0;ꢀ
}ꢀ
ꢀ
Kꢕtꢀquꢄꢀxuꢅtꢀcꢆaꢀchươngꢀtrìnhꢀlà:ꢀHelloꢀWorld!ꢀIꢀhateꢀC/C++.ꢀ
ꢀ
6/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
6.ꢀCꢓuꢀtrúcꢀcꢇaꢀmꢎtꢀchươngꢀtrìnhꢀC/C++ꢀ
CꢖuꢀtrúcꢀmꢔtꢀchươngꢀtrìnhꢀC/C++ꢀbaoꢀgꢛmꢀcácꢀthànhꢀphꢚnꢀnhư:ꢀ
Cácꢀchꢞꢀthꢗꢀtiꢌnꢀxꢝꢀlý,ꢀkhaiꢀbáoꢀbiꢕnꢀtoànꢀcꢇc,ꢀchươngꢀtrìnhꢀchínhꢀ
(hàmꢀmain),ꢀ...ꢀ
Khꢉoꢀsátꢀchươngꢀtrìnhꢀsau:ꢀ
ꢀ
/*ꢀfact.cꢀ
Phꢇnꢀnàyꢀthưꢈngꢀdùngꢀñꢉꢀmôꢀ
Purpose:ꢀprintsꢀtheꢀfactorialsꢀofꢀ
tꢄꢀmꢊcꢀñínhꢀchươngꢀtrình,ꢀtácꢀ
theꢀnumbersꢀfromꢀ0ꢀthroughꢀ10ꢀ
giꢄ,ꢀngàyꢀviꢋt,ꢀ...ꢀ(Phꢇnꢀkhôngꢀ
Author:ꢀMr.Beginnerꢀ
bꢌtꢀbuꢍc)ꢀ
Date:ꢀ01/01/2008ꢀ
*/ꢀ
ꢀ
Khaiꢀbáoꢀcácꢀtꢁpꢀtinꢀthưꢀviꢂnꢀ
#includeꢀ<iostream.h>ꢀ
ꢀ
ꢀ
ꢀ
Khaiꢀbáoꢀprototypeꢀcꢆaꢀcácꢀ
hàmꢀtꢎꢀtꢏoꢀ
intꢀfactorial(intꢀn);ꢀ
ꢀ
ꢀ
ꢀ
intꢀmain()ꢀꢀ
{ꢀ
ꢀꢀꢀintꢀi;ꢀ
ꢀꢀꢀfor(i=0;ꢀi<=10;ꢀi++)ꢀꢀ
ꢀ
Hàmꢀchínhꢀcꢆaꢀchươngꢀtrìnhꢀ
ꢀꢀꢀꢀꢀcout<<i<<“!=“<<factorial(i);ꢀ
ꢀꢀꢀreturnꢀ0;ꢀ
}ꢀ
ꢀ
/*ꢀThisꢀfunctionꢀcomputesꢀtheꢀꢀ
factorialꢀofꢀitsꢀparameter,ꢀreturningꢀitꢀ*/ꢀ
intꢀfactorial(intꢀn)ꢀꢀ
{ꢀ
ꢀꢀꢀꢀintꢀi,ꢀproduct;ꢀ
ꢀꢀꢀꢀproductꢀ=ꢀ1;ꢀ
ꢀꢀꢀꢀforꢀ(i=2;i<=n;i++)ꢀprodꢀ*=ꢀi;ꢀ
ꢀꢀꢀꢀreturnꢀproduct;ꢀ
}ꢀ
ðꢐnhꢀnghĩaꢀcácꢀhàmꢀdoꢀngưꢈiꢀ
dùngꢀtꢎꢀxâyꢀdꢎngꢀꢀ
ꢀ
ꢀ
7/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
7.ꢀCácꢀtꢉpꢀtinꢀthưꢀviꢔnꢀthôngꢀdꢕngꢀ
ðâyꢀ làꢀ cácꢀ tꢅpꢀ tinꢀ chꢆaꢀ ñꢗnhꢀ nghĩaꢀ cácꢀ hàmꢀ thôngꢀ dꢇngꢀ khiꢀ lꢅpꢀ
trìnhꢀC/C++.ꢀMuꢑnꢀsꢝꢀdꢇngꢀcácꢀhàmꢀtrongꢀcácꢀtꢅpꢀtinꢀheaderꢀnàyꢀ
thìꢀphꢉiꢀkhaiꢀbáoꢀ#includeꢀ<FileName.h>ꢀꢃꢀphꢚnꢀñꢚuꢀcꢎaꢀchươngꢀ
trình,ꢀvꢙiꢀFileName.hꢀlàꢀtênꢀtꢅpꢀtinꢀthưꢀviꢈn.ꢀCácꢀtꢅpꢀtinꢀthưꢀviꢈnꢀ
thôngꢀdꢇngꢀgꢛm:ꢀ
stdio.h(C),ꢀ iostream.h(C++)ꢀ Tꢅpꢀ tinꢀ ñꢗnhꢀ nghĩaꢀ cácꢀ hàmꢀ vào/raꢀ
chuꢐnꢀ (standardꢀ input/output)ꢀ gꢛmꢀ cácꢀ hàmꢀ xuꢖtꢀ dꢊꢀ liꢈuꢀ
(printf())/cout),ꢀnhꢅpꢀgiáꢀtrꢗꢀchoꢀbiꢕnꢀ(scanf())/cin),ꢀnhꢅnꢀkýꢀtꢘꢀtꢡꢀ
bànꢀphímꢀ(getc()),ꢀinꢀkýꢀtꢘꢀraꢀmànꢀhìnhꢀ(putc()),ꢀnhꢅpꢀmꢔtꢀchuꢤiꢀkýꢀ
tꢘꢀtꢡꢀbàmꢀphímꢀ(gets()),ꢀxuꢖtꢀchuꢤiꢀkýꢀtꢘꢀraꢀmànꢀhìnhꢀ(puts()),ꢀxóaꢀ
vùngꢀñꢈmꢀbànꢀphímꢀ(fflush()),ꢀfopen(),ꢀfclose(),ꢀfread(),ꢀfwrite(),ꢀ
getchar(),ꢀputchar(),ꢀ...ꢀ
conio.hꢀ :ꢀ Tꢅpꢀ tinꢀ ñꢗnhꢀ nghĩaꢀ cácꢀ hàmꢀ vàoꢀ raꢀ trongꢀ chꢕꢀ ñꢔꢀ DOSꢀ
(DOSꢀconsole)ꢀgꢛmꢀcácꢀhàmꢀclrscr(),ꢀgetch(),ꢀgetche(),ꢀgetpass(),ꢀ
cgets(),ꢀcputs(),ꢀputch(),ꢀclreol(),ꢀ…ꢀ
math.h:ꢀTꢅpꢀtinꢀñꢗnhꢀnghĩaꢀcácꢀhàmꢀtoánꢀhꢏcꢀgꢛmꢀcácꢀhàmꢀabs(),ꢀ
sqrt(),ꢀlog(),ꢀlog10(),ꢀsin(),ꢀcos(),ꢀtan(),ꢀacos(),ꢀasin(),ꢀatan(),ꢀpow(),ꢀ
exp(),ꢀ…ꢀ
alloc.h:ꢀTꢅpꢀtinꢀñꢗnhꢀnghĩaꢀcácꢀhàmꢀliênꢀquanꢀñꢕnꢀviꢈcꢀquꢉnꢀlýꢀbꢔꢀ
nhꢙꢀgꢛmꢀcácꢀhàmꢀcalloc(),ꢀrealloc(),ꢀmalloc(),ꢀfree(),ꢀfarmalloc(),ꢀ
farcalloc(),ꢀfarfree(),ꢀꢀ…ꢀ
io.h:ꢀ Tꢅpꢀ tinꢀ ñꢗnhꢀ nghĩaꢀ cácꢀ hàmꢀ vàoꢀ raꢀ cꢖpꢀ thꢖpꢀ gꢛmꢀ cácꢀ hàmꢀ
open(),ꢀ_open(),ꢀread(),ꢀ_read(),ꢀclose(),ꢀ_close(),ꢀcreat(),ꢀ_creat(),ꢀ
creatnew(),ꢀeof(),ꢀfilelength(),ꢀlock(),ꢀ…ꢀ
ꢀ
8/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
Chươngꢀ2ꢀ
BIꢖUꢀTHꢗCꢀꢀ
(Expressions)ꢀ
ꢀ
Biꢄuꢀthꢆcꢀñưꢁcꢀtꢂoꢀthànhꢀtꢡꢀnhꢊngꢀthànhꢀtꢑꢀnhưꢀdꢊꢀliꢈuꢀvàꢀtoánꢀtꢝ.ꢀ
Dꢊꢀliꢈuꢀcóꢀthꢄꢀchꢆaꢀtrongꢀbiꢕnꢀhoꢜcꢀhꢠng.ꢀToánꢀtꢝꢀtrongꢀcácꢀngônꢀ
ngꢊꢀlꢅpꢀtrìnhꢀcóꢀcùngꢀýꢀnghĩaꢀnhưꢀtrongꢀtoánꢀhꢏc.ꢀCóꢀnhiꢌuꢀloꢂiꢀ
toánꢀtꢝꢀnhưꢀtoánꢀtꢝꢀgánꢀ(=),ꢀtoánꢀtꢝꢀsꢑꢀhꢏcꢀ(+ꢀꢓꢀ*ꢀ/ꢀ%),ꢀtoánꢀtꢝꢀquanꢀ
hꢈꢀ(==ꢀ<ꢀ<=ꢀ>ꢀ>=ꢀ!=),ꢀtoánꢀtꢝꢀluꢅnꢀlýꢀ(&&ꢀ||ꢀ!),ꢀ...ꢀ
ꢀ
1.ꢀKiꢋuꢀdꢈꢀliꢔuꢀ(dataꢀtypes)ꢀ
C/C++ꢀcóꢀnămꢀkiꢄuꢀdꢊꢀliꢈuꢀcơꢀsꢃ:ꢀkýꢀtꢘꢀ(char),ꢀsꢑꢀnguyênꢀ(int),ꢀsꢑꢀ
thꢘcꢀ(float),ꢀsꢑꢀthꢘcꢀcóꢀñꢔꢀchínhꢀxácꢀgꢖpꢀñôiꢀ(double),ꢀvàꢀkiꢄuꢀvôꢀ
ñꢗnhꢀ(void).ꢀTꢖtꢀcꢉꢀnhꢊngꢀkiꢄuꢀdꢊꢀliꢈuꢀkhácꢀñꢌuꢀdꢘaꢀtrênꢀ5ꢀkiꢄuꢀcơꢀ
sꢃꢀnày.ꢀKíchꢀthưꢙcꢀvàꢀphꢂmꢀviꢀcꢎaꢀnhꢊngꢀkiꢄuꢀdꢊꢀliꢈuꢀnàyꢀcóꢀthꢄꢀ
thayꢀñꢤiꢀtùyꢀtheoꢀloꢂiꢀCPUꢀvàꢀtrìnhꢀbiênꢀdꢗch.ꢀ
Kiꢄuꢀ charꢀ ñưꢁcꢀ dùngꢀ ñꢄꢀ giꢊꢀ cácꢀ giáꢀ trꢗꢀ cꢎaꢀ bꢔꢀ mãꢀ ASCIIꢀ
(Amercicanꢀ Standardꢀ Codeꢀ forꢀ Informationꢀ Interchange).ꢀ Kiꢄuꢀ
charꢀchiꢕmꢀ1ꢀbyteꢀbꢔꢀnhꢙ.ꢀ
Kíchꢀthưꢙcꢀcꢎaꢀkiꢄuꢀintꢀlàꢀ16ꢀbitsꢀ(2ꢀbytes)ꢀtrênꢀmôiꢀtrưꢋngꢀ16ꢓbitꢀ
nhưꢀDOS,ꢀWindowsꢀ3.1.ꢀMôiꢀtrưꢋngꢀ32ꢓbitꢀnhưꢀWindowsꢀ95,ꢀkíchꢀ
thưꢙcꢀ kiꢄuꢀ intꢀ làꢀ 32ꢀ bitsꢀ (4ꢀ bytes).ꢀ Nóiꢀ chung,ꢀ tùyꢀ thuꢔcꢀ môiꢀ
trưꢋng,ꢀkíchꢀthưꢙcꢀcꢎaꢀkiꢄuꢀintꢀcóꢀthꢄꢀkhácꢀnhau.ꢀ
ChuꢐnꢀCꢀchꢞꢀraꢀphꢂmꢀviꢀtꢑiꢀthiꢄuꢀcꢎaꢀkiꢄuꢀdꢊꢀliꢈuꢀsꢑꢀthꢘcꢀ(float,ꢀ
double)ꢀlàꢀ1Eꢓ37ꢀñꢕnꢀ1E+37.ꢀ
Kiꢄuꢀvoidꢀdùngꢀñꢄꢀkhaiꢀbáoꢀhàmꢀkhôngꢀtrꢉꢀvꢌꢀgiáꢀtrꢗꢀhoꢜcꢀtꢂoꢀnênꢀ
cácꢀconꢀtrꢨꢀtꢤngꢀquátꢀ(genericꢀpointers).ꢀ
Ngoꢂiꢀtrꢡꢀkiꢄuꢀvoid,ꢀcácꢀkiꢄuꢀdꢊꢀliꢈuꢀcơꢀsꢃꢀcóꢀthꢄꢀcóꢀcácꢀtꢡꢀnhưꢀ
signed,ꢀunsigned,ꢀlong,ꢀshortꢀñiꢀtrưꢙcꢀnó.ꢀCácꢀtꢡꢀnàyꢀlàmꢀthayꢀñꢤiꢀ
phꢂmꢀviꢀtꢑiꢀthiꢄuꢀmꢧiꢀkiꢄuꢀcơꢀsꢃꢀcóꢀthꢄꢀchꢆa.ꢀBꢉngꢀsauꢀtrìnhꢀbàyꢀ
tꢖtꢀcꢉꢀcácꢀkꢕtꢀhꢁpꢀhꢁpꢀlꢈꢀcꢎaꢀkiꢄuꢀdꢊꢀliꢈuꢀvꢙiꢀcácꢀtꢡꢀtrên.ꢀ
9/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
ꢀ
Kíchꢀthưꢏcꢀ
bꢘngꢀbitsꢀ
Kiꢋuꢀdꢈꢀliꢔuꢀ
Phꢐmꢀviꢀtꢙiꢀthiꢋuꢀ
charꢀ
8ꢀ
ꢓ127ꢀtoꢀ127ꢀ
unsignedꢀcharꢀ
signedꢀcharꢀ
ꢀ
8ꢀ
8ꢀ
0ꢀtoꢀ255ꢀ
ꢓ127ꢀtoꢀ127ꢀ
ꢀ
ꢓ32,767ꢀtoꢀ32,767ꢀ
0ꢀtoꢀ65,535ꢀ
giꢑngꢀnhưꢀintꢀ
ꢓ32,767ꢀtoꢀ32,767ꢀ
0ꢀtoꢀ65,535ꢀ
giꢑngꢀnhưꢀshortꢀintꢀ
ꢀ
ꢀ
16ꢀorꢀ32ꢀ
16ꢀorꢀ32ꢀ
16ꢀorꢀ32ꢀ
16ꢀ
intꢀ
unsignedꢀintꢀ
signedꢀintꢀ
shortꢀintꢀhoꢜcꢀshortꢀ
unsignedꢀshortꢀintꢀ
signedꢀshortꢀintꢀ
ꢀ
16ꢀ
16ꢀ
ꢀ
longꢀintꢀhoꢜcꢀlongꢀ
signedꢀlongꢀintꢀ
unsignedꢀlongꢀintꢀ
ꢀ
32ꢀ
32ꢀ
32ꢀ
ꢀ
ꢓ2,147,483,647ꢀtoꢀ2,147,483,647ꢀ
giꢑngꢀnhưꢀlongꢀintꢀ
0ꢀtoꢀ4,294,967,295ꢀ
ꢀ
floatꢀ
doubleꢀ
longꢀdoubleꢀ
32ꢀ
64ꢀ
80ꢀ
ðꢔꢀchínhꢀxácꢀlàꢀ6ꢀkýꢀsꢑꢀ
ðꢔꢀchínhꢀxácꢀlàꢀ10ꢀkýꢀsꢑꢀ
ðꢔꢀchínhꢀxácꢀlàꢀ10ꢀkýꢀsꢑꢀ
ꢀ
2.ꢀCácꢀñꢅnhꢀdanhꢀ(Identifierꢀnames)ꢀ
Trongꢀ C/C++,ꢀ tênꢀ cꢎaꢀ cácꢀ biꢕn,ꢀ hꢠng,ꢀ hàm,...ꢀ ñưꢁcꢀ gꢏiꢀ làꢀ ñꢗnhꢀ
danh.ꢀNhꢊngꢀñꢗnhꢀdanhꢀnàyꢀcóꢀthꢄꢀlàꢀ1ꢀhoꢜcꢀnhiꢌuꢀkýꢀtꢘ.ꢀKýꢀtꢘꢀñꢚuꢀ
tiênꢀphꢉiꢀlàꢀmꢔtꢀchꢊꢀcáiꢀhoꢜcꢀdꢖuꢀ_ꢀ(underscore),ꢀnhꢊngꢀkýꢀtꢘꢀtheoꢀ
sauꢀ phꢉiꢀ làꢀ chꢊꢀ cái,ꢀ chꢊꢀ sꢑ,ꢀ hoꢜcꢀ dꢖuꢀ _.ꢀ Sauꢀ ñâyꢀ làꢀ nhꢊngꢀ ñꢗnhꢀ
danhꢀñúngꢀvàꢀsai:ꢀ
ðúngꢀ
countꢀ
test23ꢀ
Saiꢀ
1countꢀ
hi!thereꢀ
high_balanceꢀ
ꢀ
high...balanceꢀ
C/C++ꢀphânꢀbiꢈtꢀkýꢀtꢘꢀHOAꢀvàꢀthưꢋng.ꢀVìꢀvꢅy,ꢀcount,ꢀCount,ꢀvàꢀ
COUNTꢀlàꢀ3ꢀdanhꢀñꢗnhꢀkhácꢀnhau.ꢀ
10/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
ðꢗnhꢀdanhꢀkhôngꢀñưꢁcꢀtrùngꢀvꢙiꢀcácꢀtꢡꢀkhóaꢀ(keywords)ꢀvàꢀkhôngꢀ
nênꢀcóꢀcùngꢀtênꢀnhưꢀcácꢀhàmꢀthưꢀviꢈnꢀcꢎaꢀC/C++.ꢀ
ꢀ
3.ꢀTꢚꢀkhóaꢀ(keywords)ꢀ
Làꢀnhꢊngꢀtꢡꢀñãꢀñưꢁcꢀdànhꢀriêngꢀbꢃiꢀngônꢀngꢊꢀlꢅpꢀtrìnhꢀchoꢀnhꢊngꢀ
mꢇcꢀñíchꢀriêngꢀcꢎaꢀnó.ꢀKhôngꢀñưꢁcꢀdùngꢀtꢡꢀkhóaꢀñꢄꢀñꢜtꢀtênꢀchoꢀ
nhꢊngꢀñꢗnhꢀdanhꢀnhưꢀbiꢕn,ꢀhꢠng,ꢀhàm,ꢀ...ꢀTꢖtꢀcꢉꢀcácꢀtꢡꢀkhóaꢀtrongꢀ
C/C++ꢀñꢌuꢀlàꢀchꢊꢀthưꢋngꢀ(lowercase).ꢀSauꢀñâyꢀlàꢀdanhꢀsáchꢀcácꢀtꢡꢀ
khóaꢀcꢎaꢀC/C++:ꢀ
ꢀ
autoꢀ
breakꢀ caseꢀ
enumꢀ
registerꢀ returnꢀ shortꢀ
charꢀ
externꢀ floatꢀ
constꢀ
continueꢀ defaultꢀ doꢀ
doubleꢀ elseꢀ
intꢀ longꢀ
forꢀ
gotoꢀ
ifꢀ
signedꢀ
sizeofꢀ
staticꢀ
structꢀ switchꢀ typedefꢀ unionꢀ unsignedꢀ voidꢀ
volatileꢀ whileꢀ
ꢀ
4.ꢀBiꢍnꢀ(variables)ꢀ
Mꢔtꢀbiꢕnꢀlàꢀñꢗnhꢀdanhꢀcꢎaꢀmꢔtꢀvùngꢀtrongꢀbꢔꢀnhꢙꢀdùngꢀñꢄꢀgiꢊꢀmꢔtꢀ
giáꢀ trꢗꢀ màꢀ cóꢀ thꢄꢀ bꢗꢀ thayꢀ ñꢤiꢀ bꢃiꢀ chươngꢀ trình.ꢀ Tꢖtꢀ cꢉꢀ biꢕnꢀ phꢉiꢀ
ñưꢁcꢀkhaiꢀbáoꢀtrưꢙcꢀkhiꢀñưꢁcꢀsꢝꢀdꢇng.ꢀDꢂngꢀkhaiꢀbáoꢀbiꢕnꢀtꢤngꢀ
quátꢀlà:ꢀ
type variableNames;
type:ꢀphꢉiꢀlàꢀmꢔtꢀtrongꢀcácꢀkiꢄuꢀdꢊꢀliꢈuꢀhꢁpꢀlꢈ.ꢀ
variableNames:ꢀ tênꢀ cꢎaꢀ mꢔtꢀ hayꢀ nhiꢌuꢀ biꢕnꢀ phânꢀ cáchꢀ nhauꢀ bꢃiꢀ
dꢖuꢀphꢐy.ꢀ
ꢀ
Ngoàiꢀra,ꢀtaꢀcóꢀthꢄꢀvꢡaꢀkhaiꢀbáoꢀvꢡaꢀkhꢃiꢀtꢂoꢀgiáꢀtrꢗꢀbanꢀñꢚuꢀchoꢀ
cácꢀbiꢕnꢀdùngꢀcúꢀphápꢀsau:ꢀ
type varName1=value, ... , varName_n=value;
ꢀ
Víꢀdꢇ:ꢀ
intꢀi,ꢀj;ꢀ//ꢀkhaiꢀbáoꢀ2ꢀbiꢁnꢀi,ꢀjꢀkiꢂuꢀintꢀ
//ꢀkhaiꢀbáoꢀbaꢀbiꢁnꢀday,ꢀmonthꢀvàꢀyearꢀkiꢂuꢀshortꢀintꢀ
shortꢀday,ꢀmonth,ꢀyear;ꢀ
11/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
charꢀch;ꢀ//ꢀkhaiꢀbáoꢀbiꢁnꢀchꢀkiꢂuꢀkýꢀtꢃꢀ
//ꢀkhaiꢀbaoꢀ4ꢀbienꢀkieuꢀfloat,ꢀgánꢀaverageꢀgiáꢀtrꢄꢀ0ꢀ
floatꢀmark1,ꢀmark2,ꢀmark3,ꢀaverageꢀ=ꢀ0;ꢀꢀ
ꢀ
Lưuꢀý:ꢀKhiꢀkhaiꢀbáoꢀbiꢋnꢀnꢋuꢀkhôngꢀcungꢀcꢅpꢀgiáꢀtrꢐꢀkhꢑiꢀtꢏoꢀthìꢀgiáꢀtrꢐꢀ
cꢆaꢀbiꢋnꢀlàꢀchưaꢀxácꢀñꢐnh.ꢀDoꢀñó,ꢀviꢂcꢀdùngꢀnhꢒngꢀbiꢋnꢀnàyꢀtrongꢀcácꢀ
biꢉuꢀthꢓcꢀlàꢀvôꢀnghĩa.ꢀ
ꢀ
Biꢕnꢀñưꢁcꢀkhaiꢀbáoꢀtꢂiꢀbaꢀnơi:ꢀbênꢀtrongꢀhàm,ꢀtrongꢀñꢗnhꢀnghĩaꢀ
thamꢀsꢑꢀcꢎaꢀhàm,ꢀvàꢀbênꢀngoàiꢀtꢖtꢀcꢉꢀhàm.ꢀNhꢊngꢀbiꢕnꢀnàyꢀñưꢁcꢀ
gꢏiꢀlꢚnꢀlưꢁtꢀlàꢀbiꢕnꢀcꢇcꢀbꢔ,ꢀcácꢀthamꢀsꢑꢀhìnhꢀthꢆc,ꢀvàꢀbiꢕnꢀtoànꢀcꢇc.ꢀ
ꢀ
4.1.ꢀBiꢍnꢀcꢕcꢀbꢎꢀ(localꢀvariables)ꢀ
Nhꢊngꢀbiꢕnꢀñưꢁcꢀkhaiꢀbáoꢀbênꢀtrongꢀmꢔtꢀhàmꢀgꢏiꢀlàꢀbiꢕnꢀcꢇcꢀbꢔ.ꢀ
Cácꢀbiꢕnꢀcꢇcꢀbꢔꢀchꢞꢀñưꢁcꢀthamꢀchiꢕuꢀñꢕnꢀchꢞꢀbꢃiꢀnhꢊngꢀlꢈnhꢀnꢠmꢀ
trongꢀkhꢑiꢀ(block)ꢀcóꢀkhaiꢀbáoꢀbiꢕn.ꢀMꢔtꢀkhꢑiꢀbꢦtꢀñꢚuꢀvꢙiꢀdꢖuꢀ{ꢀvàꢀ
kꢕtꢀthúcꢀvꢙiꢀdꢖuꢀ}.ꢀ
Biꢕnꢀcꢇcꢀbꢔꢀchꢞꢀtꢛnꢀtꢂiꢀtrongꢀkhiꢀkhꢑiꢀchꢆaꢀnóꢀñangꢀthꢘcꢀthiꢀvàꢀbꢗꢀ
hꢎyꢀkhiꢀkhꢑiꢀchꢆaꢀnóꢀthꢘcꢀthiꢀxong.ꢀ
Víꢀdꢇ:ꢀXemꢀxétꢀhaiꢀhàmꢀsau:ꢀ
voidꢀfunc1(void)ꢀ
{ꢀ
intꢀx;ꢀ
xꢀ=ꢀ10;ꢀ
}ꢀ
ꢀ
voidꢀfunc2(void)ꢀ
{ꢀ
intꢀx;ꢀ
xꢀ=ꢀꢅ199;ꢀ
}ꢀ
Biꢕnꢀnguyênꢀxꢀñưꢁcꢀkhaiꢀbáoꢀ2ꢀlꢚn,ꢀmꢔtꢀtrongꢀhàmꢀfunc1()ꢀvàꢀmꢔtꢀ
trongꢀhàmꢀfunc2().ꢀBiꢕnꢀxꢀtrongꢀfunc1()ꢀkhôngꢀcóꢀquanꢀhꢈꢀgìꢀvꢙiꢀ
biꢕnꢀxꢀtrongꢀfunc2()ꢀbꢃiꢀvìꢀmꢧiꢀxꢀchꢞꢀtꢛnꢀtꢂiꢀtrongꢀkhꢑiꢀchꢆaꢀnó.ꢀ
ꢀ
4.2.ꢀCácꢀthamꢀsꢙꢀhìnhꢀthꢛcꢀ(formalꢀparameters)ꢀ
12/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
Nꢕuꢀmꢔtꢀhàmꢀcóꢀnhꢅnꢀcácꢀñꢑiꢀsꢑꢀtruyꢌnꢀvàoꢀhàmꢀthìꢀnóꢀphꢉiꢀkhaiꢀ
báoꢀ cácꢀ biꢕnꢀ ñꢄꢀ nhꢅnꢀ giáꢀ trꢗꢀ cꢎaꢀ cácꢀ ñꢑiꢀ sꢑꢀ khiꢀ hàmꢀ ñưꢁcꢀ gꢏi.ꢀ
Nhꢊngꢀ biꢕnꢀ nàyꢀ gꢏiꢀ làꢀ cácꢀ thamꢀ sꢑꢀ hìnhꢀ thꢆc.ꢀ Nhꢊngꢀ biꢕnꢀ nàyꢀ
ñưꢁcꢀñꢑiꢀxꢝꢀgiꢑngꢀnhưꢀcácꢀbiꢕnꢀcꢇcꢀbꢔꢀkhácꢀñưꢁcꢀkhaiꢀbáoꢀtrongꢀ
hàm.ꢀXemꢀxétꢀvíꢀdꢇꢀsau:ꢀ
intꢀsum(intꢀfrom,ꢀintꢀto)ꢀ
{ꢀ
ꢀ
intꢀtotal=0;ꢀ
ꢀ
for(intꢀi=fromꢀ;ꢀi<=toꢀ;ꢀi++)ꢀtotalꢀ+=i;ꢀ
returnꢀtotal;ꢀ
ꢀ
}ꢀ
Trongꢀvíꢀdꢇꢀnày,ꢀfromꢀvàꢀtoꢀlàꢀ2ꢀthamꢀsꢑꢀhìnhꢀthꢆcꢀvàꢀñưꢁcꢀñꢑiꢀxꢝꢀ
nhưꢀbiꢕnꢀcꢇcꢀbꢔꢀtotalꢀcꢎaꢀhàmꢀsum.ꢀLưuꢀýꢀbiꢕnꢀiꢀñưꢁcꢀkhaiꢀbáoꢀ
trongꢀcꢖuꢀtrúcꢀlꢜpꢀforꢀnênꢀnóꢀlàꢀbiꢕnꢀcꢇcꢀbꢔꢀchꢞꢀtꢛnꢀtꢂiꢀtrongꢀcꢖuꢀ
trúcꢀforꢀmàꢀthôi.ꢀNhꢊngꢀlꢈnhꢀnꢠmꢀngòaiꢀcꢖuꢀtrúcꢀforꢀsꢥꢀkhôngꢀthamꢀ
chiꢕuꢀñưꢁcꢀbiꢕnꢀiꢀnày.ꢀ
ꢀ
4.3.ꢀBiꢍnꢀtoànꢀcꢕcꢀ(globalꢀvariables)ꢀ
Biꢕnꢀtoànꢀcꢇcꢀcóꢀphꢂmꢀviꢀlàꢀtoànꢀbꢔꢀchươngꢀtrình.ꢀDoꢀñó,ꢀtꢖtꢀcꢉꢀcácꢀ
lꢈnhꢀcóꢀtrongꢀchươngꢀtrìnhꢀñꢌuꢀcóꢀthꢄꢀthamꢀchiꢕuꢀñꢕnꢀbiꢕnꢀtoànꢀ
cꢇc.ꢀBiꢕnꢀtoànꢀcꢇcꢀñưꢁcꢀkhaiꢀbáoꢀbênꢀngoàiꢀtꢖtꢀcꢉꢀhàm.ꢀ
Khꢉoꢀsátꢀchươngꢀtrìnhꢀsau:ꢀ
#includeꢀ<iostream.h>ꢀ
voidꢀincrease();ꢀ
voidꢀdecrease();ꢀ
intꢀgVarꢀ=ꢀ100;ꢀ
voidꢀmain()ꢀ
{ꢀ
ꢀ
ꢀ
coutꢀ<<ꢀ“ValueꢀofꢀgVar=ꢀ“ꢀ<<ꢀgVar;ꢀ
increase();ꢀ
ꢀ
coutꢀ<<ꢀ“Afterꢀincreased,ꢀgVar=ꢀ“ꢀ<<ꢀgVar;ꢀ
ꢀ
ꢀ
decrease();ꢀ
coutꢀ<<ꢀ“Afterꢀdecreased,ꢀgVar=ꢀ“ꢀ<<ꢀgVar;ꢀ
}ꢀ
ꢀ
voidꢀincrease()ꢀ
{ꢀ
gVarꢀ=ꢀgVarꢀ+ꢀ1;}ꢀ
ꢀ
voidꢀdecrease()ꢀ
{ꢀ
gVarꢀ=ꢀgVarꢀꢅ1;}ꢀ
13/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
Sauꢀkhiꢀthꢘcꢀthiꢀchươngꢀtrìnhꢀtrên,ꢀkꢕtꢀquꢉꢀxuꢖtꢀtrênꢀmànꢀhìnhꢀlà:ꢀ
ValueꢀofꢀgVar=ꢀ100ꢀ
Afterꢀincreased,ꢀgVar=ꢀ101;ꢀ
Afterꢀdecreased,ꢀgVar=ꢀ100;ꢀ
ꢀ
5.ꢀTꢚꢀkhóaꢀconstꢀ
Giáꢀtrꢗꢀcꢎaꢀbiꢕnꢀthayꢀñꢤiꢀtrongꢀsuꢑtꢀquáꢀtrìnhꢀthꢘcꢀthiꢀchươngꢀtrình.ꢀ
ðꢄꢀgiáꢀtrꢗꢀcꢎaꢀbiꢕnꢀkhôngꢀbꢗꢀthayꢀñꢤi,ꢀtaꢀñꢜtꢀtrưꢙcꢀkhaiꢀbáoꢀbiꢕnꢀtꢡꢀ
khóaꢀconst.ꢀTꢡꢀkhiꢀbiꢕnꢀñãꢀcóꢀgiáꢀtrꢗ,ꢀgiáꢀtrꢗꢀnàyꢀsꢥꢀkhôngꢀbaoꢀgiꢋꢀ
bꢗꢀthayꢀñꢤiꢀbꢃiꢀbꢖtꢀkỳꢀlꢈnhꢀnàoꢀtrongꢀchươngꢀtrình.ꢀThôngꢀthưꢋngꢀ
taꢀdùngꢀchꢊꢀHOAꢀñꢄꢀñꢜtꢀtênꢀchoꢀnhꢊngꢀbiꢕnꢀnày.ꢀ
Víꢀdꢇ:ꢀkhaiꢀbáoꢀhꢠngꢀnguyênꢀMAXꢀcóꢀgiáꢀtrꢗꢀ100ꢀ
constꢀintꢀMAXꢀ=ꢀ200;ꢀ
ꢀ
6.ꢀHꢘngꢀ(constants)ꢀ
Hꢠngꢀ làꢀ nhꢊngꢀ giáꢀ trꢗꢀ cꢑꢀ ñꢗnhꢀ (fixedꢀ values)ꢀ màꢀ chươngꢀ trìnhꢀ
khôngꢀthꢄꢀthayꢀñꢤi.ꢀBꢖtꢀkỳꢀkiꢄuꢀdꢊꢀliꢈuꢀnàoꢀcũngꢀcóꢀhꢠngꢀtươngꢀ
ꢆng.ꢀHꢠngꢀcònꢀñưꢁcꢀgꢏiꢀlàꢀliterals.ꢀ
Hꢠngꢀkýꢀtꢘꢀñưꢁcꢀràoꢀquanhꢀbꢃiꢀcꢜpꢀdꢖuꢀnháyꢀñơn.ꢀVíꢀdꢇꢀ'a'ꢀvàꢀ'%'ꢀ
làꢀnhꢊngꢀhꢠngꢀkýꢀtꢘ.ꢀ
Hꢠngꢀnguyênꢀlàꢀnhꢊngꢀsꢑꢀmàꢀkhôngꢀcóꢀphꢚnꢀthꢅpꢀphân.ꢀVíꢀdꢇꢀ100ꢀ
vàꢀꢓ100ꢀlàꢀnhꢊngꢀhꢠngꢀnguyên.ꢀ
Hꢠngꢀ sꢑꢀ thꢘcꢀ yêuꢀ cꢚuꢀ mꢔtꢀ dꢖuꢀ chꢖmꢀ thꢅpꢀ phânꢀ phânꢀ cáchꢀ phꢚnꢀ
nguyênꢀvꢙiꢀphꢚnꢀthꢅpꢀphân.ꢀVíꢀdꢇꢀ123.45ꢀlàꢀmꢔtꢀhꢠngꢀsꢑꢀthꢘc.ꢀ
Víꢀdꢇꢀvꢌꢀcáchꢀviꢕtꢀcácꢀlꢏaiꢀhꢠngꢀsꢑ:ꢀ
Kiꢋuꢀdꢈꢀliꢔuꢀ Cácꢀvíꢀdꢕꢀvꢜꢀhꢘngꢀ
Ghiꢀchúꢀ
intꢀ
longꢀintꢀ
1,ꢀ123,ꢀ21000,ꢀ234ꢀ
35000L,ꢀ34lꢀ
ꢀ
CóꢀkýꢀtꢘꢀlꢀhoꢜcꢀLꢀꢃꢀcuꢑiꢀ
CóꢀkýꢀtꢘꢀuꢀhoꢜcꢀUꢀꢃꢀcuꢑiꢀ
CóꢀkýꢀtꢘꢀfꢀhoꢜcꢀFꢀꢃꢀcuꢑiꢀ
ꢀ
unsignedꢀintꢀ 10000U,ꢀ987u,ꢀ40000Uꢀ
floatꢀ
123.23f,ꢀ4.34eꢓ3Fꢀ
doubleꢀ
123.23,ꢀ1.0,ꢀ0.9876324ꢀ
longꢀdoubleꢀ 1001.2Lꢀ
CóꢀkýꢀtꢘꢀlꢀhoꢜcꢀLꢀꢃꢀcuꢑiꢀ
14/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
7.ꢀHꢘngꢀchuꢝiꢀkýꢀtꢒꢀ(stringꢀconstants)ꢀ
C/C++ꢀcungꢀcꢖpꢀmꢔtꢀlꢏaiꢀhꢠngꢀkhácꢀgꢏiꢀlàꢀchuꢤi.ꢀMꢔtꢀchuꢤiꢀlàꢀmꢔtꢀ
tꢅpꢀcácꢀkýꢀtꢘꢀñưꢁcꢀbaoꢀquanhꢀbꢃiꢀcꢜpꢀdꢖuꢀnháyꢀñôi.ꢀVíꢀdꢇ,ꢀ"Thisꢀisꢀ
aꢀstring"ꢀlàꢀmꢔtꢀchuꢤi.ꢀ
Lưuꢀýꢀphânꢀbiꢈtꢀhꢠngꢀchuꢤiꢀvàꢀhꢠngꢀkýꢀtꢘ.ꢀMꢔtꢀhꢠngꢀkýꢀtꢘꢀlàꢀmꢔtꢀ
kýꢀtꢘꢀbaoꢀquanhꢀbꢃiꢀcꢜpꢀdꢖuꢀnháyꢀñơn.ꢀDoꢀñó,ꢀ'a'ꢀlàꢀhꢠngꢀkýꢀtꢘꢀ
nhưngꢀ"a"ꢀlàꢀhꢠngꢀchuꢤi.ꢀ
8.ꢀHꢘngꢀkýꢀtꢒꢀñꢞcꢀbiꢔtꢀ(escapeꢀsequences)ꢀ
C/C++ꢀcóꢀnhꢊngꢀhꢠngꢀkýꢀtꢘꢀñꢜcꢀbiꢈtꢀmàꢀkhôngꢀthꢄꢀbiꢄuꢀdiꢢnꢀnhưꢀ
nhꢊngꢀhꢠngꢀkýꢀtꢘꢀthôngꢀthưꢋng.ꢀNhꢊngꢀhꢠngꢀnàyꢀcònꢀgꢏiꢀlàꢀescapeꢀ
sequences.ꢀSauꢀñâyꢀlàꢀdanhꢀsáchꢀcácꢀhꢠngꢀñꢜcꢀbiꢈtꢀñó:ꢀ
Mãꢀ
\bꢀ
\fꢀ
Ýꢀnghĩaꢀ
Lùiꢀsangꢀtráiꢀ1ꢀkýꢀtꢘꢀ
Vꢌꢀñꢚuꢀdòngꢀ
\nꢀ
\rꢀ
Sangꢀdòngꢀmꢙiꢀ
Xuꢑngꢀdòngꢀ
\tꢀ
Tabꢀtheoꢀchiꢌuꢀngangꢀ
\"ꢀ
Dꢖuꢀnháyꢀñôiꢀ
\'ꢀ
Dꢖuꢀnháyꢀñơnꢀ
\0ꢀ
\\ꢀ
Nullꢀ
Dꢖuꢀ\ꢀ
\vꢀ
\aꢀ
\?ꢀ
\Nꢀ
\xNꢀ
Tabꢀtheoꢀchiꢌuꢀñꢆngꢀ
Cꢉnhꢀbáoꢀ
Dꢖuꢀhꢨiꢀ
Hꢠngꢀbátꢀphânꢀ(vꢙiꢀNꢀlàꢀmꢔtꢀhꢠngꢀbátꢀphân)ꢀ
Hꢠngꢀthꢅpꢀlꢇcꢀphânꢀ(vꢙiꢀNꢀlàꢀmꢔtꢀhꢠngꢀthꢅpꢀlꢇcꢀphân)ꢀ
Xemꢀxétꢀvíꢀdꢇꢀsau:ꢀ
\nꢀ
Enterꢀ
#includeꢀ<iostream.h>ꢀ
voidꢀmain(void)ꢀ
{ꢀ
Items:ꢀ
Item1ꢀ
ꢀꢀcoutꢀ<<"Items:\n";ꢀ
ꢀꢀcoutꢀ<<”\tItem1\n”;ꢀ
ꢀꢀcoutꢀ<<”\tItem2\n”;ꢀ
ꢀꢀcoutꢀ<<”\tItem3\n”;ꢀ
outputꢀ
\tꢀ
Item2ꢀ
Item3ꢀ
}ꢀ
tabꢀ
ꢀ
ꢀ
15/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
ꢀ
9.ꢀToánꢀtꢆꢀ(operators)ꢀ
C/C++ꢀ cóꢀ bꢑnꢀ loꢂiꢀ toánꢀ tꢝ:ꢀ sꢑꢀ hꢏcꢀ (arithmetic),ꢀ quanꢀ hꢈꢀ
(relational),ꢀluꢅnꢀlýꢀ(logical),ꢀvàꢀbitwise.ꢀ
ꢀ
9.1.ꢀToánꢀtꢆꢀgánꢀ(assignmentꢀoperator)ꢀ
Dꢂngꢀtꢤngꢀquátꢀcꢎaꢀtoánꢀtꢝꢀgánꢀlàꢀ
variableName = expression;
variableName:ꢀTênꢀbiꢕnꢀ
expression:ꢀBiꢄuꢀthꢆcꢀ
Lưuꢀ ý,ꢀ phíaꢀ bênꢀ tráiꢀ dꢖuꢀ bꢠngꢀ phꢉiꢀ làꢀ mꢔtꢀ biꢕnꢀ hayꢀ conꢀ trꢨꢀ vàꢀ
khôngꢀthꢄꢀlàꢀhàmꢀhayꢀhꢠng.ꢀ
Víꢀdꢇ:ꢀ
totalꢀ=ꢀaꢀ+ꢀbꢀ+ꢀcꢀ+ꢀd;ꢀ
ꢀ
9.2.ꢀChuyꢋnꢀñꢝiꢀkiꢋuꢀtrongꢀcâuꢀlꢔnhꢀgánꢀ
Khiꢀnhꢊngꢀbiꢕnꢀcꢎaꢀmꢔtꢀkiꢄuꢀkꢕtꢀhꢁpꢀvꢙiꢀnhꢊngꢀbiꢕnꢀcꢎaꢀmꢔtꢀkiꢄuꢀ
khácꢀthìꢀmꢔtꢀsꢘꢀchuyꢄnꢀñꢤiꢀkiꢄuꢀxꢉyꢀra.ꢀðꢑiꢀvꢙiꢀcâuꢀlꢈnhꢀgán,ꢀgiáꢀ
trꢗꢀcꢎaꢀbiꢄuꢀthꢆcꢀbênꢀ phꢉiꢀdꢖuꢀbꢠngꢀñưꢁcꢀ tꢘꢀñꢔngꢀchuyꢄnꢀthànhꢀ
kiꢄuꢀdꢊꢀliꢈuꢀcꢎaꢀbiꢕnꢀbênꢀtráiꢀdꢖuꢀbꢠng.ꢀ
Víꢀdꢇ:ꢀ
intꢀi=100;ꢀ
doubleꢀdꢀ=ꢀ123.456;ꢀ
ꢀ
Nꢕuꢀthꢘcꢀthiꢀlꢈnhꢀ
iꢀ=ꢀd;ꢀ
thìꢀiꢀsꢥꢀcóꢀgiáꢀtrꢗꢀlàꢀ123ꢀvìꢀ123.456ꢀsꢥꢀtꢘꢀñꢔngꢀchuyꢄnꢀthànhꢀsꢑꢀ
nguyênꢀnênꢀbꢗꢀcꢦtꢀbꢨꢀphꢚnꢀthꢅpꢀphân.ꢀSꢘꢀchuyꢄnꢀñꢤiꢀkiꢄuꢀnàyꢀgꢏiꢀ
làꢀchuyꢄnꢀñꢤiꢀkiꢄuꢀbꢗꢀmꢖtꢀmátꢀthôngꢀtin.ꢀ
ꢀ
16/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
Nꢕuꢀthꢘcꢀthiꢀlꢈnhꢀ
dꢀ=ꢀi;ꢀ
thìꢀdꢀsꢥꢀcóꢀgiáꢀtrꢗꢀlàꢀ100.0.ꢀSꢘꢀchuyꢄnꢀñꢤiꢀkiꢄuꢀnàyꢀgꢏiꢀlàꢀchuyꢄnꢀ
ñꢤiꢀkiꢄuꢀkhôngꢀmꢖtꢀmátꢀthôngꢀtin.ꢀ
ꢀ
Tómꢀlꢂi,ꢀkhiꢀchuyꢄnꢀñꢤiꢀkiꢄuꢀtꢡꢀkiꢄuꢀdꢊꢀliꢈuꢀcóꢀmiꢌnꢀgiáꢀtrꢗꢀnhꢨꢀ
sangꢀkiꢄuꢀdꢊꢀliꢈuꢀcóꢀmiꢌnꢀgiáꢀtrꢗꢀlꢙnꢀhơnꢀthìꢀviꢈcꢀchuyꢄnꢀñꢤiꢀkiꢄuꢀ
nàyꢀlàꢀanꢀtoànꢀvìꢀkhôngꢀbꢗꢀmꢖtꢀmátꢀthôngꢀtin.ꢀThꢆꢀtꢘꢀtăngꢀdꢚnꢀtꢡꢀ
kiꢄuꢀdꢊꢀliꢈuꢀcóꢀmiꢌnꢀgiáꢀtrꢗꢀnhꢨꢀñꢕnꢀkiꢄuꢀdꢊꢀliꢈuꢀcóꢀmiꢌnꢀgiáꢀtrꢗꢀlꢙnꢀ
làꢀcharꢀꢀꢀintꢀꢀꢀlongꢀꢀꢀfloatꢀꢀꢀdouble.ꢀ
ꢀ
Khiꢀchuyꢄnꢀñꢤiꢀkiꢄuꢀdꢊꢀliꢈuꢀcóꢀmiꢌnꢀgiáꢀtrꢗꢀlꢙnꢀsangꢀkiꢄuꢀdꢊꢀliꢈuꢀ
cóꢀmiꢌnꢀgiáꢀtrꢗꢀnhꢨꢀhơnꢀthìꢀviꢈcꢀchuyꢄnꢀñꢤiꢀkiꢄuꢀnàyꢀlàꢀkhôngꢀanꢀ
toànꢀvìꢀcóꢀthꢄꢀmꢖtꢀmátꢀthôngꢀtin.ꢀThꢆꢀtꢘꢀgiꢉmꢀdꢚnꢀtꢡꢀkiꢄuꢀdꢊꢀliꢈuꢀ
cóꢀ miꢌnꢀ giáꢀ trꢗꢀ lꢙnꢀ ñꢕnꢀ kiꢄuꢀ dꢊꢀ liꢈuꢀ cóꢀ miꢌnꢀ giáꢀ trꢗꢀ nhꢨꢀ làꢀꢀ
doubleꢀꢀꢀfloatꢀꢀꢀlongꢀꢀꢀintꢀꢀꢀchar.ꢀ
ꢀ
Víꢀdꢇ:ꢀ
intꢀiꢀ=ꢀ100;ꢀ
longꢀlꢀ=ꢀ200;ꢀ
floatꢀfꢀ=ꢀ123.456f;ꢀ
doubleꢀdꢀ=ꢀ1.23456789;ꢀ
ꢀ
Khꢉoꢀsátꢀcácꢀlꢈnhꢀgánꢀsau:ꢀ
intꢀn;ꢀlongꢀm;ꢀfloatꢀp;ꢀdoubleꢀq;ꢀ
nꢀ=ꢀiꢀ+ꢀlꢀ+ꢀfꢀ+ꢀd;ꢀ//ꢀ(1)ꢀ
mꢀ=ꢀiꢀ+ꢀlꢀ+ꢀfꢀ+ꢀd;ꢀ//ꢀ(2)ꢀ
pꢀ=ꢀiꢀ+ꢀlꢀ+ꢀfꢀ+ꢀd;ꢀ//ꢀ(3)ꢀ
qꢀ=ꢀiꢀ+ꢀlꢀ+ꢀfꢀ+ꢀd;ꢀ//ꢀ(4)ꢀ
17/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
ꢀ
(1)ꢀ
iꢀ
lꢀ
fꢀ
dꢀ
ꢀꢀ
100ꢀ
200ꢀ
123.456ꢀ
1.23456789ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
doubleꢀ
100.0ꢀ
doubleꢀ
200.0ꢀ
doubleꢀ
doubleꢀ
123.456ꢀ
1.23456789ꢀ
424.69056789ꢀ
intꢀ
nꢀcóꢀgiáꢀtrꢗꢀlàꢀ424ꢀ
(3)ꢀ
iꢀ
lꢀ
fꢀ
dꢀ
100ꢀ
200ꢀ
123.456ꢀ
1.23456789ꢀ
doubleꢀ
100.0ꢀ
doubleꢀ
200.0ꢀ
doubleꢀ
doubleꢀ
123.456ꢀ
1.23456789ꢀ
424.69056789ꢀ
floatꢀ
pꢀcóꢀgiáꢀtrꢗꢀlàꢀ424.690567ꢀ
18/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
ꢀ
ꢀ
(4)ꢀ
iꢀ
lꢀ
fꢀ
dꢀ
ꢀ
100ꢀ
200ꢀ
123.456ꢀ
1.23456789ꢀ
ꢀ
ꢀ
ꢀ
doubleꢀ
doubleꢀ
200.0ꢀ
doubleꢀ
doubleꢀ
ꢀ
100.0ꢀ
ꢀ
123.456ꢀ
1.23456789ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
ꢀ
424.69056789ꢀ
qꢀcóꢀgiáꢀtrꢗꢀlàꢀ424.69056789ꢀ
Kꢕtꢀluꢅn:ꢀTrưꢋngꢀhꢁpꢀ(1)ꢀvàꢀ(3):ꢀmꢖtꢀmátꢀthôngꢀtin.ꢀTrưꢋngꢀhꢁpꢀ
(4)ꢀkhôngꢀmꢖtꢀmátꢀthôngꢀtin.ꢀ
ꢀ
10.ꢀCácꢀtoánꢀtꢆꢀsꢙꢀhꢟcꢀ(arithmeticꢀoperators)ꢀ
Cácꢀtoánꢀtꢝꢀsꢑꢀhꢏcꢀgꢛm:ꢀ+ꢀ(cꢔng),ꢀꢓꢀ(trꢡ),ꢀ*ꢀ(nhân),ꢀ/ꢀ(chia),ꢀvàꢀ%ꢀ
(lꢖyꢀphꢚnꢀdưꢀcꢎaꢀphépꢀchiaꢀnguyên).ꢀꢀ
Khiꢀtꢝꢀsꢑꢀvàꢀmꢟuꢀsꢑꢀcꢎaꢀphépꢀchiaꢀlàꢀsꢑꢀnguyênꢀthìꢀñóꢀlàꢀphépꢀchiaꢀ
nguyênꢀnênꢀphꢚnꢀdưꢀcꢎaꢀphépꢀchiaꢀnguyênꢀbꢗꢀcꢦtꢀbꢨ.ꢀVíꢀdꢇ,ꢀ5/2ꢀthìꢀ
kꢕtꢀquꢉꢀlàꢀ2.ꢀꢀ
Toánꢀ tꢝꢀ lꢖyꢀ phꢚnꢀ dưꢀ %ꢀ (modulusꢀ operator)ꢀ chꢞꢀ ápꢀ dꢇngꢀ vꢙiꢀ sꢑꢀ
nguyênꢀvàꢀtrꢉꢀvꢌꢀphꢚnꢀdư.ꢀVíꢀdꢇ,ꢀ7%2ꢀthìꢀkꢕtꢀquꢉꢀlàꢀ1.ꢀ
ꢀ
11.ꢀToánꢀtꢆꢀ++ꢀvàꢀꢠꢠꢀ(incrementꢀandꢀdecrementꢀoperators)ꢀ
C/C++ꢀcóꢀhaiꢀtoánꢀtꢝꢀrꢖtꢀthưꢋngꢀdùngꢀlàꢀ++ꢀvàꢀꢓꢓ.ꢀToánꢀtꢝꢀ++ꢀcꢔngꢀ
1ꢀñꢕnꢀtoánꢀhꢂngꢀcꢎaꢀnóꢀvàꢀtoánꢀtꢝꢀꢓꢓꢀthìꢀtrꢡꢀ1ꢀtꢡꢀtoánꢀhꢂngꢀcꢎaꢀnó.ꢀ
19/124ꢀ
GiáoꢀtrìnhꢀPPꢀlꢁpꢀtrìnhꢀ
TT.CôngꢀNghꢂꢀThôngꢀTinꢀ
Víꢀdꢇ:ꢀ
x++;ꢀ//ꢀtuongꢀduongꢀxꢀ=ꢀxꢀ+ꢀ1;ꢀ
xꢅꢅ;ꢀ//ꢀtuongꢀduongꢀxꢀ=ꢀxꢀꢅꢀ1;ꢀ
ꢀ
Toánꢀ tꢝꢀ ++ꢀ vàꢀ ꢓꢓꢀ cóꢀ thꢄꢀ ñꢜtꢀ phíaꢀ trưꢙcꢀ (prefix)ꢀ hoꢜcꢀ phíaꢀ sauꢀ
(postfix)ꢀtoánꢀhꢂng.ꢀSꢘꢀkhácꢀnhauꢀcꢎaꢀ2ꢀtrưꢋngꢀhꢁpꢀnàyꢀlàꢀkhiꢀtoánꢀ
tꢝꢀ++ꢀvàꢀꢓꢓꢀñꢆngꢀtrưꢙcꢀtoánꢀhꢂng,ꢀhànhꢀñꢔngꢀtăngꢀvàꢀgiꢉmꢀtrênꢀtoánꢀ
hꢂngꢀ ñưꢁcꢀ thꢘcꢀ hiꢈnꢀ trưꢙc,ꢀ sauꢀ ñóꢀ giáꢀ trꢗꢀ mꢙiꢀ cꢎaꢀ toánꢀ hꢂngꢀ sꢥꢀ
dùngꢀñꢄꢀthamꢀgiaꢀvàoꢀviꢈcꢀñꢗnhꢀtrꢗꢀcꢎaꢀbiꢄuꢀthꢆc.ꢀ
ꢀ
Víꢀdꢇ:ꢀKhꢉoꢀsátꢀñoꢂnꢀlꢈnhꢀsauꢀ
intꢀxꢀ=ꢀ100;ꢀ
intꢀn,m;ꢀ
Nꢕuꢀthꢘcꢀhiꢈnꢀlꢈnh:ꢀ
nꢀ=ꢀ++xꢀ+ꢀ1;ꢀ//ꢀnꢀsꢆꢀcóꢀgiáꢀtrꢄꢀlàꢀ102ꢀ(1)ꢀ
ꢀ
Nꢕuꢀthꢘcꢀhiꢈnꢀlꢈnh:ꢀ
nꢀ=ꢀx++ꢀ+ꢀ1;ꢀ//ꢀnꢀsꢆꢀcóꢀgiáꢀtrꢄꢀlàꢀ101ꢀ(2)ꢀ
Sauꢀkhiꢀlꢈnhꢀ(1)ꢀhayꢀ(2)ꢀñưꢁcꢀthꢘcꢀthiꢀthìꢀxꢀcóꢀgiáꢀtrꢗꢀlàꢀ101ꢀ
ꢀ
Tươngꢀtꢘ,ꢀnꢕuꢀthꢘcꢀhiꢈnꢀlꢈnh:ꢀ
mꢀ=ꢀꢅꢅxꢀ+ꢀ1;ꢀ//ꢀnꢀsꢆꢀcóꢀgiáꢀtrꢄꢀlàꢀ100ꢀ(3)ꢀ
ꢀ
Nꢕuꢀthꢘcꢀhiꢈnꢀlꢈnh:ꢀ
mꢀ=ꢀxꢅꢅꢀ+ꢀ1;ꢀ//ꢀnꢀsꢆꢀcóꢀgiáꢀtrꢄꢀ101ꢀ(4)ꢀ
ꢀ
Sauꢀkhiꢀlꢈnhꢀ(3)ꢀhayꢀ(4)ꢀñưꢁcꢀthꢘcꢀthiꢀthìꢀxꢀcóꢀgiáꢀtrꢗꢀlàꢀ99ꢀ
ꢀ
Khiꢀcácꢀtoánꢀtꢝꢀsꢑꢀhꢏcꢀxuꢖtꢀhiꢈnꢀtrongꢀmꢔtꢀbiꢄuꢀthꢆc,ꢀthìꢀñꢔꢀưuꢀtiênꢀ
thꢘcꢀhiꢈnꢀnhưꢀsau:ꢀ
20/124ꢀ
Tải về để xem bản đầy đủ
124 trang
21220
Free
Bạn đang xem 20 trang mẫu của tài liệu "Giáo trình Phương pháp lập trình", để tải tài liệu gốc về máy hãy click vào nút Download ở trên
File đính kèm:
- giao_trinh_phuong_phap_lap_trinh.pdf
