P. 1
Giao Trinh C++ - Nguyen Phu Quang V.1.3

Giao Trinh C++ - Nguyen Phu Quang V.1.3

4.82

|Views: 2,634|Likes:
Được xuất bản bởiDinhTuan
Giao trinh cua thay Nguyen Phu Quang - DHXD - Dung de huog dan va on luyen doi tuyen tin hoc
Giao trinh cua thay Nguyen Phu Quang - DHXD - Dung de huog dan va on luyen doi tuyen tin hoc

More info:

Published by: DinhTuan on Oct 15, 2008
Bản quyền:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as DOC, PDF, TXT or read online from Scribd
See more
See less

05/09/2014

pdf

text

original

NGUYỄN PHÚ QUẢNG

BỘ MÔN TIN HỌC XÂY DỰNG
KHOA CÔNG NGHỆ THÔNG TIN – ĐẠI HỌC XÂY DỰNG
LP T!"NH C##
Tài liệu lưu hành nội bộ
version 0.0.2
Lập trình C++ Nguyễn Phú Quảng
Mục lục
I. MỞ ĐẦU.............................................................................................................................4
Ì.1. Môi trường phát triển.................................................................................................................... ..........4
Ì.2. Chương trình đầu tiên...................................................................................................... ......................4
Ì.3. Ìnput & Output................................................................................................................ ........................5
II. NGÔN NGỮ.......................................................................................................................5
ÌÌ.1. Cơ bán vê ngôn ngü.................................................................................................. ...........................5
ÌÌ.2. Kiểu................................................................................................................................... ....................5
ÌÌ.3. Chuyển đôi giüa các kiểu...................................................................................................... ................7
ÌÌ.4. Biểu thúc & toán tú...................................................................................................... .........................7
III. LỆNH.................................................................................................................................9
ÌÌÌ.1. Lênh dang biểu thúc.......................................................................................................................... ...9
ÌÌÌ.2. Khôi lênh.................................................................................................................. ............................9
ÌÌÌ.3. Lênh rë nhánh.............................................................................................................. ........................9
ÌÌÌ.4. Vòng lãp for...................................................................................................................... ..................10
ÌÌÌ.5. Vòng lãp while................................................................................................................. ...................13
ÌÌÌ.6. Vòng lãp do...while........................................................................................................ .....................13
ÌÌÌ.7. Nháy không điêu kiên......................................................................................................... ................13
IV. HÀM................................................................................................................................13
ÌV.1. Ðjnh nghïa hàm................................................................................................................. .................13
ÌV.2. Ví dụ khai báo hàm........................................................................................................................... ..14
ÌV.3. Khi nào sú dụng hàm...................................................................................................... ...................14
ÌV.4. Hàm đưoc goi như thê nào?........................................................................................ ......................14
ÌV.5. Hàm goi đê quy........................................................................................................... .......................15
V. MẢNG..............................................................................................................................17
V.1. Ðjnh nghïa............................................................................................................................ ...............17
V.2. Truy câp phần tú cúa máng............................................................................................................. ....17
V.3. Khói tao máng......................................................................................................................... ............17
V.4. Máng nhiêu chiêu.............................................................................................................. ..................17
V.5. Sú dụng máng làm tham sô cúa hàm................................................................................................ ..17
VI. CON TRỎ.......................................................................................................................17
VÌ.1. Khai báo con tró................................................................................................................... ..............17
VÌ.2. Các toán tú trên con tró............................................................................................... ......................17
VÌ.3. Con tró và máng.............................................................................................................................. ...17
VÌ.4. Con tró hàm............................................................................................................... ........................17
VII. STRUCT........................................................................................................................17
VÌÌ.1. Ðjnh nghïa Struct.................................................................................................... ..........................17
VÌÌ.2. Khai báo biên................................................................................................................. ...................18
VÌÌ.3. Truy câp trường...................................................................................................... ..........................18
VIII. Stream..........................................................................................................................18
VÌÌÌ.1. File stream............................................................................................................... ........................18
VÌÌÌ.2. String stream............................................................................................................................ ........19
VÌÌÌ.3. Ghi có đjnh dang............................................................................................................... ...............19
IX. KIEU NGUÒI DÙNG Đ[NH NGHÏA...............................................................................21
X. CÁP PHÁT BQ NHÓ ĐQNG...........................................................................................21
2
Lập trình C++ Nguyễn Phú Quảng
XI. LÓP................................................................................................................................21
XII. MÃU...............................................................................................................................21
XIII. THU VIỆN CHUAN......................................................................................................21
XÌÌÌ.1. Các khái niêm......................................................................................................... .........................21
XÌÌÌ.2. Kiểu vector..................................................................................................................... ..................22
XÌÌÌ.3. Kiểu string...................................................................................................................... ..................26
XÌÌÌ.4. Kiểu list (danh sách).................................................................................................................... .....29
XÌÌÌ.5. Kiểu set (tâp hop)................................................................................................. ...........................32
XÌÌÌ.6. Kiểu map (ánh xa).................................................................................................................. ..........32
XÌÌÌ.7. Kiểu hash_map (ánh xa dùng máng bãm)................................................................ .......................34
XÌÌÌ.8. Kiểu hash_set (tâp hop)............................................................................................................ .......35
XÌÌÌ.9. Thuât toán (Algorithm).................................................................................................................... ..35
XIV. GIẢI MQT SÓ BÀI TOÁN BANG STL.........................................................................43
XÌV.1. Quán lý sinh viên............................................................................................................................ ..43
XÌV.2. Rào đât.................................................................................................................. ..........................45
XÌV.3. Robot..................................................................................................................... ..........................46
XÌV.4. Dijsktra.............................................................................................................................. ...............47
XÌV.5. Hop diên tích hình chü nhât............................................................................................................ .47
XV. INPUT VÀ OUTPUT......................................................................................................49
3
Lập trình C++ Nguyễn Phú Quảng
I. MỞ ĐẦU
C++ là ngôn ngữ mạnh, được phát triển từ ngôn ngữ C. Học C++ đem lại nhiề lợi th! ch" #ạn $%i
&h'i lượng m( ng)n $à" l"ại l%n nh*t tr"ng các ngôn ngữ, c+ng như t,nh tư-ng đ)ng $%i h. h!t
các ngôn ngữ t/0 C 1C2li&e l0ng0ge3.
4ài li5 nà6 m"ng m'n gi7p #ạn c8 m9t cái nh:n t;ng thể $%i cách ti!p c<n th<t ng=n gọn. C* tr7c
>ách ?/0 tr@n c'n AC++ in 0 nt>hellA cB0 nhà C*t #Dn EFGeill6.
4ại Hi5t n0m, đ( c8 r*t nhiề c'n >ách gi%i thi5 $ề C, C++. 4r"ng tài li5 nà6, ch7ng tôi &hông
m0ng th0m $ọng CI6 ?/ng m9t giá" tr:nh $ề C++ mà chJ là những đ7c &!t &inh nghi5m mà ch7ng
tôi đ( tr/c ti!p làm $i5c $%i C++, nh*t là tr"ng những #ài t"án thi@n $ề giDi th<t.
Kọi g8p L Cin gMi $ề đN0 chJO ng6enphP0ngQgm0il.c"m. Rin chIn thành cDm -n mọi đ8ng g8p
cB0 các #ạn.
I.1. Môi truòng phát triên
Sể th<n ti5n ch" $i5c học ngôn ngữ, ch7ng tôi Cin gi%i thi5 2 môi trưTng Pen th9c để #ạn c8
thể th/c hành l<p tr:nh C++.
Kicr">"Ut Hi>0l C++ 1V.W, X.W, X.Y3O ph.n mềm nà6 nZm tr"ng #9 ph.n mềm Kicr">"Ut Hi>0l
[t?i".
\e$C++ ].WO ^ạn c8 thể tDi mi_n ph, từ đN0 chJ httpO``aaa.#l""?>he?.net`?e$cpp.html, ch7ng tôi
&h6!n &h,ch các #ạn >M ?bng ph.n mềm mi_n ph, nà6.
4"àn #9 chư-ng tr:nh minh họ0 đề c8 thể chạ6 tr@n cD 2 môi trưTng HC++ $à \e$C.
I.2. Chuong trình dâu tiên
Kc \e$C, #ạn tạ" Uile m%i, gd $à" đ"ạn chư-ng tr:nh ?ư%i đI6 $à lư lại 1t*t nhi@n là &hông gd $à"
>' ?eng, tr"ng t*t cD các chư-ng tr:nh minh họ0, ch7ng tôi >M ?bng >' ?eng để giDi th,ch ch"
chư-ng tr:nh3. [0 đ8 #*m Ctrl+fg để ?Nch chư-ng tr:nh, #*m Ctrl+fYW để chạ6 chư-ng tr:nh, #ạn
>h th*6 m9t màn h:nh mà đen $à ?eng chữ AHell" e$er6 #"?6iA, &hi #ạn gd Y ph,m #*t &j th: màn
h:nh mà đen >h đ8ng lại.
01 #include <iostream>
02 #include <stdio.h>
03
04 using namespace std;
05 int main() {
0 cout << !"ello e#er$ %od$&! << endl;
0' getchar();
0( )
\eng WY, W2O [M ?bng 2 thư $i5n i">tre0m $à >t?i".h
\eng WkO lhi các chư-ng tr:nh ?ài $à phmc tạp, $i5c đnt t@n ch" các #i!n, hàm gnp &h8 &hon. Sể ?_
?àng h-n &hi đnt t@n, ngưTi t0 chi0 t@n thành nhiề &hông gi0n &hác nh0 gọi là n0me>p0ce. >t? là
m9t n0me>p0ce được >M ?bng tr"ng i">tre0m $à m9t >' thư $i5n chpn &hác.
\eng W]O Hàm m0in là hàm &hông thể thi! tr"ng các chư-ng tr:nh C++. lhi chư-ng tr:nh được
th/c thi, n8 >h gọi đ!n hàm m0in.
\eng WVO 4r"ng C++, &hái ni5m >tre0m chJ m9t ?eng ?ữ li5 1đ. $à" h"nc đ. r03. 4r"ng trưTng
hợp nà6 c"t là ?eng ?ữ li5 r0 1mnc đNnh là màn h:nh3. [M ?bng t"án tM qq, ch7ng t0 th/c hi5n $i5c
đư0 2 ?ữ li5 l.n lượt là CI &L t/ AHell" e$er6 #"?6iA $à &L t/ C'ng ?eng en?l r0 màn h:nh.
k
Lập trình C++ Nguyễn Phú Quảng
\eng WXO getch0r13 là hàm gi7p chư-ng tr:nh ?ừng lại $à đợi ngưTi ?rng gd m9t ph,m #*t &j. 4h/c
ch*t, tr"ng $, ?b nà6 &hông c.n phDi ?ừng chư-ng tr:nh. shưng ?" đnc t,nh cB0 môi trưTng \e$C
$à HC là màn h:nh "tpt >h #i!n m*t >0 &hi chư-ng tr:nh chạ6 C"ng, ?" đ8 ch7ng tôi đư0 th@m
l5nh nà6 để ?ừng chư-ng tr:nh lại, gi7p các #ạn P0n >át th*6 CI &L t/ in tr@n màn h:nh.
I.3. Input & Output
II. NGÔN NGỮ
II.1. Co bán vê ngôn ngü
sgôn ngữ l<p c8 nhiề điểm tư-ng t/ $%i ngôn ngữ t/ nhi@n
2 Chm0 m9t t<p từ &h80 1gi'ng $%i từ $/ng cB0 ngôn ngữ t/ nhi@n3
2 Chm0 m9t l"ạt các P6 t=c &!t hợp các từ &h80, t"án tM $%i nh0 1gi'ng $%i ngữ pháp tr"ng
ngôn ngữ t/ nhi@n3
lhi #ạn đ( thạ" m9t ngôn ngữ l<p tr:nh, $i5c học m9t ngôn ngữ &hác là tư-ng đ'i đ-n giDn 1c+ng
như #ạn đ( học ti!ng tnh th: c8 thể học ti!ng uháp r*t nh0nh $: h0i ngôn ngữ nà6 c8 nhiề từ tư-ng
đ)ng $%i nh03.
Hi5c học ngôn C++ 1c+ng như học ti!ng tnh3 đem lại ch" #ạn lợi th! r*t l%n $: đI6 là ngôn ngữ
được >M ?bng ph; #i!n nh*t. H-n th! nữ0 c8 r*t nhiề các ngôn ngữ l<p tr:nh &hác được CI6 ?/ng
tr@n c- >c c7 pháp cB0 C++ 1gọi là các ngôn ngữ gi'ng2C v C2li&e3, ?" đ8 #ạn c8 thể ti!p c<n r*t
nh0nh $%i các ngôn ngữ nà6 n! đ( thông thạ" $%i C++.
II.2. Kiêu
II.2.1. Các kiêu co bán
uh.n nà6 tr:nh #à6 các &iể ?ữ li5 c- #Dn cB0 C++. 4r"ng gi%i hạn cB0 tài li5 nà6, tôi &hông tr:nh
#à6 $ề c"n trw. Knc ?r c"n trw là m9t tr"ng nhưng đnc điểm n;i #<t cB0 C++ nhưng t,nh phmc tạp
cB0 c"n trw ?_ gI6 nh.m lxn ch" ngưTi m%i làm Pen. Ch7ng t0 >h giDi P6!t các #ài t"án tr@n C++
mà &hông h"nc hạn ch! t'i đ0 >M ?bng c"n trw.
a. Kiêu sô
• Số nguyên
2 liể char 1Y #6te3O 12Y2y đ!n Y2X3
2 liể short 12 #6te3O 1232XVy đ!n 32XVX3
2 liể int, long 1k #6te3O 122 tz đ!n 2 tz3
2 4*t cD các &iể tr@n, n! #; >ng unsign O
o n>ign ch0rO
o n>ign >h"rtO
o n>ign intO
2 Hi5c l/0 chọn &iể ?ữ li5 tr"ng #ài t"án phbc th9c $à" $rng giá trN cB0 #i!n. lh"Dng giá
trN càng l%n, #i!n càng chi!m nhiề #9 nh%. Chư-ng tr:nh C++ ?Nch tr@n \e$C h"ạt đ9ng
tr@n môi trưTng {in?"a> thưTng là h5 điề hành 32 #it, >' ng6@n được >M ?bng ph; #i!n
nh*t là &iể int.
]
Lập trình C++ Nguyễn Phú Quảng
2 H, ?b
char a;
int % * 20;
long c * 30;
unsign char d * 200;
• Số thực
2 float 1k #6te3O [' th/c đ9 ch,nh Các đ-n.
2 double 1y #6te3O [' th/c đ9 ch,nh Các &|p.
• Logic
2 bool O c8 2 giá trN là true $à false
II.2.2. Các kiêu phúc
a. Kiêu máng
2 KDng là m9t ?(6 các ph.n tM crng &iể được >=p li@n ti!p nh0 tr"ng #9 nh%
2 Các ph.n tM được phIn #i5t $%i nh0 #ci chJ >', là các >' t.n t/ #=t đ. từ W
2 H, ?b
int a+100,; -- .hai %/o m0ng g1m 100 s2 int
-- a+0, l3 1 s2 int4 ph5n t6 75u ti8n c9a m0ng
-- a+1, l3 1 s2 int4 ph5n t6 th: 2 c9a m0ng
-- a+;;, l3 1 s2 int4 ph5n t6 cu2i c<ng c9a m0ng
long %+10,; -- .hai %/o m0ng g1m 10 s2 long
2 KDng được &h0i #á" the" $, ?b tr@n là mDng Y chiề. Chiề cB0 mDng là >' chJ >' >M ?bng
để Các đNnh m9t ph.n tM 1gi'ng như h5 tọ0 đ9 Y chiề, 2 chiề, 3 chiề3
2 H, ?b &h0i #0" $à >M ?bng mDng nhiề chiề như >0
int a+3,+3,; -- .hai %/o a l3 m0ng 2 chi=u (gi2ng nh> 1 %0ng)
-- a+0, l3 m?t m0ng 1 chi=u g1m 3 s2 ngu$8n (gi2ng nh> 1 d@ng c9a %0ng)
-- a+0,+0, l3 s2 int 75u ti8n c9a d@ng
-- a+0,+1, l3 s2 int th: 2 c9a d@ng
-- a+0,+2, l3 s2 int cu2i c<ng c9a d@ng
-- a+1, l3 d@ng th: 2 c9a %0ng
-- a+2, l3 d@ng cu2i c<ng c9a %0ng
a+1,+1, * 5; -- A/n gi/ trB c9a s2 ngu$8n C d@ng 14 c?t 1 l3 5
b. Kiêu struct
[trct là &iể ?ữ li5 ch" ph|p #ạn t<p hợp nhiề thành ph.n $à" tr"ng crng m9t #i!n. }*6 $, ?b
thông tin cB0 m9t điểm g)m 2 tọ0 đ9 C, 6, thông tin cB0 m9t đ"ạn th~ng g)m điểm đ. $à điểm
c'i.
[trct là &iể ?ữ li5, ?" đ8 #ạn phDi &h0i #á" &iể ?ữ li5 đ8 #Zng l5nh t6pe?eU r)i m%i c8 thể &h0i
#á" được các #i!n th9c &iể nà6. C7 pháp &h0i #á" >trct như >0O
struct <D8nEFiGu> { -- .hai %/o FiGu struct
<.iGuEtr>HngE1> <D8nEtr>HngE1>; -- Dr>Hng c9a struct (gi2ng Fhai %/o %iIn)
<.iGuEtr>HngE2> <D8nEtr>HngE2>4 <D8nEtr>HngE3>;
);
<D8nEFiGu> <%iInE1>4 <%iInE2>; -- .hai %/o %iIn thu?c FiGu mJi tKo ra
<%iInE1>.<D8nEtr>HngE1> * <Ai/EtrB>; -- Dru$ cLp tr>Hng dM liNu c9a %iIn
Các thành ph.n &h0i #á" #@n tr"ng >trct được gọi là trưTng 1Uiel?3. K9t >trct g)m nhiề trưTng,
#i!n th9c &iể >trct
V
Lập trình C++ Nguyễn Phú Quảng
II.2.3. Các kiêu stI
a. Kiêu string
b. Kiêu vector
c. Kiêu vector
II.3. Chuyên dôi giüa các kiêu
II.4. Biêu thúc & toán tú
II.4.1. Biêu thúc
^iể thmc là &!t hợp cB0 các t"án tM $à t"án hạng. 4"án hạng c8 thể là các >' h"nc các #i!n.
II.4.2. Toán tú
a. Các phép toán sô hçc
2 uh|p c9ng +
o 0 + #
2 uh|p trừ 2
o 0 2 #
2 uh|p nhIn •
o 0 • #
2 uh|p chi0 `O Ch7 L tr"ng ph|p chi0
o s! cD 2 t"án hạng crng là >' ng6@n th: ph|p chi0 là chi0 ng6@n
 YW ` 3 ch" giá trN 3
o s! Y tr"ng 2 t"án hạng là >' th/c th: ph|p chi0 là chi0 >' th/c
 YW.W ` 3 ch" giá trN 3.3333333
2 uh|p l*6 ?ưO €
o YW € 3 ch" giá trN Y
b. Các phép toán so sánh
2 [" >ánh #Zng ••
o YW •• 3 ch" giá trN U0l>e
o YW •• YW ch" giá trN tre
2 [" >ánh &hác i•
o YW i• 3 ch" giá trN tre
X
Lập trình C++ Nguyễn Phú Quảng
2 [" >ánh l%n h-n ‚
2 [" >ánh nhw h-n q
2 [" >ánh l%n h-n h06 #Zng ‚•
2 [" >ánh nhw h-n h06 #Zng q•
c. Các phép toán Iogic
2 uh|p t"án 0n? ƒƒ
o YW••3 ƒƒ ]‚kO ch" giá trN U0l>e
o YW‚3 ƒƒ ]‚kO ch" giá trN tre
2 uh|p t"án "r „„
o YW••3 „„ ]‚kO ch" giá trN tre
o YW••3 „„ ]qk ch" giá trN U0l>e
2 uh|p t"án n"t i
o i1YW••33 ch" giá trN
d. Các phép toán trên bit
2 uh|p t"án 0n? từng #it ƒ
o YW ƒ 3 • YWYW
2
ƒ WWYY
2
• WWYW
2
o YW ƒ Y] • YWYW
2
ƒ YYYY
2
•YWYW
2
2 uh|p t"án "r từng #it „
o YW „ 3 • YWYW
2
„ WWYY
2
• YWYY
2
o YW „ Y] • YWYW
2
„ YYYY
2
• YYYY
2
e. Các phép toán 1 ngôi
2 uh|p tong Y đ-n $N
o i++ 1chJ ?ành ch" #i!n c8 giá trN ng6@n3
2 uh|p giDm Y đ-n $N
o i…
2 uh|p tong giá trN cB0 #i!n
o i +• 2
2 uh|p giDm giá trN cB0 #i!n
o i 2• 2
2 uh|p nhIn giá trN cB0 #i!n $%i Y >'
o i •• ]
2 uh|p chi0 giá trN cB0 #i!n ch" Y >'
o i `• ]
2 Các ph|p t"án &hác như ƒ•, „•, ƒƒ•, „„• ... tư-ng t/
y
Lập trình C++ Nguyễn Phú Quảng
III. LỆNH
III.1. Lênh dang biêu thúc
III.1.1. Phép gán
4@n #i!n • ^iể thmc†
2 ^iể thmc c8 thể là Y hZng >'
2 ^iể thmc c8 thể là Y #i!n
2 ^iể thmc c8 thể là #i!n $à hZng >' &!t hợp $%i nh0 #ci t"án tM
III.2. Khôi Iênh
Các &h'i l5nh để phIn chư-ng tr:nh thành nhiề &h'i c"n. Hi5c phIn &h'i gi7p chư-ng tr:nh rd
ràng, ?_ hiể h-n the" ng6@n t=c chi0 để trN. K9t &h'i l5nh được đnt tr"ng cnp ng"nc ‡ ˆ $à được
c"i như m9t l5nh đ-n.
C++ ch" ph|p &h0i #á" #i!n tại #*t &j n-i nà" tr"ng chư-ng tr:nh. ^i!n &h0i #á" tr"ng &h'i l5nh
nà" th: chJ t)n tại tr"ng &h'i chư-ng tr:nh đ8 1#i!n &h0i #á" tr"ng &h'i chư-ng tr:nh tr"ng &hông
thể >M ?bng tr"ng &h'i chư-ng tr:nh ng"ài3.
H, ?b $ề $i5c >M ?bng các &h'i chư-ng tr:nh.
if (a>%) {
int m; -- OiIn m Fhai %/o trong Fh2i iP (a>%)
m * 1; -- m cQ thG 7>Rc s6 dSng tKi c<ng Fh2i ch>Tng trUnh
if (d>e) {
m * 5; -- m cQ thG 7>Rc s6 dSng tKi Fh2i ch>Tng trUnh %8n trong
)
) else {
m * 10; -- m FhVng thG s6 dSng 7>Rc C Fh2i ch>Tng trUnh ngo3i
)
III.3. Lênh rë nhánh
}5nh iU >M ?bng để c8 h06 &hông th/c hi5n m9t đ"ạn chư-ng tr:nh the" m9t điề &i5n 1gọi là rh
nhánh3. }5nh iU g)m 2 ?ạngO r7t gọn $à đ.6 đB
2 \ạng r7t gọnO s! qSiề‰&i5n‚ đ7ng th: th/c hi5n q}5nh‚
if (<Wi=uEFiNn>) {
<XNnh>
)
o qSiề‰&i5n‚ c8 thể là
 K9t #iể thmc l"gic
 K9t #iể thmc &iể >' 1>' &hác W được c"i là đ7ng, #Zng W là >0i3
o s! q}5nh‚ chJ là Y l5nh đ-n, #ạn &hông c.n để tr"ng &h'i chư-ng tr:nh #Zng cnp
ng"nc ‡ˆ. 46 nhi@n, $i5c nà6 &hông được &h6!n &h,ch.
2 \ạng đ.6 đBO s! qSiề‰&i5n‚ là đ7ng th: th/c hi5n q}5nh‰n!‰đ7ng‚, ngược lại th/c
hi5n q}5nh‰n!‰>0i‚
if (<Wi=uEFiNn>) {
<XNnhEnIuE7Yng>;
) else {
<XNnhEnIuEsai>;
)
ŠU là m9t c* tr7c điề &hiển được >M ?bng ph; #i!n nh*t. S"ạn chư-ng tr:nh >0 >h n@ $, ?b >M
?bng l5nh iU.
g
Lập trình C++ Nguyễn Phú Quảng
#include <iostream>
#include <stdli%.h>
using namespace std;
int main ()
{
int gio;
cout << !Zhap #ao gio (0[24)\ !;
cin >> gio;
if (gio<12)
{
cout << !]hao %uoi sang!;
) else
{
cout << !]hao %uoi chieu!;
)
getchar();
getchar();
)
III.4. Vòng Iåp for
III.4.1. Cú pháp vòng Iåp for
Heng lnp U"r cB0 C++ &hái Pát h-n $eng lnp U"r cB0 u0>c0l. ^ạn c8 thể >M ?bng $eng lnp $%i c7
pháp r*t mềm ?‹" ch" nhiề h"àn cDnh &hác nh0. C7 pháp cB0 $eng lnp U"r như >0O
for (<XNnhEFhCiEtKo> ; <Wi=uEFiNn> ; <XNnhEtha$E7^i>)
{
<XNnhEl_p>;
)
4r:nh t/ th/c hi5n cB0 $eng lnp như >0O
2 4h/c hi5n q}5nh‰&hci‰tạ"‚
2 liểm tr0 qSiề‰&i5n‚
o s! qSiề‰&i5n‚ là đ7ngO
 4h/c hi5n q}5nh‰lnp‚
 4h/c hi5n q}5nh‰th06‰đ;i‚ để th06 đ;i trạng thái
 }np lại #ư%c thm 2 1liểm tr0 điề &i5n3
o s! qSiề‰&i5n‚ >0i, th"át &hwi $eng lnp
R|t $, ?b >0O
for (int i*0; i<3; i``)
{
cout << !i * ! << i << endl;
)
2 4h/c hi5n l5nh &hci tạ" 1i•W3
2 liểm tr0 điề &i5n 1iq33
o i•W n@n điề &i5n là đ7ng
 4h/c hi5n l5nh c"t... l5nh nà6 $i!t r0 màn h:nh ?eng chữ Ai • WA
 4h/c hi5n l5nh th06 đ;i i++ 1i tong từ W thành Y3
 }np lại #ư%c &iểm tr0
2 liểm tr0 điề &i5n 1iq33
o i•Y n@n điề &i5n là đ7ng
 4h/c hi5n l5nh c"t... l5nh nà6 $i!t r0 màn h:nh ?eng chữ Ai • YA
YW
Lập trình C++ Nguyễn Phú Quảng
 4h/c hi5n l5nh th06 đ;i i++ 1i tong từ Y thành 23
 }np lại #ư%c &iểm tr0
2 liểm tr0 điề &i5n 1iq33
o i•2 n@n điề &i5n là đ7ng
 4h/c hi5n l5nh c"t... l5nh nà6 $i!t r0 màn h:nh ?eng chữ Ai • 2A
 4h/c hi5n l5nh th06 đ;i i++ 1i tong từ 2 thành 33
 }np lại #ư%c &iểm tr0
2 liểm tr0 điề &i5n 1iq33
o i•3 n@n điề &i5n >0i, th"át &hwi $eng lnp
shư $<6, $%i $eng lnp n@ tr@n, chư-ng tr:nh th/c hi5n l5nh lnp 3 l.n, $i!t r0 màn h:nh 3 ?eng
 i • W
 i • Y
 i • 2
Heng lnp &!t th7c &hi i • 3 1điề &i5n &iểm tr0 >0i3
III.4.2. Vòng Iåp for Iông nhau
H, ?b >M ?bng $eng lnp U"r l)ng nh0 để $i!t #Dng cM chư-ng r0 màn h:nh. 4r"ng trưTng hợp nà6
$eng lnp U"r >h h"ạt đ9ng như >0O
 i • W
2 4h/c hi5n $eng lnp U"r $%i Œ • W, Y, 2,... , y, g 1YW l.n lnp, m•i l.n $i!t r0 t,ch i•Œ3, >0 đ8
$i!t C'ng ?eng.
 i • Y
2 4h/c hi5n $eng lnp $%i Œ • W, Y, 2,... g
 i • 2
2 ....
 i • g
2 4h/c hi5n $eng lnp $%i Œ • W, Y, 2,... g
#include <iostream>
#include <stdli%.h>
#include <iomanip>
using namespace std;
int main ()
{
for (int i*0; i<10; i``)
{
for (int a*0; a<10; a``) cout << setb(4) << ica;
cout << endl;
)
getchar();
)
l!t PD cB0 đ"ạn chư-ng tr:nh >h như >0O
YY
Lập trình C++ Nguyễn Phú Quảng
Heng lnp U"r cB0 C++ c8 thể th06 th! $eng lnp U"r... ?"ant" cB0 u0>c0l #Zng cách th06 đ;i điề &i5n
&iểm tr0 $à l5nh tong thành l5nh giDm. H, ?b >0 $i!t r0 YWW >' từ ggW, gyW, gXW đ!n W
#include <iostream>
#include <stdli%.h>
#include <iomanip>
using namespace std;
int main ()
{
for (int i*;;0; i>*0; i[*10)
{
cout << i << ! !;
)
getchar();
)
III.4.3. Sú dµng break và continue trong vòng Iåp for
4r"ng $eng lnp U"r, #ạn c8 thể >M ?bng các l5nh >0O
2 #re0& để th"át &hwi $eng lnp
2 c"ntine để ti!p tbc th/c hi5n #ư%c ti!p the" cB0 $eng lnp
[0 đI6 là $, ?b >M ?bng #re0& $à c"ntineO
#include <iostream>
#include <stdli%.h>
#include <math.h>
using namespace std;
int main()
{
int n * 100; -- diIt tet c0 c/c s2 ngu$8n t2 tf 1 7In n ra m3n hUnh
int i4 a4 m;
for (i*1; i<*n; i``) { -- ght tfng s2
-- ght tet c0 c/c s2 tf 2 7In cin 2 c9a i
for (a*24 m * sjrt(i); a<*m; a``) {
if (ika**0) break; -- ZIu cQ 1 s2 l3 >Jc thU tho/t
)
-- ZIu tho/t Fhi i chia hIt cho a thU i Fo ph0i l3 s2 ngu$8n t2
-- ZIu i FhVng chia hIt cho a4 s2 i l3 ngu$8n t2
if (ika&*0) cout << i << ! !;
)
getchar();
)
Y2
Lập trình C++ Nguyễn Phú Quảng
III.5. Vòng Iåp whiIe
C7 pháp
while (<Wi=uEFiNn>)
{
<XNnhEl_p>;
)
4r"ng &hi qSiề‰&i5n‚ cen đ7ng th: th/c hi5n q}5nh‰lnp‚
Heng lnp ahile ,t &hi được >M ?bng $: #ạn c8 thể >M ?bng $eng lnp U"r th06 ch" ahile.
Heng lnp ahile $à ?"... ahile đề c8 thể >M ?bng #re0& $à c"ntine tư-ng t/ $eng lnp
III.6. Vòng Iåp do...whiIe
do
{
<XNnhEl_p>;
) while (<Wi=uEFiNn>);
4h/c hi5n q}5nh‰lnp‚ ch" đ!n &hi qSiề‰&i5n‚ >0i.
III.7. Nháy không diêu kiên
}5nh g"t" >M ?bng để nhD6 đ!n m9t $N tr, tr"ng chư-ng tr:nh. }5nh g"t" phá $Ž t,nh c* tr7c cB0
chư-ng tr:nh nhưng n! #i!t t<n ?bng >h làm giDm đ9 phmc tạp cB0 chư-ng tr:nh. Hxn $%i $, ?b $i!t
r0 các >' ng6@n t', #ạn c8 thể chJnh >M0 chư-ng tr:nh ch" đ-n giDn h-n #Zng cách >M ?bng g"t"O
#include <iostream>
#include <stdli%.h>
#include <math.h>
using namespace std;
int main()
{
int n * 100;
int i4 a4 m;
for (i*1; i<*n; i``) {
for (a*24 m * sjrt(i); a<*m; a``) {
-- ZIu i chia hIt cho a4 nh0$ 7In #B trl !.oZgu$enDo!
if (ika**0) goto .oZgu$enDo;
)
-- ZIu i FhVng chia hIt cho %et c: a n3o4 i l3 s2 ngu$8n t2
cout << i << ! !;
-- ZIu i chia hIt cho 1 s2 a4 ]h>Tng trUnh sm nh0$ trnc tiIp 7In
-- #B trl .oZgu$enDo
.oZgu$enDo\;
)
getchar();
)
IV. HÀM
IV.1. Đ[nh nghïa hàm
C7 phápO
<.iGuEh3m> <D8nEh3m>(+oanhEs/chEthamEs2,)
{
<XNnh>;
return <Ai/EtrBEtr0E#=>;
<XNnh>;
)
4r"ng đ8O
2 qliể‰hàm‚O liể giá trN trD $ề cB0 hàm, 1n! hàm &hông trD $ề giá trN, &iể hàm là $"i?3
Y3
Lập trình C++ Nguyễn Phú Quảng
2 q4@n‰hàm‚O 4@n cB0 hàm 1P6 ư%c gi'ng như đnt t@n #i!n v &hông c8 ?* cách, &hông
chm0 &L t/ đnc #i5t3
2 s! hàm c8 &iể $"i?, c8 thể ?rng l5nh retrn để th"át &hwi hàm
2 s! hàm c8 &iể &hác $"i?, #ạn phDi trD $ề giá trN tư-ng mng $%i &iể 1$, ?b &iể int th:
phDi là return 13
2 s! &hông c8 th0m >', #ạn $xn phDi c8 cnp ng"nc 13
\0nh >ách th0m >' được li5t &@ như >0O
<.iGuEthamEs2E1> <D8nEthamEs2E1>4 <.iGuEthamEs2E2> <D8nEthamEs2E2>4...
IV.2. Ví dµ khai báo hàm
#include <iostream>
#include <Pstream>
#include <stdio.h>
using namespace std;
-- "3m tlnh t^ng c9a 2 s2
-- ]Q 2 tham s2 a4 % (FiGu int)
-- Dr0 #= t^ng c9a a #3 % (FiGu int)
int Dong(int a4 int %)
{
return a`%;
)
int main()
{
cout << !"am tinh tong\ ! << Dong(20434) << endl;
getchar();
)
IV.3. Khi nào sú dµng hàm
Hàm được >M ?bng tr"ng các trưTng hợp >0O
2 K9t đ"ạn l5nh được lnp đi, lnp lại nhiề l.n
2 K9t đ"ạn chư-ng tr:nh Pá ?ài, c.n chi0 nhw để ?_ PDn lL
IV.4. Hàm duçc gçi nhu thê nào?
Các #i!n $à th0m >' cB0 hàm được lư tr"ng >t0c&, m•i &hi #ạn gọi hàm, má6 t,nh th/c hi5n các
công $i5c >0O
2 }.n lượt đư0 các th0m >' $à" tr"ng >t0c&
2 }ư lại $N tr, gọi hàm 1cB0 hàm hi5n tại3
2 4rw chư-ng tr:nh >0ng $N tr, m%i 1cB0 hàm được gọi3
2 }*6 các th0m >' r0 &hwi >t0c&
2 K•i #i!n được &h0i #á" tr"ng chư-ng tr:nh c"n >h được đư0 $à" >t0c&
lhi th"át &hwi chư-ng tr:nh c"n, má6 t,nh làm $i5c the" P6 tr:nh ngược lại
2 }*6 các #i!n đ( &h0i #á" r0 &hwi >t0c&
2 }ư lại giá trN trD $ề cB0 hàm 1tr"ng th0nh ghi3
2 4rw chư-ng tr:nh $ề $N tr, c+ 1trư%c &hi gọi hàm3
H%i P6 tr:nh nà6, c8 thể nh<n r0 các đnc điểm >0O
2 lhi gọi hàm, #9 nh% cB0 >t0c& đ.6 l@n #Zng t;ng &,ch thư%c cB0 các th0m >' $à các #i!n
&h0i #á" tr"ng hàm
Yk
Lập trình C++ Nguyễn Phú Quảng
2 [0 &hi th"át &hwi hàm, $rng #9 nh% c*p ch" các th0m >' $à #i!n tr"ng hàm được &hôi
phbc, >t0c& trc $ề trạng thái c+
2 Các hàm c8 thể gọi lxn nh0, m•i l.n gọi hàm >t0c& lại đ.6 th@m. [t0c& chm0 thông tin thm
t/ các hàm gọi nh0 $à các #i!n tr"ng hàm đ8 1thông tin nà6 gọi là C0ll >t0c&3
IV.5. Hàm gçi dê quy
S5 P6 là c- ch! m9t hàm t/ gọi ch,nh n8. shT >M ?bng >t0c&, m•i hàm >h c8 $rng nh% lư giữ
th0m >' $à #i!n cB0 ri@ng n8. Các $rng nh% nà6 được >=p C!p tr@n >t0c& 1hàm gọi c'i crng >h
được l*6 r0 trư%c ti@n3.
R|t $, ?b &inh điển >0O
#include <iostream>
#include <Pstream>
#include <stdio.h>
using namespace std;
-- "3m tlnh giai thfa c9a m?t s2
-- p6 dSng cVng th:c tru$ h1i n& * n c (n[1)&
-- "3m AiaiDhua(n) 7>Rc tlnh tf h3m AiaiDhua(n[1)
-- D:c l3 h3m AiaiDhua tn gqi lKi chlnh nQ (7N ju$)
int AiaiDhua(int n)
{
if (n>*1) return ncAiaiDhua(n[1); else return 1;
)
int main()
{
int n;
cout << !n * !; cin >> n;
cout << !n& * ! << AiaiDhua(n) << endl;
PPlush(stdin);
getchar();
)
Chư-ng tr:nh tr@n t,nh gi0i thư0 cB0 m9t >' #Zng cách >M ?bng hàm •i0i4h0. ^Dn thIn hàm nà6 >M
?bng công thmc tr6 h)i ni • n • 1n2Y3i Hàm •i0i4h01n3 gọi hàm •i0i4h01n2Y3, •i0i4h01n2Y3
gọi •i0i4h01n223. Cm t.n t/ ch" đ!n hàm •i0i4h01Y3, hàm nà6 Pá đ-n giDn $: ch" giá trN Y n@n
&hông gọi đ5 P6.
shư $<6, hàm •i0i4h01n3 được t,nh #Zng cách gọi đ5 P6 n l.n th06 $: ?rng $eng lnp. Sể các #ạn
hiể rd h-n $ề đ5 P6, ch7ng t0 phIn t,ch h"ạt đ9ng cB0 hàm •i0i4h01n3 $%i n•k.
 Ch7ng t0 h(6 thM phIn t,ch Pá tr:nh h"ạt đ9ng cB0 các hàm &hi gọi đ5 P6 P0 #Dng >0
4>=1
4*GiaiThua(3)
3
3*GiaiThua(2)
2>=1
2*GiaiThua(1
)
1>=1
End
return
1
return
2*1=2
return
3*2=6
return
4*6=24
Begin
Ð
Ð
Ð
S
Y]
Lập trình C++ Nguyễn Phú Quảng
Bưóc Mô tá Stack
main() Chương trình bãt đầu hoat
đông tù hàm main()
goi GiaiThua(4) Hàm main() thuc hiên lời goi
hàm GiaiThua(4)
goi GiaiThua(3) Hàm GiaiThua(4) goi hàm
GiaiThua(3)
goi GiaiThua(2) Hàm GiaiThua(3) goi hàm
GiaiThua(2)
goi GiaiThua(1) Hàm GiaiThua(2) goi hàm
GiaiThua(1)
Trá vê giá trj
cúa
GiaiThua(1)
n=1, hàm GiaiThua(1) không
goi đê quy mà trá vê giá trj 1,
sau đó thoát ra, tró vê hàm đã
goi nó (là hàm GiaiThua(2))
Trá vê giá trj
cúa
GiaiThua(2)
n=2, Tính n*GiaiThua(1) = 2*1
= 2
Trá vê giá trj 2
Thoát tró vê hàm đã goi hàm
này (là hàm GiaiThua(3))
Trá vê giá trj
cúa
GiaiThua(3)
n=3, Tính n*GiaiThua(2) = 3*2
= 6
Trá vê giá trj 6
Thoát tró vê hàm đã goi hàm
này (là hàm GiaiThua(4))
Trá vê giá trj
cúa
GiaiThua(4)
n=4, tính n*GiaiThua(3) = 4*6 =
24
Trá vê giá trj 24
4
4
3
4
3
2
4
3
2
1
4
3
2
1
4
3
2
4
3
4
YV
Lập trình C++ Nguyễn Phú Quảng
Thoát tró vê hàm đã goi hàm
này (là hàm main())
V. MẢNG
V.1. Đ[nh nghïa
V.2. Truy câp phân tú cúa máng
V.3. Khói tao máng
V.4. Máng nhiêu chiêu
V.5. Sú dµng máng Iàm tham sô cúa hàm
VI. CON TRỎ
4r"ng má6 t,nh, #9 nh% được >=p C!p tr"ng các ô li@n ti!p nh0, m•i ô chi!m Y #6te. Các ô nh% nà6
phIn #i5t $%i nh0 #ci đN0 chJ 1g.n gi'ng các ph.n tM cB0 mDng phIn #i5t $%i nh0 #ci chJ >'3.
K•i #i!n, tr6 the" &,ch thư%c >h chi!m Y h"nc nhiề ô nh% li@n tbc tr"ng #9 nh%. SN0 chJ cB0 #i!n
là đN0 chJ cB0 ô nh% đ. ti@n cB0 #i!n đ8.
4r"ng C++, c8 m9t l"ại #i!n lư lại đN0 chJ cB0 các ô nh%, các #i!n nà6 được gọi là c"n trw. C"n trw
c+ng là #i!n, c8 &,ch thư%c k #6te, lư Y >' là đN0 chJ cB0 các #i!n.
VI.1. Khai báo con tró
VI.2. Các toán tú trên con tró
VI.3. Con tró và máng
VI.4. Con tró hàm
VII. STRUCT
VII.1. Đ[nh nghïa Struct
YX
Lập trình C++ Nguyễn Phú Quảng
VII.2. Khai báo biên
VII.3. Truy câp truòng
VIII. Stream
VIII.1. FiIe stream
VIII.1.1. Ghi fiIe
Sể ghi ?ữ li5 r0 Uile teCt, #ạn >M ?bng &iể ?ữ li5 "U>tre0m 1" • "tpt, U • Uile3. liể ?ữ li5 nà6
6@ c. #ạn phDi &h0i #á" he0?er là qU>tre0m‚.
i">tre0m c8 các phư-ng thmc >0O
2 U."pen1At@n UileA3O Kc Uile
2 U.cl">e13O S8ng Uile
#include <iostream>
#include <Pstream>
using namespace std;
int main () {
oPstream m$Pile;
m$Pile.open (!c\-#idu.trt!);
m$Pile << !Ahi thong tin ra Pile.! << endl;
m$Pile << 123.43 << endl;
m$Pile.close();
return 0;
)
VIII.1.2. Đçc fiIe
2 4ư-ng t/ ghi Uile, đọc Uile teCt >M ?bng &iể ?ữ li5 iU>tre0m 1i • inpt, U • Uile3.
#include <iostream>
#include <Pstream>
#include <stdio.h>
using namespace std;
int main () {
iPstream m$Pile;
m$Pile.open (!c\-#idu.trt!);
int a4 %4 c4 d4 e;
m$Pile >> a >> % >> c >> d >> e;
m$Pile.close();
cout << a << ! ! << % << ! ! << c << ! ! << d << ! ! << e << endl;
getchar();
return 0;
)
-- Zoi dung Pile
-c
3 4 5 '
c-
H, ?b tr@n m%i chJ minh họ0 đọc các giá trN li@n ti!p từ Uile. Sể đọc các ?eng, CI &L t/... iU>tre0m
c8 các phư-ng thmc >0O
2 f.eof() O liểm tr0 Cem đ( h!t Uile chư0• 4rD $ề W n! chư0 h!t Uile, Y n! đ( h!t Uile
Yy
Lập trình C++ Nguyễn Phú Quảng
2 f.get() O Sọc Y &L t/ tr@n UileO [M ?bng để đọc &L t/ C'ng ?eng >0 &hi ?rng các t"án tM ?xn
hư%ng từ >tre0m r0 #i!n 1th0m &hD" $, ?b3. 4rD $ề &L t/ $ừ0 đọc được.
2 getline(f, str) O Sọc m9t ?eng từ Uile 1$à" CI &L t/ >tr3
2 [0 &hi đọc Y ?eng từ Uile, #ạn c8 thể ?rng i>tring>tre0m để đọc ?ữ li5 từ l)ng CI &L t/
$à" các #i!n. 1th0m &hD" $, ?b3
-c
Wqc #3o tf Pile readPile.trt #Ji ceu trYc
o@ng 1\ p2 d@ng c9a m0ng 2 chi=u
]/c d@ng tiIp theo4 msi d@ng l3 c/c ph5n t6 c9a m0ng 2 chi=u (l>u t4 s2 ph5n t6
msi d@ng cQ thG Fh/c nhau4 FhVng cQ s2 ghi s2 l>Rng ph5n t6 C 75u)
c-
#include <iostream>
#include <Pstream> -- header cho 7qc ghi Pile
#include <sstream> -- header cho 7qc ghi tr8n string
#include <stdio.h>
#include <#ector>
using namespace std;
int main () {
int n;
typedef #ector<int> dong; -- .iGu d@ng (m0ng s2 ngu$8n)
#ector<dong> a; -- u0ng 2 chi=u (m0ng c/c d@ng)
string line;
int %;
iPstream P(!readPile.trt!); -- uC Pile
P >> n; P.get(); -- Wqc s2 d@ng4 P.get()\ ru2ng d@ng
a.resive(n); -- W_t s2 d@ng cho m0ng 2 chi=u
for (int i*0; i<n; i``)
{
getline(P4 line); -- Wqc tf d@ng #3o rwu line
istringstream Ps(line); -- DKo stream Ps tf rwu line
while (Ps >> %) a+i,.pushE%acF( % ); -- Wqc tfng s2 tf stream Ps
)
P.close(); -- WQng Pile
for (int i*0; i<a.sive(); i``) -- xn c/c ph5n t6 c9a m0ng
{
for (int a*0; a<a+i,.sive(); a``) cout << a+i,+a, << ! !;
cout << endl;
)
getchar();
)
-- Zoi dung Pile readPile.trt
-c
3
1 2 3 4
5 ' ( ;
10 11
c-
VIII.2. String stream
VIII.2.1. istringstream
VIII.2.2. ostringstream
VIII.3. Ghi có d[nh dang
C h• trợ đọc ghi the" đNnh ?ạng 1$, ?bO >' lượng chữ >' >0 ?* php63 #Zng cách >M ?bng các th0m
>' € tr"ng ph.n đNnh ?ạng.
Yg
Lập trình C++ Nguyễn Phú Quảng
C++ c+ng ch" ph|p làm tư-ng t/ $%i thư $i5n i"m0nip 1$i!t t=t cB0 m0nipl0te3. Sể >M ?bng thư
$i5n nà6, #ạn &h0i #á"
#include <iomanip>
VIII.3.1. Ghi vói sô Iuçng dâu phây xác d[nh
s! m'n ghi >' th/c $%i 3 chữ >' >0 ?* php6, #ạn >M ?bng l5nh setprecision. Ch7 L
>etpre>i>i"n1n3 >h ghi r0 n2Y chữ >' >0 ?* php6 1t,nh cD ?* ch*m là n chữ3.
#include <iostream>
#include <stdli%.h>
#include <iomanip>
using namespace std;
int main () {
cout << setprecision(4) << (20.0-3) << endl; -- Ahi ra 3 chM s2 sau deu phy$ .'
getchar();
)
VIII.3.2. Ghi vói sô Iuçng ký tµ xác d[nh
^ạn c8 thể >M ?bng l5nh >eta để Các đNnh >' lượng &L t/ >h được ghi r0 ch" l.n ghi ti!p the". Con lề
mnc đNnh là #@n phDi. s! #ạn m'n ch6ển >0ng con lề trái #ạn >M ?bng l5nh left. Ch7 LO các l5nh
left $à right >h con lề trái $à phDi ch" t*t cD các l5nh $i!t >0 đ8.
#include <iostream>
#include <stdli%.h>
#include <iomanip>
using namespace std;
int main () {
cout << setb(10) << 123 << setb(10) << 45 << endl; -- 123 45
cout << setb(10) << 123 << 45 << endl; -- 12345
cout << lePt << setb(10) << 123 << setb(10) << 45 << endl; -- 123 45
getchar();
)
VIII.3.3. Ghi vói hê co sô 8, 10, 16
^ạn c8 thể >M ?bng l5nh setbase để đư0 các >' $%i các h5 c- >' &hác nh0 r0 ">tre0m. Các h5 c- >'
c8 thể >M ?bng là YW, YV $à y. Ch7 L, l5nh >et#0>e c8 tác ?bng đ'i $%i t*t cD các >' được $i!t r0 >0
l5nh nà6. }5nh showbase >h hiển thN các >' crng $%i cách ghi tr"ng C
2 Y23O cách ghi #:nh thưTng cB0 >' Y23 c h5 th<p phIn
2 WCX#O cách ghi h5 c- >' YV 1heC03 cB0 >' Y23
2 WYX3O cách ghi h5 c- >' y cB0 >' Y23
[0 &hi ghi $%i h5 c- >' &hác nh0 &‘m the" showbase, #ạn c8 thể >M ?bng noshowbase để t=t ch!
đ9 nà6 đi.
#include <iostream>
#include <stdli%.h>
#include <iomanip>
using namespace std;
int main () {
cout << setbase(16) << 123 << endl; -- '%
cout << 123 << endl; -- '%
cout << setbase(8) << 123 << endl; -- 1'3
cout << showbase;
cout << setbase(16) << 123 << endl; -- 0r'%
cout << setbase(1) << 123 << endl; -- 123
cout << setbase(8) << 123 << endl; -- 01'3
cout << noshowbase;
cout << setbase(16) << 123 << endl; -- '%
getchar();
)
2W
Lập trình C++ Nguyễn Phú Quảng
IX. KIEU NGUÒI DÙNG Đ[NH NGHÏA
X. CÁP PHÁT BQ NHÓ ĐQNG
XI. LÓP
XII. MÃU
XIII. THU VIỆN CHUAN
C++ được đánh giá là ngôn ngữ mạnh $: t,nh mềm ?‹", g.n g+i $%i ngôn ngữ má6. sg"ài r0, $%i
&hD nong l<p tr:nh the" mx, C++ đ( &hi!n ngôn ngữ l<p tr:nh trc thành &hái Pát, &hông cb thể $à
chi ti!t như nhiề ngôn ngữ &hác. H%i &hái ni5m mx, những ngưTi l<p tr:nh đ( đề r0 &hái ni5m l<p
tr:nh &hái Pát 1generic pr"gr0mming3, C++ được cng c*p &‘m $%i m9t #9 thư $i5n chpn [4}
1[t0n?0r? 4empl0te }i#r0r63. ^9 thư $i5n nà6 th/c hi5n t"àn #9 các công $i5c $à" r0 ?ữ li5
1i">tre0m3, PDn lL mDng 1$ect"r3, th/c hi5n h. h!t các t,nh nong cB0 các c* tr7c ?ữ li5 c- #Dn
1>t0c&, Pee, m0p, >et...3. sg"ài r0, [4} cen #0" g)m các th<t t"án c- #DnO t:m min, m0C, t,nh
t;ng, >=p C!p 1$%i nhiề th<t t"án &hác nh03, th06 th! các ph.n tM, t:m &i!m 1t:m &i!m thưTng $à
t:m &i!m nhN phIn3, tr9n. 4"àn #9 các t,nh nong n@ tr@n đề được cng c*p ?ư%i ?ạng mx n@n
$i5c l<p tr:nh lôn thể hi5n t,nh &hái Pát h80 c0", làm $i5c ?_ ?àng tr@n t*t cD các &iể ?ữ li5. s!
#ạn l<p tr:nh giDi P6!t các #ài t"án thi@n $ề th<t t"án, [4} là >/ l/0 chọn đ7ng đ=n, hợp lL ch"
ph|p #ạn giDi #ài t"án r*t nh0nh ch8ng, l"ại #w được nhiề công >mc tr"ng $i5c cài đnt các th<t
t"án c- #Dn.
XIII.1. Các khái niêm
XIII.1.1. Container
C"nt0iner 1thrng chm03 là &hái ni5m chJ các đ'i tượng lư trữ các đ'i tượng 1giá trN3 &hác. S'i
tượng c"nt0iner >h cng c*p các phư-ng thmc để tr6 c<p các thành ph.n 1element3 cB0 n8. Cb thể
h-n, t*t cD các c"nt0iner đề chm0 các #9 lnp 1iter0t"r3 để ch" ph|p ?65t P0 t"àn #9 các element
cB0 c"nt0iner.
Các c"nt0iner được phIn l"ại the" t,nh ch*t thm t/ cB0 các element, #0" g)m các l"ại >0O
2 f"ra0r? c"nt0iner
2 Ge$er>i#le c"nt0iner
2 G0n?"m tcce>> c"nt0iner
K9t >' c"nt0iner h06 được >M ?bng nh*t g)m $ect"r 1tư-ng t/ như mDng3, $ect"r là G0n?"m 0cce>>
c"nt0iner 1ngưTi ?rng c8 thể tr6 c<p tr/c ti!p #*t cm ph.n tM nà" tr@n $ect"r3.
XIII.1.2. Iterator
Šter0t"r 1#9 lnp3 là &hái ni5m >M ?bng để chJ m9t c"n trw trw đ!n các đ'i tượng. K•i c"nt0iner c8
m9t l"ại iter0t"r &hác nh0 để trw đ!n các thành ph.n cB0 c"nt0iner. Sể iter0t"r l.n lượt trw đ!n từng
thành ph.n tr"ng c"nt0iner, ch7ng t0 >M ?bng các t"án tM tong 1++3.
2Y
Lập trình C++ Nguyễn Phú Quảng
lhái ni5m iter0t"r ch" ph|p #ạn làm $i5c m9t cách t;ng Pát $%i #*t &j m9t &iể ?ữ li5 nà", từ
những &iể ?ữ li5 tr6 c<p ngx nhi@n 1$ect"r3 đ!n các ánh Cạ 1m0p3, t<p hợp 1>et3, ?0nh >ách 1li>t3
ch" đ!n những &iể ?ữ li5 đ-n giDn như mDng.
\" đ8, iter0t"r g=n liền $%i t*t cD các l"ại c"nt0iner, đI6 là &hái ni5m #ạn c.n n=m r*t $ững n!
m'n làm $i5c t't $%i [4}.
XIII.1.3. Môt sô phuong thúc co bán cúa Container
C"nt0iner g)m nhiề l"ại, nhưng t*t cD các c"nt0iner đề g)m các phư-ng thmc c- #Dn >0
Phương thúc Mô tá
a.begin() Trá vê iterator bãt đầu cúa container
a.end() Trá vê iterator cuôi cùng cúa container
a.size() Kích thưóc (sô lưong element) cúa container
a.max_size() Kích thưóc tôi đa cúa container
a.empty() Trá vê giá trj != 0 nêu container trông (không có element nào), 0 nêu
ngưoc lai
a.swap(b) Hoán đôi 2 container vói nhau (giông viêc hoán đôi giá trj cúa 2 biên
kiểu sô)
XIII.2. Kiêu vector
liể $ect"r c8 thể c"i là &iể mDng tr"ng l<p tr:nh C tr6ền th'ng. KDng là t<p hợp các giá trN crng
&iể, được >=p C!p n'i ti!p nh0. Các ph.n tM cB0 mDng c8 thể được tr6 c<p ngx nhi@n P0 chJ >'.
H*n đề đnt r0O s! $ect"r là mDng th: tại >0" lại phDi >M ?bng $ect"r &hi #ạn đ( Pá Pen th9c $%i
mDng• Ch7ng tôi Cin phIn t,ch m9t >' nhược điểm >0 cB0 mDngO
2 s! #ạn >M ?bng mDng t’nhO KDng nà6 lôn được &h0i #á" $%i &,ch thư%c t'i đ0 mà #ạn c8
thể ?rng đ!n → t'n nhiề $rng nh% thừ0
2 s! #ạn >M ?bng mDng đ9ngO ^ạn phDi Cin c*p phát #9 nh%, làm $i5c $%i c"n trw. C"n trw là
&hái ni5m h06 tr"ng C, C++, nhưng n8 là ng6@n nhIn cB0 r*t nhiề r=c r'i tr"ng l<p tr:nh.
2 shược điểm P0n trọng nh*tO s! #ạn >M ?bng mDng $ượt chJ >' $ượt Pá &,ch thư%c đ(
&h0i #á", C++ >h &hông thông #á" l•i, điề nà6 ?xn đ!n l•i ?I6 ch6ền ?" các l5nh l•i đ(
tác đ9ng đ!n các #i!n &hác tr"ng chư-ng tr:nh 1tr"ng u0>c0l #ạn c8 thể &iểm tr0 tràn chJ >'
mDng #Zng ?xn #i@n ?Nch r0nge chec&3.
$ect"r là m9t c"nt0iner cng c*p &hD nong >M ?bng mDng mềm ?‹", c8 &iểm >"át r0nge chec& &hi
c.n thi!t, $%i &,ch thư%c tr6 L 1mà &hông c.n phDi >M ?bng c"n trw3. sg"ài r0 $ect"r ch" ph|p #ạn
ch‘n th@m h"nc C80 đi m9t >' ph.n tM chJ #Zng Y l5nh 1&hông phDi >M ?bng $eng lnp như đ'i $%i
mDng3.
Sể >M ?bng $ect"r, #ạn phDi &h0i #á" Uile he0?er $%i c7 pháp
#include <#ector>
C7 pháp &h0i #á" $ect"r như >0
#ector<.iGu> d;
22
Lập trình C++ Nguyễn Phú Quảng
XIII.2.1. Ví dµ 1
4r"ng đ8, #ạn c8 thể &h0i #á" &iể là #*t cm &iể #i!n nà". Sể hiể rd h-n $ề $ect"r, #ạn h(6 the"
?di $, ?b >0
#include <iostream> -- Dh> #iNn iostream phSc #S ghi dM liNu ra m3n hUnh
#include <#ector> -- Dh> #iNn #ector4 s6 dSng FiGu #ector
#include <stdio.h> -- Dh> #iNn stdio (s6 dSng h3m getchar() 7G dfng ct)
using namespace std; -- p6 dSng namespace std
int main() {
#ector<int> d; -- d FiGu #ector s2 ngu$8n (s6 dSng gi2ng m0ng int)
d.resive(3); -- W_t Flch th>Jc c9a %iIn d l3 3 (gi2ng m0ng 3 pt)
d+0, * 5; -- A/n gi/ trB cho c/c ph5n t6 c9a %iIn d
d+1, * ; -- p6 dSng deu mQc +, ho3n to3n gi2ng #Ji m0ng
d+2, * ';
for (int i*0; i<d.sive(); i``) { -- Ahi gi/ trB c/c ph5n t6 c9a d ra m3n hUnh
cout << d+i, << endl; -- ZIu s6 dSng m0ng4 %Kn ph0i cQ %iIn l>u Flch
) -- th>Jc4 c@n #ector cQ h3m cho %iIn Flch th>Jc
getchar(); -- ofng ch>Tng trUnh 7G rem FIt ju0
)
H, ?b tr@n ch" #ạn th*6 $i5c >M ?bng $ect"r r*t đ-n giDn, h"àn t"àn gi'ng $%i mDng nhưng #9 nh%
được PDn lL t/ đ9ng, #ạn &hông phDi P0n tIm đ!n giDi ph8ng các $rng #9 nh% đ( Cin c*p phát.
XIII.2.2. Ví dµ 2
46 nhi@n, $i5c >M ?bng $ect"r &hông chJ ?ừng lại c những ư điểm tr@n, ch7ng t0 h(6 nghi@n cm
$, ?b ti!p the" để th*6 được các ư điểm &hác cB0 $ect"r.
#include <iostream>
#include <#ector>
#include <stdio.h>
using namespace std;
int main() {
int i;
#ector<int> d;
for (i*0; i<5; i``) -- X_p 5 l5n4 msi l5n 7>a th8m 1 s2 #3o #ector
d.pushE%acF(i); -- Zh> #L$4 #ector cQ thG 7>Rc s6 dSng nh> stacF
cout << endl << !uang truoc Fhi insert! << endl;
for (i*0; i<d.sive(); i``) -- Ahi lKi n?i dung c9a m0ng ra m3n hUnh
cout << d+i, << endl;
d.insert( d.%egin()`34 100 ); -- ]hzn #3o #B trl th: 3 c9a #ector gi/ trB 100
cout << endl << !uang sau Fhi insert! << endl;
for (i*0; i<d.sive(); i``) -- xn n?i dung c9a #ector sau Fhi chzn
cout << d+i, << endl; -- #ector sm cQ ph5n t64 ph5n t6 100 chzn #3o
-- dB trl th: 3 c9a #ector
d.erase( d.%egin()`3 ); -- gQa ph5n t6 #fa chzn #3o 7i
cout << endl << !uang sau Fhi erase! << endl;
for (i*0; i<d.sive(); i``) -- xn n?i dung c9a #ector sau Fhi rQa
cout << d+i, << endl; -- dector lKi gi2ng nh> lYc mJi FhCi tKo
getchar();
)
H%i $, ?b tr@n, #ạn c8 thể th*6 những ư điểm >0 cB0 $ect"r
2 ^ạn c8 thể >M ?bng $ect"r như Y >t0c&. 4h0" tác p>h‰#0c&13 cB0 $ect"r ch" ph|p #ạn th@m
Y giá trN m%i $à" $ect"r. 4h0" tác nà6 >h t/ đ9ng tong &,ch thư%c cB0 $ect"r, ?" đ8 #ạn >h
&hông phDi P0n tIm đ!n PDn lL &,ch thư%c cB0 $ect"r.
2 $ect"r ch" ph|p #ạn ch‘n th@m Y ph.n tM $à" các $N tr, #*t &j cB0 $ect"r, các ph.n tM nZm
>0 $N tr, nà6 >h được ?Nch đi Y $N tr, đển l*6 &h"Dng tr'ng ch" ph.n tM m%i. 4h0" tác ch‘n
ph.n tM c8 thể th/c hi5n ?_ ?àng đ'i $%i mDng thưTng #Zng cách >M ?bng $eng lnp để
ch6ển ?Nch các ph.n tM. 46 nhi@n, để chư-ng tr:nh h"ạt đ9ng đ7ng tr"ng mọi trưTng hợp,
#ạn phDi t,nh đ!n nhiề trưTng hợpO ?ng lượng hi5n tại cB0 mDng c8 đB &hông• s! &hông
đB phDi Cin c*p phát th@m... s! >M ?bng $ect"r, các #ạn >h ?_ ?àng th/c hi5n chmc nong
nà6 chJ #Zng Y l5nh $à lôn đDm #D" rZng l5nh nà6 >h h"ạt đ9ng ch,nh Các.
23
Lập trình C++ Nguyễn Phú Quảng
2 4ư-ng t/ $%i th0" tác C80 m9t ph.n tM &hwi $ect"r, #ạn c+ng chJ c.n >M ?bng Y l5nh.
XIII.2.3. Ví dµ 3
Ch7ng t0 ti!p tbc the" ?di $, ?b ti!p the" để t:m hiể ti!p các &hD nong cB0 $ect"r
#include <iostream>
#include <#ector>
#include <stdio.h>
using namespace std;
int main() {
-- u0ng c/c rwu Ft tn (dM liNu test)
char c]hao+, * {!gin!4 !chao!4 !tat!4 !ca!4 !cac!4 !%an!);
int n * siveoP(]hao)-siveoP(c]hao); -- Dlnh Flch th>Jc c9a m0ng
-- ]/ch tlnh n3$ s6 dSng m?t m{o\
-- .lch th>Jc c9a to3n %? m0ng chia cho
-- .lch th>Jc c9a 1 ph5n t6 c9a m0ng
#ector<char c> d; -- dector ch:a c/c rwu Ft tn
-- (c|ng gi2ng m0ng4 #ector cQ thG ch:a
-- mqi loKi gi/ trB)
int i;
cout << endl << !#ector truoc Fhi roa! << endl;
Por (i*0; i<n; i``) {
d.pushE%acF(]hao+i,); -- W>a c/c gi/ trB tf m0ng #3o #ector
)

cout << endl << !#ector sau Fhi roa! << endl;
Por (i*0; i<d.sive(); i``) {
cout << d+i, << endl; -- xn ra c/c gi/ trB c9a #ector
)

d.erase(d.%egin()`24 d.%egin()`2`3); -- gQa #ector tf th3nh ph5n 2 7In
-- th3nh ph5n th: 3 sau th3nh ph5n 2
-- D:c l3 rQa 3 th3nh ph5n FG tf
-- th3nh ph5n 2
Por (i*0; i<d.sive(); i``) {
cout << d+i, << endl; -- XKi in #ector sau Fhi rQa ra m3n hUnh
)
cout << endl; -- xn s2 l>Rng th3nh ph5n c9a #ector
cout << !dector truoc Fhi clear co ! << d.sive() << ! thanh phan! << endl;
d.clear(); -- gQa to3n %? c/c th3nh ph5n
cout << !dector sau Fhi clear co ! << d.sive() << ! thanh phan! << endl;
getchar(); -- XKi in ra s2 l>Rng th3nh ph5n
)
l!t PD cB0 đ"ạn chư-ng tr:nh tr@n như >0O
#ector truoc Fhi roa
gin
chao
tat
ca
cac
%an
#ector sau Fhi roa
gin
chao
%an
dector truoc Fhi clear co 3 thanh phan
dector sau Fhi clear co 0 thanh phan
shư $<6, ch7ng t0 #i!t th@m m9t >' chmc nong cB0 $ect"r
2 Hect"r &hông chJ làm $i5c $%i >' mà cen c8 thể làm $i5c $%i t*t cD các ?ạng ?ữ li5 &hác
1đI6 là đnc điểm cB0 l<p tr:nh &hái Pát $%i templ0te3
2 Hect"r c8 thể C80 nhiề thành ph.n m9t l7c
2 Hect"r c8 th! C80 t*t cD các thành ph.n #Zng phư-ng thmc cle0r13.
2k
Lập trình C++ Nguyễn Phú Quảng
XIII.2.4. Ví dµ 4
Cen m9t $*n đề đ( được đề c<p đ!n từ &hi ch7ng tôi gi%i thi5 $ề $ect"r, đ8 là &hD nong &iểm tr0
tràn chJ >' mDng 1r0nge chec&3, để #i!t $ề &hD nong nà6, ch7ng t0 lại ti!p tbc $%i m9t $, ?b m%i
#include <iostream>
#include <#ector>
#include <stdio.h>
using namespace std;
int main() {
tr$ { -- s6 dSng tr$...catch 7G %}$ lsi
#ector<long> d(34 10); -- .hCi tKo #ector g1m 3 th3nh ph5n
-- Det c0 g/n gi/ trB 10
cout << !d+0,*! << d+0, << endl; -- W>a th3nh ph5n 0 ra m3n hUnh
cout << !d+1,*! << d+1, << endl; -- W>a th3nh ph5n 1 ra m3n hUnh
cout << !d+2,*! << d+2, << endl; -- W>a th3nh ph5n 2 ra m3n hUnh
cout << !d+3,*! << d+3, << endl; -- Dh3nh ph5n 3 (lNnh n3$ hoKt 7?ng FhVng
-- 7Yng #U d ch~ cQ 3 th3nh ph5n 04142
cout << !d+4,*! << d+4, << endl; -- Dh3nh ph5n 4 (c3ng FhVng 7Yng)
-- Zh>ng 2 lNnh tr8n 7=u FhVng gw$ lsi

cout << !d+0,*! << d.at(0) << endl; -- .hVng s6 dSng +,4 d<ng ph>Tng th:c at
cout << !d+1,*! << d.at(1) << endl; -- Dh3nh ph5n 14 •.
cout << !d+2,*! << d.at(2) << endl; -- Dh3nh ph5n 24 •.
cout << !d+3,*! << d.at(3) << endl; -- Dh3nh ph5n 3\ Xsi4 ch>Tng trUnh dfng
cout << !d+4,*! << d.at(4) << endl;
getchar();
) catch (erception €e) {
cout << !]o loi ra$ ra! << endl; -- o@ng thVng %/o lsi (nIu ch>Tng trUnh
getchar(); -- ph/t sinh lsi Fhi chK$
)
)
l!t PD cB0 đ"ạn chư-ng tr:nh tr@n như >0
d+0,*10 <[[ •.
d+1,*10 <[[ •.
d+2,*10 <[[ •.
d+3,*0 <[[ pai4 Fo cQ gi/ trB n3$
d+4,*1;;2 <[[ pai
d+0,*10 <[[ •.
d+1,*10 <[[ •.
d+2,*10 <[[ •.
]o loi ra$ ra <[[ DhVng %/o lsi Fhi s6 dSng ph5n t6 FhVng hRp lN
4r"ng $, ?b nà6, ch7ng t0 lại c8 th@m m9t >' &inh nghi5m >0
2 C8 thể >M ?bng c7 pháp $ect"rq&iể‚ t@n‰$ect"r1>'‰ph.n‰tM, giá‰trN‰t*t‰cD‰ph.n‰tM3 để
&hci tạ" m9t $ect"r c8 >' lượng ph.n tM #i!t trư%c $à t*t cD các ph.n tM đề c8 crng Y giá trN
2 s! >M ?bng c7 pháp #i!n‰$ect"r“chJ‰>'”, chư-ng tr:nh >h &hông tạ" r0 l•i &hi >M ?bng chJ
>' mDng nZm ng"ài $rng hợp l5 1gi'ng như mDng thưTng3. 4r"ng $, ?b, ch7ng t0 m%i chJ
l*6 giá trN ph.n tM $%i chJ >' &hông hợp l5, trưTng hợp nà6 chJ ch" &!t PD >0i. shưng n!
ch7ng t0 gán giá trN ch" ph.n tM &hông hợp l5 nà6, h< PD >h nghi@m trọng h-n nhiề $:
th0" tác đ8 >h làm hwng các giá trN &hác tr@n #9 nh%.
2 uhư-ng thmc 0t1chJ‰>'3 c8 tác ?bng tư-ng t/ như ?rng &L hi5 “”, nhưng c8 m9t >/ &hác
#i5t là th0" tác nà6 c8 &iểm tr0 chJ >' hợp l5. Kinh chmng ch" nh<n C|t nà6 tr"ng $, ?b &hi
chư-ng tr:nh chạ6 đ!n $N tr, l5nh H.0t133, l5nh nà6 &hông ch" r0 &!t PD mà tạ" thành thông
#á" l•i.
XIII.2.5. Ví dµ 5
#include <iostream>
#include <#ector>
#include <stdio.h>
using namespace std;
int main() {
t$pedeP #ector<long> #long;
#ector<#long> d(34 #long(3) );
int i4 a;
Por (i*0; i<3; i``)
2]
Lập trình C++ Nguyễn Phú Quảng
Por (a*0; a<3; a``) d+i,+a, * rand() k 10;
Por (i*0; i<3; i``)
{
Por (a*0; a<3; a``) cout << d+i,+a, << ! !;
cout << endl;
)
getchar();
)
H, ?b nà6 minh họ0 $i5c >M ?bng mDng 2 chiề, th/c ch*t đI6 là m9t $ect"r cB0 $ect"r. KDng 2
chiề >M ?bng #i5n pháp nà6 c8 thể c8 &,ch thư%c &hác nh0 giữ0 các ?eng 1$, ?b mDng 2 chiề là
nM0 tr@n cB0 m0 tr<n3
XIII.2.6. Sú dµng vector có kiêm tra ch• sô
#include <iostream>
#include <Pstream>
#include <#ector>
#include <algorithm>
#include <stdli%.h>
using namespace std;
template <t$pename D>
class m#ector \ pu%lic #ector<D> { -- Dao lop m#ector (giong #ector4 nhung co Fiem tra chi
so)
pu%lic\
D t;
D€ operator +, (int i) {
tr$ {
return #ector<D>\\at(i);
) catch (erception €e) {
cout << !Dran chi so ! << i << ! ! << #ector<D>\\sive()[1 << endl;
getchar();
return t;
)
)
);
m#ector< int > chiso;
int n;
int main()
{
chiso.resive( 5 );
chiso+5, * 10;
)
-c
5
ouc
•nh
dan
Dhu
Oa
c-
XIII.3. Kiêu string
lhi m%i học C, ch=c các #ạn đề r*t #'i r'i &hi làm $i5c $%i CI &L t/, $i5c >M ?bng c"n trw lư CI
&L t/ r*t phmc tạp, ?_ gI6 l•i &hi!n nhiề ngưTi >" >ánh n8 $%i CI &L t/ tr"ng u0>c0l.
\" đ8, [4} cng c*p &iể >tring 1CI &L t/3, gi7p các #ạn tránh &hwi h"àn t"àn các phiền phmc n@
tr@n. >tring th/c ch*t là m9t $ect"rqch0r‚ c8 #; >ng th@m m9t >' phư-ng thmc $à th9c t,nh, ?"
đ8, n8 c8 t"àn #9 các t,nh ch*t cB0 Y $ect"r.
[tring c+ng c8 các hàm size, push_back, toán tử [] gi'ng $ect"r.
Sể n'i >tring, #ạn c8 thể >M ?bng t"án tM +, +• để n'i các CI &L t/.
2V
Lập trình C++ Nguyễn Phú Quảng
XIII.3.1. Hàm ch€n x•u ‚insertƒ
-- inserting into a string
#include <iostream>
#include <string>
#include <stdli%.h>
using namespace std;
int main ()
{
string str*!da$ la .. rau thu!;
string istr * !them!;
str.insert((4 istr);
cout << str << endl;
getchar();
)
XIII.3.2. Hàm xóa x•u ‚eraseƒ
-- inserting into a string
#include <iostream>
#include <string>
#include <stdli%.h>
using namespace std;
int main ()
{
string str*!da$ cung la rau thu!;
str.erase(04 3); -- ! cung la rau thu!
cout << str << endl;
str.erase(4 2);
cout << str << endl; -- ! cung rau thu!
getchar();
)
XIII.3.3. Hàm thay thê x•u ký tµ ‚repIaceƒ
-- inserting into a string
#include <iostream>
#include <string>
#include <stdli%.h>
using namespace std;
int main ()
{
string str*!con cho la con cho con. ]on meo Fo phai la con cho!;
str.replace(44 34 !]"•!); -- !con ]"• la con cho con. ]on meo Fo phai la con cho!;
cout << str << endl;
getchar();
)
XIII.3.4. Hàm Iây x•u con ‚stringƒ
-- inserting into a string
#include <iostream>
#include <string>
#include <stdli%.h>
using namespace std;
int main ()
{
string str*!]on]ho cha$ jua rao!;
string str2 * string(str.%egin()`04 str.%egin()`3); -- !]on!
cout << str2 << endl;
str2 * string(str.%egin()`'4 str.%egin()`11); -- !cha$!
cout << str2 << endl;
getchar();
)
2X
Lập trình C++ Nguyễn Phú Quảng
XIII.3.5. Hàm tìm kiêm xuôi ‚findƒ
-- inserting into a string
#include <iostream>
#include <string>
#include <stdli%.h>
using namespace std;
int main ()
{
string str*!]on]ho cha$ jua rao!;
cout << str.Pind(!cha$!) << endl; -- '
cout << (int)str.Pind(!]ha$!) << endl; -- [1
getchar();
)
XIII.3.6. Hàm tìm kiêm nguçc ‚rfindƒ
-- inserting into a string
#include <iostream>
#include <string>
#include <stdli%.h>
using namespace std;
int main ()
{
string str*!]on]ho cha$ jua cha$ jua rao!;
cout << str.Pind(!cha$!) << endl; -- '
cout << (int)str.rPind(!cha$!) << endl; -- 1
getchar();
)
XIII.3.7. Ví dµ 1
Sể làm $i5c $%i >tring cB0 [4}, ch7ng t0 crng Cem C|t $, ?b >0
#include <iostream>
#include <stdio.h>
#include <string>
using namespace std;
int main() {
string s * !"ello string!; -- .hai %/o %iIn FiGu string
cout << !Zoi dung string\ ! << s << endl; -- xn nVi dung string ra m3n hUnh
cout << !]hieu dai cua string\ ! << s.sive() << endl;
-- ]hi=u d3i
cout << !.$ tu 0\ ! << s+0, << endl; -- xn Ft tn 75u ti8n c9a rwu
cout << !.$ tu 1\ ! << s+1, << endl; -- xn Ft tn th: 2
cout << !.$ tu 2\ ! << s+2, << endl; -- xn Ft tn th: 3
s `* ! co the noi string!; -- Z2i rwu Ft tn
cout << !Zoi dung string sau Fhi noi\ ! << s << endl;
s.erase(s.%egin()`54 s.%egin()`5`'); -- gQa 1 7oKn tr8n rwu Ft tn
cout << !Zoi dung string sau Fhi roa\ ! << s << endl;
getchar();
)
4r"ng $, ?b nà6, c8 thể nh<n th*6 những điểm >0
2 RI &L t/ c8 các t,nh ch*t cB0 m9t c"nt0inerO uhư-ng thmc >i•e13 >M ?bng để l*6 >' lượng
ph.n tM, ?* “” ?rng để tr6 c<p đ!n các element, phư-ng thmc er0>e13 >M ?bng để C80 Y >'
các ph.n tM li@n ti!p nh0
2 RI &, t/ c8 thể c9ng $%i nh0 #Zng các t"án tM +, +•
XIII.3.8. Ví dµ 2„ Tách x•u ký tµ
4r"ng $i5c CM lL CI &L t/, &hông thể thi! được các th0" tác tách CI &L t/ thành nhiề CI &L t/
c"n thông P0 các &L t/ ngon cách. Các hàm nà6 c8 >–n tr"ng các ngôn ngữ &hác như Hi>0l ^0>ic,
—0$0... H%i [4}, các #ạn c8 thể ?_ ?àng t/ CI6 ?/ng m9t hàm $%i chmc nong tư-ng t/
#include <iostream>
#include <#ector>
2y
Lập trình C++ Nguyễn Phú Quảng
#include <stdio.h>
#include <string>
using namespace std;
int main() {
string p * !gin chao tat ca cac %an!; -- .hCi tKo gi/ trB c9a rwu
string\\iterator t4 t2; -- ]/c %iIn l_p
#ector<string> split; -- u0ng c/c rwu (l>u FIt ju0 t/ch)
Por (t*p.%egin(); t<p.end();) { -- X_p tf #B trl %‚t 75u
t2*Pind(t4 p.end()4 ƒ ƒ); -- DUm Ft tn space ƒ ƒ 75u ti8n
-- FG tf #B trl t
iP (t&*t2) split.pushE%acF(string(t4 t2)); -- Xe$ rwu Ft tn giMa 2 #B trl
t * t2`1; -- ]hu$Gn sang #B trl sau
)
Por (int i*0; i<split.sive(); i``) {
cout << split+i, << endl; -- xn m0ng c/c rwu Ft tn
)
getchar();
return 0;
)
l!t PD cB0 chư-ng tr:nh như >0
gin
chao
tat
ca
cac
%an
S"ạn chư-ng tr:nh >M ?bng các &˜ th<t >0
2 uhư-ng thmc Uin?1$N‰tr,‰đ., $N‰tr,‰c'i, &L‰t/‰t:m3 ?rng để t:m $N tr, đ. ti@n cB0
&L‰t/‰t:m #=t đ. từ $N‰tr,‰đ.. Hàm nà6 trD $ề $N tr, cB0 &L t/ t:m được 1n! t:m th*63
h"nc $N‰tr,‰c'i 1n! &hông t:m th*63
2 >tring c8 thể &hci tạ" từ m9t đ"ạn &L t/ c"n cB0 m9t CI &L t/ &hác $%i c7 pháp
>tring1$N‰tr,‰đ., $N‰tr,‰c'i3
2 S"ạn chư-ng tr:nh th/c hi5n tách các CI &L t/ &ể cD tr"ng trưTng hợp c8 nhiề &L t/ cách
nZm li@n ti!p nh0.
XIII.4. Kiêu Iist ‚danh sáchƒ
li>t là &iể ?0nh >ách li@n &!t 2 chiề 1h(6 li@n h5 $%i các &i!n thmc cB0 môn C* tr7c ?ữ li5 $à
•iDi th<t3. lhác #i5t cB0 &iể ?0nh >ách li@n &!t $%i &iể mDng c ch•O
2 KDng c.n nhiề thTi gi0n để th@m h"nc C80 ph.n tM 1?Nch ch6ển các ph.n tM ph,0 >0 >0ng
phDi h"nc >0ng trái3, cen ?0nh >ách li@n &!t th/c hi5n các th0" tác th@m, C80 $%i thTi gi0n
&hông đáng &ể 1chJ c.n c=t đmt li@n &!t c+, tạ" r0 li@n &!t m%i3.
2 KDng ch" ph|p tr6 C*t các ph.n tM ng06 l<p tmc thông P0 chJ >' 1tr6 c<p ngx nhi@n 2
r0n?"m 0cce>>3, cen ?0nh >ách li@n &!t phDi tr6 c<p các ph.n tM the" thm t/ t.n t/.
2g
Lập trình C++ Nguyễn Phú Quảng
Sể >M ?bng li>t, #ạn phDi &h0i #á" Uile he0?er li>t $%i c7 pháp >0
#include <list>
Các phư-ng thmc c- #Dn cB0 li>t
Phương thúc Mô tá
c.size()
Sô lưong phần tú cúa list
c. empty ()
Trá vê 1 nêu danh sách là trông, 0 nêu ngưoc lai
c.max_size()
Trá vê sô lưong phần tú tôi đa cúa list
c1 == c2
Trá vê 1 nêu hai danh sách giông nhau
c1 != c2
Trá vê 1 nêu hai danh sách khác nhau (nhanh hơn !(c1==c2))
c1 < c2
Trá vê 1 nêu danh sách c1 < danh sách c2
c.front()
Trá vê phần tú đầu tiên cúa list
c.back()
Trá vê phần tú cuôi cùng cúa list
c.begin()
Trá vê phần tú lãp đầu tiên cúa danh sách
c.end()
Trá vê phần tú lãp cuôi cùng cúa danh sách
c.sort()
Sãp xêp danh sách vói toán tú <
c1.merge(c2) Trôn danh sách c1 vói danh sách c2 (vói điêu kien cá 2 danh sách đêu đã
sãp xêp vói toán tú <). Danh sách đưoc trôn cüng së đưoc sãp xêp vói
toán tú <. Ðây là thuât toán trôn 2 đường vói 2 danh sách đã đưoc sãp
xêp (đô phúc tap là tuyên tính)
XIII.4.1. Ví dµ 1„ Duyêt Iist theo 2 chiêu
#include <iostream>
#include <algorithm>
#include <stdli%.h>
#include <list>
using namespace std;
int main() {
int •+, * {342434142434543);
int n * si!eof(•)-si!eof(c•);
list<int> d;
for (int i*0; i<n; i``) {
d.pushE%acF(•+i,);
)
list<int>\\iterator #i;
cout << endl << !oanh sach theo chieu ruoi! << endl;
for (#i*d.%egin(); #i&*d.end(); #i``) {
cout << c#i << endl;
)
list<int>\\re#erseEiterator r#i;
cout << endl << !oanh sach theo chieu nguoc! << endl;
for (r#i*d.r%egin(); r#i&*d.rend(); r#i``) {
cout << cr#i << endl;
)
getchar();
)
3W
Lập trình C++ Nguyễn Phú Quảng
XIII.4.2. Ví dµ 2„ Ch€n thêm phân tú, xóa phân tú
#include <iostream>
#include <algorithm>
#include <stdli%.h>
#include <list>
using namespace std;
"oid printint(const int €i) {
cout << i << endl;
)
int main() {
int •+, * {142434445);
int n * si!eof(•) - si!eof(c•);
list<int> d(•4 •`n);
list<int>\\iterator i;
cout << endl << !oanh sach %an dau! << endl;
PorEeach( d.%egin()4 d.end()4 printint );
cout << endl << !oanh sach sau Fhi chen #ao cuoi! << endl;
d.pushE%acF(100);
PorEeach( d.%egin()4 d.end()4 printint );
cout << endl << !oanh sach sau Fhi chen #ao dau! << endl;
d.pushEPront(200);
PorEeach( d.%egin()4 d.end()4 printint );
getchar();
)
XIII.4.3. Ví dµ 3„ Tách Iist
XIII.4.4. Ví dµ 4„ S…p xêp Iist
#include <iostream>
#include <algorithm>
#include <stdli%.h>
#include <list>
using namespace std;
int main() {
int •+, * {342434142434543);
int n * si!eof(•)-si!eof(c•);
list<int> d(•4 •`n);
d.sort();
list<int>\\iterator #i;
cout << endl << !oanh sach sau Fhi sap rep! << endl;
for (#i*d.%egin(); #i&*d.end(); #i``) {
cout << c#i << endl;
)
getchar();
)
XIII.4.5. Ví dµ 5„ Trôn Iist
#include <iostream>
#include <algorithm>
#include <stdli%.h>
#include <list>
using namespace std;
int main() {
int •+, * {541434;4');
int O+, * {(44442);
int na * si!eof(•)-si!eof(c•);
int n% * si!eof(O)-si!eof(cO);
list<int> da(•4 •`na)4 d%(O4 O`n%);
3Y
Lập trình C++ Nguyễn Phú Quảng
list<int>\\iterator #i;
cout << endl << !oanh sach • sau Fhi sap rep! << endl;
da.sort();
for (#i*da.%egin(); #i&*da.end(); #i``) {
cout << c#i << endl;
)
cout << endl << !oanh sach O sau Fhi sap rep! << endl;
d%.sort();
for (#i*d%.%egin(); #i&*d%.end(); #i``) {
cout << c#i << endl;
)
cout << endl << !oanh sach • sau Fhi tron #oi danh sach O! << endl;
da.merge(d%);
for (#i*da.%egin(); #i&*da.end(); #i``) {
cout << c#i << endl;
)
getchar();
)
XIII.5. Kiêu set ‚tâp hçpƒ
#include <iostream>
#include <set>
#include <stdio.h>
using namespace std;
int main() {
set<int> •;
•.insert(5);
•.insert(');
•.insert(10);
•.insert(15);
cout << (•.Pind(3)&*•.end()) << endl;
cout << (•.Pind(5)&*•.end()) << endl;
cout << (•.Pind(')&*•.end()) << endl;
cout << (•.Pind(10)&*•.end()) << endl;
getchar();
)
XIII.6. Kiêu map ‚ánh xaƒ
XIII.6.1. Giói thiêu
liể m0p ch" ph|p #ạn l*6 tư-ng mng giữ0 m9t giá trN $%i m9t giá trN &hác, h0i giá trN nà6 tạ" thành
m9t cnp giá trN. 4r"ng đ8 giá trN đ. cB0 cnp là &h80 1&e63, &e6 là ?6 nh*t 1&hông c8 2 &e6 crng
C*t hi5n tr"ng Y m0p3. \" đ8, từ &e6 #ạn c8 thể t:m được giá trN tư-ng mng $%i &e6 tr"ng cnp.
32
Lập trình C++ Nguyễn Phú Quảng
s! th/c hi5n t:m &i!m #:nh thưTng tr@n m9t mDng s ph.n tM, #ạn phDi m*t trng #:nh s`2 ph|p
t:m &i!m. \ữ li5 cB0 các &e6 được t; chmc ?ư%i ?ạng cI6 he0p 1lá trái nhw h-n g'c, lá phDi l%n
h-n g'c3 n@n $i5c t:m &i!m các cnp the" &h80 r*t nh0nh, thTi gi0n trng #:nh là l"g
2
s 1$: đ9 >I
cB0 cI6 là l"g
2
s3.
s! #ạn #i!t t<n ?bng, m0p c8 thể mng ?bng để giDi r*t nhiề ?ạng #ài t"án &hác nh0. 4r"ng ph.n
nà6, ch7ng tôi Cin gi%i thi5 m9t >' mng ?bng cB0 m0p
2 [M ?bng làm từ điểnO H, ?bO tr0 cm thông tin cB0 >inh $i@n the" m( >'
2 S!m >' lượng cB0 m9t thành ph.n 1ch" m9t l"ạt các ph.n tM, t:m Cem c8 #0" nhi@ ph.n tM
$à m•i ph.n tM C*t hi5n #0" nhi@ l.n3
2 [M ?bng để lư m0 tr<n thư0 1m0 tr<n thư0 là m0 tr<n g)m r*t nhiề ph.n tM #Zng W3. 4r"ng
các #ài thi 4in học, nhiề trưTng hợp các #ạn gnp phDi những m0 tr<n c8 &,ch thư%c r*t l%n
1Y tri5 C Y tri5 ch~ng hạn3 nhưng >' lượng ph.n tM &hác W chJ &h"Dng $ài trom ngh:n.
4rưTng hợp nà6 >M ?bng m0p để lư m0 tr<n là r*t th,ch hợp.
XIII.6.2. Các phuong thúc
Phương thúc Mô tá
c.size()
Sô lưong phần tú cúa list
c1 == c2
Trá vê 1 nêu hai map giông nhau
c1 != c2
Trá vê 1 nêu hai map khác nhau (nhanh hơn !(c1==c2))
c1 < c2
Trá vê 1 nêu map c1 < map c2
c.begin()
Trá vê phần tú lãp đầu tiên cúa danh sách
c.end()
Trá vê phần tú lãp cuôi cùng cúa danh sách
c[k]
Trá vê giá trj tương úng vói khóa k (chú ý: nêu chưa có cãp nào có khóa
k, map së tu tao môt cãp mói có khóa k và gán giá trj mãc đjnh. Ðôi vói
kiểu sô, giá trj mãc đjnh là 0)
c.find(k)
Trá vê iterator tương úng vói khóa k, nêu không tìm thây thì trá vê end()
XIII.6.3. Ví dµ„ sú dµng map
#include <iostream>
#include <stdli%.h>
#include <map>
using namespace std;
int main() {
int a+, * {244414345434543424142434444434142);
int n * si!eof(a)-si!eof(a+0,);
map<int4 int> m;
for (int i*0; i<n; i``) {
m+a+i,, ``;
)
map<int4 int>\\iterator a;
for (a*m.%egin(); a&*m.end(); a``)
cout << !„han tu ! << a[>Pirst << ! ruat hien !
<< a[>second << ! lan ! << endl;
getchar();
)
33
Lập trình C++ Nguyễn Phú Quảng
XIII.6.4. Ví dµ„ t† diên
#include <iostream>
#include <stdio.h>
#include <map>
using namespace std;
class s# {
public\
int maso;
string ten;
string lop;
"oid print() {
cout << !cccccccccccccccccccccccccccccccccccccccc! << endl
<< !ua so\ ! << maso << endl
<< !"o ten\ ! << ten << endl
<< !Xop\ ! << lop << endl;
)
);
int main () {
s# a+, * {
{13424 !uai!4 !4(th!)4
{432124 !Xan!4 !4'th!)4
{331334 !]uc!4 !4'th!)4
{433214 !Druc!4 !45th!)4
{12344 !oao!4 !42th!));
int n * si!eof(a)-si!eof(a+0,);
map<int4 s#> m;
for (int i*0; i<n; i``) m+a+i,.maso, * a+i,;
m+43212,.print();
m+1234,.print();
getchar();
return 0;
)
XIII.6.5. Ví dµ„ dêm
#include <iostream>
#include <stdli%.h>
#include <map>
using namespace std;
int main() {
string a+, * {!chuoi!4 !na!4 !oi!4 !tao!4 !chuoi!4 !oi!4 !na!4 !tao!4 !oi!);
int n * si!eof(a)-si!eof(a+0,);
map<string4 int> m;
for (int i*0; i<n; i``) {
m+a+i,, ``;
)
map<string4 int>\\iterator a;
for (a*m.%egin(); a&*m.end(); a``)
cout << !gau F$ tu ƒ! << a[>Pirst << !ƒ ruat hien !
<< a[>second << ! lan ! << endl;
getchar();
)
XIII.6.6. Ví dµ„ ma trân thua
XIII.7. Kiêu hash‡map ‚ánh xa dˆng máng b‰mƒ
liể m0p ch" ph|p ánh Cạ giữ0 t<p &h80 $à t<p giá trN $%i thTi gi0n E1l"gs3. K0p >M ?bng c* tr7c
?ữ li5 &iể cI6 n@n đ9 phmc tạp là l"g
2
s. 46 nhi@n, #ạn c8 thể >M ?bng c* tr7c ?ữ li5 mạnh h-n
là mDng #om 1h0>h‰m0p3. H0>h‰m0p c8 thể t:m &i!m the" &h80 $%i đ9 phmc tạp E1Y3.
3k
Lập trình C++ Nguyễn Phú Quảng
XIII.8. Kiêu hash‡set ‚tâp hçpƒ
4r"ng l<p tr:nh giDi các #ài t"án 4in học #Zng u0>c0l, nhiề #ạn đ( P@n m*t m9t &iể ?ữ li5 r*t
mạnh là &iể t<p hợp 1&iể ?ữ li5 nà6 ch" ph|p &iểm tr0 Cem m9t ph.n tM c8 nZm tr"ng tIp hợp
h06 &hông, t:m ph.n gi0", hợp, hi5 cB0 h0i t<p hợp $%i nh03. u0>c0l là m9t tr"ng ,t ngôn ngữ c8
&iể ?ữ li5 ng6@n thB6 là t<p hợp. C $à C++ &hông c8 &iể ?ữ li5 nà6. 46 nhi@n, #ạn c8 thể >M
?bng &iể ?ữ li5 t<p hợp tr"ng [4}. 4<p hợp tr"ng [4} cen mạnh h-n t<p hợp tr"ng u0>c0l r*t
nhiề $: n8 h• trợ t*t cD các &iể ?ữ li5 1t<p hợp tr"ng u0>c0l chJ h• trợ ?ạng >'3 $%i >' lượng ph.n
tM &hông hạn ch! 1t<p hợp cB0 u0>c0l chJ được t'i đ0 2]V ph.n tM3.
XIII.9. Thuât toán ‚AIgorithmƒ
shư đ( gi%i thi5 tr"ng các ph.n trư%c, [4} cng c*p các th<t t"án c- #Dn nhZm mbc đ,ch gi7p
#ạn &hông phDi c"?e lại những giDi th<t Pá c- #Dn như 1>=p C!p, th06 th!, t:m &i!m...3. Các công
cb nà6 &hông những gi7p #ạn r7t ng=n thTi gi0n l<p tr:nh mà cen cD thTi gi0n gŽ r'i &hi th<t t"án
c- #Dn được cài đnt &hông ch,nh Các. sg"ài r0, $%i [4} tlg"rithm, #ạn c8 nhiề l/0 chọn ch"
những th<t t"án c- #Dn. H, ?b, $%i th<t t"án >=p C!p, #ạn c8 thể l/0 chọn giữ0 th<t t"án >=p C!p
nh0nh 1Pic&>"rt3 ch" &!t PD r*t nh0nh $%i đ9 phmc tạp sl"gs tr"ng đ0 >' các trưTng hợp, nhưng
lại c8 đ9 phmc tạp s•s tr"ng trưTng hợp C* nh*t $à th<t t"án >=p C!p $ng đ'ng 1he0p>"rt3 chạ6
ch<m h-n Pic&>"rt nhưng c8 đ9 phmc tạp tr"ng mọi trưTng hợp là sl"gs.
Ch7 L rZng các th<t t"án cB0 [4} tlg"rithm c8 thể áp ?bng ch" mọi &iể iter0t"r, &ể cD c"n trw
thưTng 1&hông phDi là iter0t"r cB0 [4}3. shư $<6, các th<t t"án >=p C!p, t:m &i!m, th06 th! &hông
những áp ?bng được ch" các &iể $ect"r, li>t... mà cen c th! áp d"ng cho #$ng th%ng th&'ng.
Sể &h0i #á" >M ?bng [4} 0lg"rithm, các #ạn phDi inlc?e Uile he0?er algorith#
#include <algorithm>
\" thư $i5n q0lg"rithm‚ g)m r*t nhiề hàm &hác nh0, ngưTi t0 phIn thành các nh8m hàm >0O
2 sh8m các hàm &hông th06 đ;i giá trN cB0 c"nt0iner
2 sh8m các hàm th06 đ;i giá trN cB0 c"nt0iner
2 sh8m các hàm >=p C!p
2 sh8m các hàm tr@n ?0nh >ách được >=p C!p
2 sh8m các hàm tr9n
2 sh8m các làm tr@n he0p
2 sh8m các hàm t:m min`m0C
XIII.9.1. Nhóm các hàm không thay dôi giá tr[ cúa container
a. Các thuât toán tìm kiêm
#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
int main() {
int •+, * {3444244341424342434445444434241);
int Z * siveoP(•) - siveoP(c•);
int Pirst * Pind(•4 •`Z4 1) [ •;
cout << !po thu tu cua phan tu dau tien * 1\ ! << Pirst << endl;
getchar();
return 0;
)
#include <iostream>
3]
Lập trình C++ Nguyễn Phú Quảng
#include <stdio.h>
#include <algorithm>
using namespace std;
int main() {
int •+, * {3444244341424342434445444434241);
int O+, * {14243);
int Z• * siveoP(•) - siveoP(c•);
int ZO * siveoP(O) - siveoP(cO);
int #itri * search(•4 •`Z•4 O4 O`ZO) [ •;
cout << !di tri dau tien ruat hien O trong •\ ! << #itri << endl;
getchar();
return 0;
)
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string>
using namespace std;
int main() {
string • * !gin chao tat ca moi nguoi&&&&&!;
string O * !chao!;
string ] * !gin!;
int #itri * search(•.%egin()4 •.end()4 O.%egin()4 O.end()) [ •.%egin();
cout << !di tri dau tien ruat hien O trong •\ ! << #itri << endl;

#itri * search(•.%egin()4 •.end()4 ].%egin()4 ].end()) [ •.%egin();
cout << !di tri dau tien ruat hien ] trong •\ ! << #itri << endl;
getchar();
return 0;
)
b. Các thuât toán dêm
#include <iostream>
#include <stdio.h>
#include <#ector>
#include <algorithm>
using namespace std;
int main() {
int •+, * {3444244341424342434445444434241);
int Z * siveoP(•) - siveoP(c•);
int i;

cout << !po luong so 1 trong mang\ ! << count(•4 •`Z4 1) << endl;
cout << !po luong so 3 trong mang\ ! << count(•4 •`Z4 3) << endl;
cout << !po nho nhat trong mang\ ! << cminEelement(•4 •`Z) << endl;
cout << !po lon nhat trong mang\ ! << cmarEelement(•4 •`Z) << endl;

getchar();
return 0;
)
XIII.9.2. Nhóm các hàm thay dôi giá tr[ cúa container
a. Gán giá tr[ 1 vˆng ‚fiIIƒ
^ạn c8 thể >M ?bng l5nh Uill cB0 thư $i5n q0lg"rithm‚ để tô m9t $rng giá trN cB0 Y c"nt0iner
1thưTng là Y mDng, Y $ect"r3
-- Pill algorithm erample
#include <iostream>
#include <algorithm>
#include <#ector>
#include <stdli%.h>
using namespace std;
int main () {
#ector<int> m$#ector ((); -- m$#ector\ 0 0 0 0 0 0 0 0
Pill (m$#ector.%egin()4m$#ector.%egin()`445); -- m$#ector\ 5 5 5 5 0 0 0 0
3V
Lập trình C++ Nguyễn Phú Quảng
Pill (m$#ector.%egin()`34m$#ector.end()[24(); -- m$#ector\ 5 5 5 ( ( ( 0 0
cout << !m$#ector contains\!;
int i4 n * m$#ector.sive();
Por (i*0; i<n; i``)
cout << m$#ector+i, << ! !;
cout << endl;
getchar();
return 0;
)
b. Thay thê các giá tr[ ‚repIaceƒ
}5nh replace t:m &i!m Y giá trN tr"ng c"nt0iner, th06 th! giá trN t:m được #ci giá trN m%i.
-- replace algorithm erample
#include <iostream>
#include <algorithm>
#include <#ector>
#include <stdli%.h>
using namespace std;
int main () {
int m$ints+, * { 104 204 304 304 204 104 104 20 );
#ector<int> a (m$ints4 m$ints`(); -- 10 20 30 30 20 10 10 20
replace(a#begin()$ a#end()$ %$ &&)' -- 10 ;; 30 30 ;; 10 10 ;;
cout << !a contains\ !;
int i4 n;
Por (i*04 n*a.sive(); i<n; i``)
cout << a+i, << ! !;
getchar();
)
c. Thay thê các giá tr[ theo diêu kiên ‚repIace‡ifƒ
}5nh replace_if ch" ph|p t:m giá trN the" điề &i5n ?" m9t hàm trD $ề. Sể >M ?bng l5nh nà6 #ạn
phDi &h0i #á" Y hàm c8 giá trN trD $ề là #""l nh<n th0m >' là giá trN cB0 Y element. lhi hàm trD $ề
tre, giá trN tư-ng mng >h #N th06 th! #%i giá trN m%i. Hàm &iểm tr0 n@n &h0i #á" inline để t'c đ9
nh0nh h-n.
-- replaceEiP erample
#include <iostream>
#include <algorithm>
#include <#ector>
#include <stdli%.h>
using namespace std;
inline %ool poXe(int i) { return ((ik2)**1); )
int main () {
#ector<int> a;
-- set some #alues\
Por (int i*1; i<10; i``) a.pushE%acF(i); -- 1 2 3 4 5 ' ( ;
replace(if(a#begin()$ a#end()$ )o*e$ )' -- 0 2 0 4 0 0 ( 0
cout << !a contains\ !;
int i4 n;
Por (i*04 n*a.sive(); i<n; i``)
cout << a+i, << ! !;
getchar();
)
d. Đáo nguçc containter ‚reverseƒ
^ạn c8 thể >M ?bng l5nh re$er>e để đD" ngược Y $ect"r h"nc Y li>t.
-- re#erse algorithm erample
#include <iostream>
#include <algorithm>
#include <#ector>
3X
Lập trình C++ Nguyễn Phú Quảng
#include <stdli%.h>
using namespace std;
int main () {
#ector<int> a;
-- set some #alues\
Por (int i*1; i<10; ``i) a.pushE%acF(i); -- 1 2 3 4 5 ' ( ;
re#erse(a.%egin()4a.end()); -- ; ( ' 5 4 3 2 1
-- print out content\
cout << !a contains\!;
int i4 n * a.sive();
Por (i*0; i<n; i``)
cout << a+i, << ! !;
cout << endl;
getchar();
)
XIII.9.3. Nhóm các hàm s…p xêp
a. Các thuât toán s…p xêp
#include <iostream>
#include <stdio.h>
#include <#ector>
#include <algorithm>
using namespace std;
int main() {
#ector<int> d;
int i;

Por (i*0; i<10; i``) d.pushE%acF(rand()k10);
sort(d.%egin()4 d.end());
Por (i*0; i<d.sive(); i``) {
cout << d+i, << endl;
)
getchar();
return 0;
)
#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
int main() {
int •+, * {344424434142434241);
int Z * siveoP(•) - siveoP(c•);
int i;

cout << !pap rep danh sach theo chieu tang dan! << endl;
sort(•4 •`Z);
Por (i*0; i<Z; i``)
cout << •+i, << endl;

cout << !pap rep danh sach theo chieu giam dan! << endl;
sort(•4 •`Z4 greater<int>() );
Por (i*0; i<Z; i``)
cout << •+i, << endl;

getchar();
return 0;
)
#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
3y
Lập trình C++ Nguyễn Phú Quảng
class s# {
pu%lic\
dou%le diem;
char cten;
%ool operator < (const s# €%) const {
return diem < %.diem;
)
);
int main () {
s# a+, * {{4!uai!)4{'4!Xan!)4{54!]uc!)4{44!Druc!)4{34!oao!));
int n * siveoP(a)-siveoP(ca);
sort(a4 a`n);
Por (int i*0; i<n; i``) {
cout << a+i,.diem << ! ! << a+i,.ten << endl;
)
getchar();
return 0;
)
XIII.9.4. Nhóm các hàm trên danh sách duçc s…p xêp
K9t >' th<t t"án như t:m &i!m, th@m $à" ?0nh >ách... h"ạt đ9ng nh0nh h-n 1đ9 phmc tạp là l"g
2
n
th06 $: n3. 4hư $i5n q0lg"rithm‚ h• trợ m9t >' hàm làm $i5c ri@ng $%i các ?0nh >ách đ( >=p C!p
the" thm t/ tong ?.n.
a. Tìm cân duói và cân trên ‚Iower‡bound, upper‡boundƒ
Hàm lower_bound(first, last, (alue) trD $ề iter0t"r cB0 element c'i crng tr"ng ?0nh >ách đ( >=p
C!p c8 giá trN kh%ng (&)t *uá [(alue].
Hàm upper_bound(first, last, (alue) trD $ề iter0t"r cB0 element đ. ti@n c8 giá tr+ l,n h-n
[(alue].
-- loberE%ound-upperE%ound erample
#include <iostream>
#include <algorithm>
#include <#ector>
#include <stdli%.h>
using namespace std;
int main () {
int m$ints+, * {10420430430420410410420);
int sive * siveoP(m$ints)-siveoP(m$ints+0,);
#ector<int> #(m$ints4m$ints`sive); -- 10 20 30 30 20 10 10 20
#ector<int>\\iterator lob4up;
sort (#.%egin()4 #.end()); -- 10 10 10 20 20 20 30 30
lob*loberE%ound (#.%egin()4 #.end()4 20); -- …
up* upperE%ound (#.%egin()4 #.end()4 20); -- …
cout << !loberE%ound tro #ao #i tri\ ! << int(lob[ #.%egin()) << endl;
cout << !upperE%ound tro #ao #i tri\ ! << int(up [ #.%egin()) << endl;
getchar();
)
b. Tìm kiêm ‚binary‡searchƒ
Hàm binar._search(first, last, (alue) trD $ề tre n! t:m th*6 giá trN $0le tr"ng ?0nh >ách đ( >=p
C!p từ first đ!n last.
-- %inar$Esearch erample
#include <iostream>
#include <algorithm>
#include <#ector>
#include <stdli%.h>
using namespace std;
inline %ool Xon"on (int i4int a) { return (i>a); )
int main () {
int m$ints+, * {14243444544434241);
3g
Lập trình C++ Nguyễn Phú Quảng
#ector<int> #(m$ints4m$ints`;); -- 1 2 3 4 5 4 3 2 1
-- pu dung phep so sanh nho hon de tim Fiem
sort (#.%egin()4 #.end());
cout << !Dim phan tu 3... !;
iP (%inar$Esearch (#.%egin()4 #.end()4 3))
cout << !Dim tha$&†n!; else cout << !.hong tim tha$&†n!;
-- pu dung phep so sanh lon hon de sap rep #a tim Fiem
sort (#.%egin()4 #.end()4 Xon"on);
cout << !Dim phan tu ... !;
iP (%inar$Esearch (#.%egin()4 #.end()4 4 Xon"on))
cout << !Dim tha$&†n!; else cout << !.hong tim tha$&†n!;
getchar();
)
c. Trôn 2 danh sách dŠ duçc s…p xêp ‚mergeƒ
^ạn c8 thể >M ?bng hàm merge để tr9n 2 ?0nh >ách đ( được >=p C!p thành Y ?0nh >ách &hác.
-- merge algorithm erample
#include <iostream>
#include <algorithm>
#include <#ector>
#include <stdli%.h>
using namespace std;
int main () {
int Pirst+, * {5410415420425);
int second+, * {50440430420410);
#ector<int> #(10);
#ector<int>\\iterator it;
sort (Pirst4Pirst`5);
sort (second4second`5);
merge (Pirst4Pirst`54second4second`54#.%egin());
cout << !Dhe resulting #ector contains\!;
Por (it*#.%egin(); it&*#.end(); ``it)
cout << ! ! << cit;
getchar();
)
d. Trôn 2 danh sách dŠ duçc s…p xêp ‚merge‡inpIaceƒ
-- inplaceEmerge erample
#include <iostream>
#include <algorithm>
#include <#ector>
#include <stdli%.h>
using namespace std;
int main () {
int Pirst+, * {5410415420425);
int second+, * {50440430420410);
#ector<int> #(10);
#ector<int>\\iterator it;
sort (Pirst4Pirst`5);
sort (second4second`5);
cop$ (Pirst4Pirst`54#.%egin());
cop$ (second4second`54#.%egin()`5);
inplaceEmerge (#.%egin()4#.%egin()`54#.end());
cout << !Dhe resulting #ector contains\!;
Por (it*#.%egin(); it&*#.end(); ``it)
cout << ! ! << cit;
getchar();
)
kW
Lập trình C++ Nguyễn Phú Quảng
e. Hçp 2 danh sách dŠ duçc s…p xêp ‚set‡unionƒ
-- setEunion erample
#include <iostream>
#include <algorithm>
#include <#ector>
#include <stdli%.h>
using namespace std;
int main () {
int Pirst+, * {5410415420425);
int second+, * {50440430420410);
#ector<int> #(10); -- 0 0 0 0 0 0 0 0 0 0
#ector<int>\\iterator it;
sort (Pirst4Pirst`5); -- 5 10 10 20 25
sort (second4second`5); -- 10 20 30 40 50
it*setEunion (Pirst4 Pirst`54 second4 second`54 #.%egin());
-- 5 10 15 20 25 30 40 50 0 0
cout << !union has ! << int(it [ #.%egin()) << ! elements.†n!;
getchar();
)
f. Giao 2 danh sách dŠ duçc s…p xêp ‚set‡differenceƒ
-- setEdiPPerence erample
#include <iostream>
#include <algorithm>
#include <#ector>
#include <stdli%.h>
using namespace std;
int main () {
int Pirst+, * {5410415420425);
int second+, * {50440430420410);
#ector<int> #(10); -- 0 0 0 0 0 0 0 0 0 0
#ector<int>\\iterator it;
sort (Pirst4Pirst`5); -- 5 10 15 20 25
sort (second4second`5); -- 10 20 30 40 50
it*setEdiPPerence (Pirst4 Pirst`54 second4 second`54 #.%egin());
-- 5 15 25 0 0 0 0 0 0 0
cout << !diPPerence has ! << int(it [ #.%egin()) << ! elements.†n!;
getchar();
)
XIII.9.5. Các hàm trên heap
a. Tao heap ‚make‡heapƒ
-- range heap erample
#include <iostream>
#include <algorithm>
#include <#ector>
#include <stdli%.h>
using namespace std;
int main () {
int m$ints+, * {1042043045415);
#ector<int> #(m$ints4m$ints`5);
#ector<int>\\iterator it;
maFeEheap (#.%egin()4#.end());
cout << !initial mar heap \ ! << #.Pront() << endl;
popEheap (#.%egin()4#.end()); #.popE%acF();
cout << !mar heap aPter pop \ ! << #.Pront() << endl;
#.pushE%acF(;;); pushEheap (#.%egin()4#.end());
cout << !mar heap aPter push\ ! << #.Pront() << endl;
sortEheap (#.%egin()4#.end());
kY
Lập trình C++ Nguyễn Phú Quảng
cout << !Pinal sorted range \!;
Por (unsigned i*0; i<#.sive(); i``) cout << ! ! << #+i,;
getchar();
)
b. Thêm phân tú vào heap ‚push‡heapƒ
-- range heap erample
#include <iostream>
#include <algorithm>
#include <#ector>
#include <stdli%.h>
using namespace std;
int main () {
int m$ints+, * {1042043045415);
#ector<int> #(m$ints4m$ints`5);
#ector<int>\\iterator it;
maFeEheap (#.%egin()4#.end());
cout << !initial mar heap \ ! << #.Pront() << endl;
popEheap (#.%egin()4#.end()); #.popE%acF();
cout << !mar heap aPter pop \ ! << #.Pront() << endl;
#.pushE%acF(;;); pushEheap (#.%egin()4#.end());
cout << !mar heap aPter push\ ! << #.Pront() << endl;
sortEheap (#.%egin()4#.end());
cout << !Pinal sorted range \!;
Por (unsigned i*0; i<#.sive(); i``) cout << ! ! << #+i,;
getchar();
)
l!t PD
initial mar heap \ 30
mar heap aPter pop \ 20
mar heap aPter push\ ;;
Pinal sorted range \ 5 10 15 20 ;;
c. Xóa phân tú khói heap ‚pop‡heapƒ
-- range heap erample
#include <iostream>
#include <algorithm>
#include <#ector>
using namespace std;
int main () {
int m$ints+, * {1042043045415);
#ector<int> #(m$ints4m$ints`5);
#ector<int>\\iterator it;
maFeEheap (#.%egin()4#.end());
cout << !initial mar heap \ ! << #.Pront() << endl;
popEheap (#.%egin()4#.end()); #.popE%acF();
cout << !mar heap aPter pop \ ! << #.Pront() << endl;
#.pushE%acF(;;); pushEheap (#.%egin()4#.end());
cout << !mar heap aPter push\ ! << #.Pront() << endl;
sortEheap (#.%egin()4#.end());
cout << !Pinal sorted range \!;
Por (unsigned i*0; i<#.sive(); i``) cout << ! ! << #+i,;
cout << endl;
return 0;
)
k2
Lập trình C++ Nguyễn Phú Quảng
l!t PD
initial mar heap \ 30
mar heap aPter pop \ 20
mar heap aPter push\ ;;
Pinal sorted range \ 5 10 15 20 ;;
d. S…p xêp heap ‚sort‡heapƒ
-- range heap erample
#include <iostream>
#include <algorithm>
#include <#ector>
#include <stdli%.h>
using namespace std;
int main () {
int m$ints+, * {1042043045415);
#ector<int> #(m$ints4m$ints`5);
#ector<int>\\iterator it;
maFeEheap (#.%egin()4#.end());
cout << !initial mar heap \ ! << #.Pront() << endl;
popEheap (#.%egin()4#.end()); #.popE%acF();
cout << !mar heap aPter pop \ ! << #.Pront() << endl;
#.pushE%acF(;;); pushEheap (#.%egin()4#.end());
cout << !mar heap aPter push\ ! << #.Pront() << endl;
sortEheap (#.%egin()4#.end());
cout << !Pinal sorted range \!;
Por (unsigned i*0; i<#.sive(); i``) cout << ! ! << #+i,;
getchar();
)
l!t PD
initial mar heap \ 30
mar heap aPter pop \ 20
mar heap aPter push\ ;;
Pinal sorted range \ 5 10 15 20 ;;
XIV. GIẢI MQT SÓ BÀI TOÁN BANG STL
XIV.1. ‹uán Iý sinh viên
XIV.1.1. Đê bài
/0n file1 23456.7
89 li:u (;oO từ Uile ^Y.Šsu, g)mO
2 \eng YO [' >inh $i@n cB0 trưTng 1n v nq•YWWWW3
2 3•n ?eng ti!p the"O 4hông tin cB0 Y >inh $i@n được ghi tr@n 3 ?eng, #0" g)mO Họ t@n 1t'i đ0
2W &L t/3, l%p 1t'i đ0 V &L t/3, P@ Pán 1t'i đ0 YW &L t/3
<0u c=uO 4:m $à li5t &@O
2 [' lượng l%p tr"ng trưTng $à ?0nh >ách các l%p
2 H%i m•i l%pO
o [' lượng $à ?0nh >ách các đN0 phư-ng là P@ Pán cB0 >inh $i@n tr"ng l%p
89 li:u raO tại Uile ^Y.E™4 $%i &hôn ?ạng như >0O
2 \eng YO [' l%p cB0 trưTng 1&3
2 Các ?eng ti!p the" là thông tin cB0 từng l%p 1m•i mbc được li5t &@ ?ư%i đI6 được tr:nh #à6
tr@n Y ?eng3O
k3
Lập trình C++ Nguyễn Phú Quảng
o 4en l"p
o >' >inh $i@n cB0 l%p, >' lượng đN0 phư-ng 1m3
o >' lượng >inh $i@n P@ c đN0 phư-ng Y, t@n đN0 phư-ng Y
o >' lượng >inh $i@n P@ c đN0 phư-ng 2, t@n đN0 phư-ng 2
o ...
o >' lượng >inh $i@n P@ c đN0 phư-ng m, t@n đN0 phư-ng m
O1.xZ„ O1.•‡D
5
Zgu$en dan •
4pm1
"ung ˆen
Dran dan O
4'th1
"ai ouong
Zgu$en Dhi ]
4pm1
"ung ˆen
du dan o
4'th1
Oinh oinh
]ao Dhi ‰
4'th1
"ai ouong
2
4pm1
2 1
2 "ung ˆen
4'th1
3 2
2 "ai ouong
1 Oinh oinh
XIV.1.2. Bài giái
#include <iostream>
#include <Pstream>
#include <string>
#include <map>
using namespace std;
#dePine xZ„‡D !%1.inp!
#dePine •‡D„‡D !%1.out!
int main() {
iPstream Pi;
int n4 i;
map<string4 int> lop; -- map giMa t8n lJp #3 s2 sinh #i8n
map<string4 map<string4 int> > jue; -- map giMa t8n lJp #3 %iIn 7Im s2
-- sinh #i8n c9a tfng ju8
-- %iIn 7Im n3$ c|ng l3 /nh rK giMa ju8
-- #3 s2 sinh #i8n C ju8 7Q
Pi.open(xZ„‡D); -- uC Pile input
Pi >> n; -- p2 l>Rng sinh #i8n
char sXop+100,4 sŠue+100,;
Pi.getline(sXop4 100); -- Wqc ru2ng d@ng (sau n)
Por (int i*0; i<n; i``) {
Pi.getline(sXop4 100); -- Wqc t8n (Fo s6 dSng)
Pi.getline(sXop4 100); -- Wqc t8n lJp
lop+sXop,``; -- Dh8m s2 sinh #i8n c9a lJp 7Q
Pi.getline(sŠue4 100); -- Wqc ju8
jue+sXop,+sŠue,``; -- Dh8m s2 sinh #i8n thu?c ju8 c9a lJp 7Q
kk
Lập trình C++ Nguyễn Phú Quảng
)
Pi.close(); -- WQng Pile input
oPstream Po;
Po.open(•‡D„‡D); -- uC Pile output
map<string4 int>\\iterator a;
Po << lop.sive() << endl; -- Ahi s2 l>Rng lJp
Por (a*lop.%egin(); a&*lop.end(); a``) {-- X_p jua tfng lJp
Po << a[>Pirst << endl; -- Ahi t8n lJp (th3nh ph5n 75u c9a pair)
map<string4 int> €juei * jue+a[>Pirst,;
-- A/n %iIn tham chiIu 7In %iIn 7Im ju8
-- ]9a lJp t>Tng :ng
Po << a[>second << ! ! << juei.sive() << endl;
-- Ahi s2 l>Rng sinh #i8n c9a lJp #3
-- s2 l>Rng ju8 ju/n c9a s# trong lJp
map<string4 int>\\iterator t;
Por (t*juei.%egin(); t&*juei.end(); t``) {
-- dJi msi #<ng ju84 ghi s2 l>Rng s#
-- C ju8 7Q #3 t8n ju8
Po << t[>second << ! ! << t[>Pirst << endl;
)
)
Po.close(); -- WQng Pile output
)
-ccccccccccccccccccccc Dest1 ccccccccccccccccccccccccccc
5
Zgu$en dan •
4pm1
"ung ˆen
Dran dan O
4'th1
"ai ouong
Zgu$en Dhi ]
4pm1
"ung ˆen
du dan o
4'th1
Oinh oinh
]ao Dhi ‰
4'th1
"ai ouong
cccccccccccccccccccccccccccccccccccccccccccccccccccccccc-
XIV.2. Rào dât
XIV.2.1. Đê bài
/0n file1 >?@.7
2 K9t mDnh đ*t h:nh chữ nh<t 1&,ch thư%c t'i đ0 32WWWC32WWW3 được rà" #Zng các tưTng rà"
>"ng >"ng $%i các cạnh cB0 h:nh chữ nh<t
2 K9t &h"Dng đ*t được gọi là được #D" $5 n! n8 được gi%i hạn #ci các tưTng rà"
2 H(6 t:m &h"Dng đ*t c8 ?i5n t,ch l%n nh*t được #D" $5
89 li:u (;oO từ Uile GtE.Šsu
2 \eng đ.O 2 >' ng6@n a h là chiề r9ng $à chiề c0" cB0 mDnh đ*t
2 \eng thm 2O >' ?eng lượng tưTng rà" 1nq•YWW3
2 n ?eng ti!p the"O m•i ?eng g)m k >' ng6@n 1cách nh0 #ci ?* cách3 là tọ0 đ9 2 điểm
đ. $à c'i cB0 rà". \ữ li5 $à" đDm #D" là rà" >"ng >"ng $%i cạnh cB0 h:nh chữ nh<t
89 li:u raO tại Uile ^2.E™4, g)mO
2 \eng YO \i5n t,ch cB0 $rng được #D" $5 c8 ?i5n t,ch l%n nh*t, n! &hông c8 th: in r0 giá trN 2Y
k]
Lập trình C++ Nguyễn Phú Quảng
XIV.2.2. Bài giái
XIV.3. Robot
XIV.3.1. Đê bài
A;i B (>obot). /0n file1 >@A@/.7
K9t c"n r"#"t ?i ch6ển tr@n m9t lư%i ô $ông #Zng cách nh<n m9t tr"ng các l5nh >0O
 GO š06 phDi k] đ9
 }O š06 trái k] đ9
 • nO 4i!n $ề ph,0 trư%c Y &h"Dng n 1n q YWWW3
 ™O sh*c ch;i l@n
 \O Hạ ch;i C'ng
1ch7 L rZng &hi hạ ch;i C'ng là ô đ8 đ( được tô mà3
4rạng thái #0n đ. cB0 r"#"t là nh*c ch;i, tọ0 đ9 #0n đ. là điểm 1W, W3
ŠnptO shạp ?ữ li5 từ Uile inpt.tCt g)m các thông tin >0
 K•i ?eng là Y tr"ng ] l5nh &ể tr@n 1t'i đ0 YWWW l5nh3
EtptO l!t PD ghi r0 Uile "tpt.tCt
 \eng đ. ti@n là Y >' ng6@n chJ r0 >' lượng ô được tô mà
XIV.3.2. Bài giái
#include <iostream>
#include <Pstream>
#include <string>
#include <map>
using namespace std;
#dePine xZ„‡D !ro%ot.inp!
#dePine •‡D„‡D !ro%ot.out!
class diem { -- XJp 7iGm4 l>u tqa 7? c9a 7iGm
pu%lic\
int r4 $; -- DoK 7? c9a 7iGm
diem() {) -- "3m FhCi tKo 7iGm (FhVng tham s2)
diem(int Er4 int E$) { -- "3m FhCi tKo diGm theo tqa 7?
r * Er; $ * E$;
) -- "3m so s/nh 7iGm #Ji 7iGm Fh/c
-- "3m n3$ s6 dSng 7G s‚p rIp c/c FhQa trong map
%ool operator < (const diem€ %) const {
return (r<%.r) ‹‹ (r**%.r €€ $<%.$);
)
);
map<diem4 int> •; -- Œnh rK giMa 7iGm #3 m?t s2 ngu$8n (nIu s2 ngu$8n
-- Fh/c 0 t:c l3 7iGm 7Q 7• 7i jua)
int main() {
iPstream Pi;
Pi.open(xZ„‡D);
string s;
int huong * 0; -- ">Jng FhCi 75u
int dr+, * {1404[140); -- dector di chu$Gn t>Tng :ng theo h>Jng
int d$+, * {04[14041);
int n4 i4 r*04 $*0; -- Dqa 7? 75u ti8n
%ool choi * Palse; -- DrKng th/i c9a ch^i
bhile (&Pi.eoP()) { -- Wqc 7In Fhi hIt Pile
s * !!;
Pi >> s; -- Wqc rwu Ft tn
kV
Lập trình C++ Nguyễn Phú Quảng
sbitch (s+0,) { -- .iGm tra Ft tn 75u
case ƒŽƒ\ -- Ž\ Šua$ ph0i
huong * (huong`1)k4;
%reaF;
case ƒXƒ\ -- X\ Šua$ tr/i
huong * (huong`3)k4;
%reaF;
case ƒAƒ\ -- DiIn theo h>Jng hiNn tKi
Pi >> n; -- Wqc th8m gi/ trB n
Por (i*0; i<n[1; i``) {
r `* dr+huong,; -- dBch chu$Gn tfng %>Jc
$ `* d$+huong,; -- WIm c/c V nIu trKng th/i ch^i l3 hK ru2ng
iP (choi) •+diem(r4 $), ``;
)
%reaF;
case ƒ‡ƒ\ -- Zhec ch^i
choi * Palse;
%reaF;
case ƒoƒ\ -- "K ch^i
choi * true;
•+diem(r4 $), ``; -- WIm luVn V #fa hK
%reaF;
)
)
Pi.close();
oPstream Po;
Po.open(•‡D„‡D);
Po << •.sive();
Po.close();
)
-cccccc Dest 1 ccccccccc

o

o
ccccccccccccccccccccccc-
-cccccc Dest 2 ccccccccc

o

o
A 100
X
X
A 100
XIV.4. DiŒsktra
XIV.4.1. Đê bài
XIV.4.2. Bài giái
XIV.5. Hçp diên tích hình chü nhât
XIV.5.1. Đê bài
Ch" n h:nh chữ nh<t c8 cạnh >"ng >"ng $%i các trbc EC, E6. 4:m t;ng ?i5n t,ch &hông gi0n #N che
#ci các h:nh chữ nh<t nà6 1\i5n t,ch ph.n hợp cB0 các h:nh chữ nh<t3†
XIV.5.2. Bài giái
2 GTi rạc h80 các thông tin #Zng cáchO
kX
Lập trình C++ Nguyễn Phú Quảng
. l|" ?ài các cạnh đmng
. l|" ?ài các cạnh ng0ng
. Các cạnh nà6 chi0 &hông gi0n thành m9t lư%i h:nh chữ nh<t.
2 K•i h:nh chữ nh<t >h che m9t >' ô tr"ng lư%i nà6
2 S!m t;ng ?i5n t,ch cB0 các ô #N che, #ạn t,nh được ?i5n t,ch cB0 ph.n che phB cB0 t*t cD
các h:nh chữ nh<t.
-c
]ho 1 danh sach cac hinh chu nhat co canh song song #oi man hinh
Dim hinh chu nhat co dien tich la hop cua cac hinh chu nhat na$
c-
#include <iostream>
#include <Pstream>
#include <#ector>
#include <map>
#include <algorithm>
#dePine input !dientich.inp!
#dePine output !dientich.out!
using namespace std;
t$pedeP #ector<int> dong;
struct chunhat -- DhVng tin c9a 1 hUnh chM nhLt
{
dou%le rmin4 $min4 rmar4 $mar; -- rmin4 rmar4 $min4 $mar
);
int n;
#ector<dong> a; -- O0ng 7/nh deu c/c V %B che
#ector<chunhat> cn; -- oanh s/ch c/c hUnh chM nhLt
#ector<dou%le> tr4 t$; -- Dqa 7? c/c l>Ji dqc #3 ngang
inline #oid sbap(dou%le €a4 dou%le €%) -- "3m 7^i chs 2 s2 thnc
{
dou%le t * a; a * %; % * t; -- "3m Fhai %/o inline 7G chK$ nhanh hTn
)
int main()
{
Pstream P(input);
P >> n; P.get(); -- p2 hUnh chM nhLt
cn.resive(n);
Por (int i*0; i<n; i``) -- Wqc thVng tin tfng hUnh chM nhLt
{
chunhat €a * cn+i,; -- W^i chs nIu c/c tqa 7? FhVng hRp lN
P >> a.rmin >> a.$min >> a.rmar >> a.$mar; P.get();
iP (a.rmin>a.rmar) sbap(a.rmin4 a.rmar);
iP (a.$min>a.$mar) sbap(a.$min4 a.$mar);
tr.pushE%acF(a.rmin); -- DKo m0ng tr\ tqa 7? c/c l>Ji 7:ng
tr.pushE%acF(a.rmar);
t$.pushE%acF(a.$min); -- DKo m0ng t$\ tqa 7? c/c l>Ji ngang
t$.pushE%acF(a.$mar);
)
P.close();
sort(tr.%egin()4 tr.end()); -- p‚p rIp c/c tqa 7? l>Ji d:ng #3 ngang
sort(t$.%egin()4 t$.end());
map<dou%le4 int> mr4 m$; -- O0ng /nh rK giMa tqa 7? (s2 thnc)
Por (int i*0; i<2cn; i``) -- #3 s2 th: tn
{ -- c9a tqa 7? 7Q tr8n l>Ji (s2 ngu$8n)
mr+tr+i,, * i;
m$+t$+i,, * i;
)
a.resive(2cn); -- DKo m0ng (2n)c(2n)4 to3n s2 0
Por (int i*0; i<2cn; i``) a+i,.resive(2cn4 0);
ky
Lập trình C++ Nguyễn Phú Quảng
dou%le dt * 0; -- Dlnh t^ng diNn tlch
Por (int i*0; i<n; i``)
{
chunhat % * cn+i,;
int rmin * mr+%.rmin,; -- rmin4 rmar\ ch~ s2 cKnh tr/i4 ph0i
int $min * m$+%.$min,; -- tr8n l>Ji
int rmar * mr+%.rmar,; -- $min4 $mar\ ch~ s2 c/c cKnh tr8n4 d>Ji
int $mar * m$+%.$mar,; -- tr8n l>Ji
Por (int r*rmin; r<rmar; r``) -- ou$Nt jua tet c0 c/c thu?c hcnhLt
Por (int $*$min; $<$mar; $``) {
iP (a+r,+$,**0) -- ZIu V ch>a 7>Rc 7/nh deu
{
a+r,+$, * 1; -- W/nh deu V 7Q4 #3 tlnh th8m diNn tlch
dt `* (tr+r`1,[tr+r,)c(t$+$`1,[t$+$,);
)
)
)
oPstream Po;
Po.open(output);
Po << dt; -- D^ng diNn tlch c9a c/c hUnh chM nhLt
Po.close();
)
-c
2
0 0 1 1
0 0 2 2
c-
XV. INPUT VÀ OUTPUT
kg

You're Reading a Free Preview

Tải về
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->