NGUYN PH QUNG

B MN TIN HC XY DNG
KHOA CNG NGH THNG TIN I HC XY DNG

LP TRNH C++
Ti liu lu hnh ni b
version 0.0.2

Lp trnh C++

Nguyn Ph Qung

Mc lc
I. M U.............................................................................................................................4
I.1. Mi trng pht trin.................................................................................................................... ..........4
I.2. Chng trnh u tin...................................................................................................... ......................4
I.3. Input & Output................................................................................................................ ........................5

II. NGN NG.......................................................................................................................5

II.1. C bn v ngn ng.................................................................................................. ...........................5
II.2. Kiu................................................................................................................................... ....................5
II.3. Chuyn i gia cc kiu...................................................................................................... ................7
II.4. Biu thc & ton t...................................................................................................... .........................7

III. LNH.................................................................................................................................9
III.1. Lnh dng biu thc.......................................................................................................................... ...9
III.2. Khi lnh.................................................................................................................. ............................9
III.3. Lnh r nhnh.............................................................................................................. ........................9
III.4. Vng lp for...................................................................................................................... ..................10
III.5. Vng lp while................................................................................................................. ...................13
III.6. Vng lp do...while........................................................................................................ .....................13
III.7. Nhy khng iu kin......................................................................................................... ................13

IV. HM................................................................................................................................13
IV.1. nh ngha hm................................................................................................................. .................13
IV.2. V d khai bo hm........................................................................................................................... ..14
IV.3. Khi no s dng hm...................................................................................................... ...................14
IV.4. Hm c gi nh th no?........................................................................................ ......................14
IV.5. Hm gi quy........................................................................................................... .......................15

V. MNG..............................................................................................................................17
V.1. nh ngha............................................................................................................................ ...............17
V.2. Truy cp phn t ca mng............................................................................................................. ....17
V.3. Khi to mng......................................................................................................................... ............17
V.4. Mng nhiu chiu.............................................................................................................. ..................17
V.5. S dng mng lm tham s ca hm................................................................................................ ..17

VI. CON TR.......................................................................................................................17

VI.1. Khai bo con tr................................................................................................................... ..............17
VI.2. Cc ton t trn con tr............................................................................................... ......................17
VI.3. Con tr v mng.............................................................................................................................. ...17
VI.4. Con tr hm............................................................................................................... ........................17

VII. STRUCT........................................................................................................................17
VII.1. nh ngha Struct.................................................................................................... ..........................17
VII.2. Khai bo bin................................................................................................................. ...................18
VII.3. Truy cp trng...................................................................................................... ..........................18

VIII. Stream..........................................................................................................................18
VIII.1. File stream............................................................................................................... ........................18
VIII.2. String stream............................................................................................................................ ........19
VIII.3. Ghi c nh dng............................................................................................................... ...............19

IX. KIU NGI DNG NH NGHA...............................................................................21

X. CP PHT B NH NG...........................................................................................21
2

Lp trnh C++

Nguyn Ph Qung

XI. LP................................................................................................................................21
XII. MU...............................................................................................................................21
XIII. TH VIN CHUN......................................................................................................21
XIII.1. Cc khi nim......................................................................................................... .........................21
XIII.2. Kiu vector..................................................................................................................... ..................22
XIII.3. Kiu string...................................................................................................................... ..................26
XIII.4. Kiu list (danh sch).................................................................................................................... .....29
XIII.5. Kiu set (tp hp)................................................................................................. ...........................32
XIII.6. Kiu map (nh x).................................................................................................................. ..........32
XIII.7. Kiu hash_map (nh x dng mng bm)................................................................ .......................34
XIII.8. Kiu hash_set (tp hp)............................................................................................................ .......35
XIII.9. Thut ton (Algorithm).................................................................................................................... ..35

XIV. GII MT S BI TON BNG STL.........................................................................43

XIV.1. Qun l sinh vin............................................................................................................................ ..43
XIV.2. Ro t.................................................................................................................. ..........................45
XIV.3. Robot..................................................................................................................... ..........................46
XIV.4. Dijsktra.............................................................................................................................. ...............47
XIV.5. Hp din tch hnh ch nht............................................................................................................ .47

XV. INPUT V OUTPUT......................................................................................................49

Lp trnh C++

I.

Nguyn Ph Qung

M U

C++ l ngn ng mnh, c pht trin t ngn ng C. Hc C++ em li nhiu li th cho bn vi

khi lng m ngun vo loi ln nht trong cc ngn ng, cng nh tnh tng ng vi hu ht
cc ngn ng ta C (C-like language).
Ti liu ny mong mun gip bn c mt ci nhn tng th vi cch tip cn tht ngn gn. Cu trc
sch da trn cun "C++ in a nutshell" ca nh xut bn O'Reilly.
Ti Vit nam, c rt nhiu cun sch gii thiu v C, C++. Trong ti liu ny, chng ti khng
mang tham vng xy dng mt gio trnh v C++ m ch l nhng c kt kinh nghim m chng
ti trc tip lm vic vi C++, nht l trong nhng bi ton thin v gii thut.
Mi gp xin gi v a ch: nguyenphuquang@gmail.com. Xin chn thnh cm n mi ng gp
ca cc bn.

I.1.

Mi trng pht trin

thun tin cho vic hc ngn ng, chng ti xin gii thiu 2 mi trng quen thuc bn c
th thc hnh lp trnh C++.
Microsoft Visual C++ (6.0, 7.0, 7.1): phn mm ny nm trong b phn mm Microsoft Visual
Studio.
DevC++ 5.0: Bn c th ti min ph t a ch http://www.bloodshed.net/devcpp.html, chng ti
khuyn khch cc bn s dng phn mm min ph ny.
Ton b chng trnh minh ha u c th chy trn c 2 mi trng VC++ v DevC.

I.2.

Chng trnh u tin

M DevC, bn to file mi, g vo on chng trnh di y v lu li (tt nhin l khng g vo

s dng, trong tt c cc chng trnh minh ha, chng ti s dng s dng gii thch cho
chng trnh). Sau bm Ctrl+F9 dch chng trnh, bm Ctrl+F10 chy chng trnh, bn
s thy mt mn hnh mu en v dng ch "Hello every body!", khi bn g 1 phm bt k th mn
hnh mu en s ng li.
01
02
03
04
05
06
07
08

#include <iostream>
#include <stdio.h>
using namespace std;
int main() {
cout << "Hello every body!" << endl;
getchar();
}

Dng 01, 02: S dng 2 th vin iostream v stdio.h

Dng 04: Khi cc chng trnh di v phc tp, vic t tn cho cc bin, hm gp kh khn. d
dng hn khi t tn, ngi ta chia tn thnh nhiu khng gian khc nhau gi l namespace. std l
mt namespace c s dng trong iostream v mt s th vin chun khc.
Dng 05: Hm main l hm khng th thiu trong cc chng trnh C++. Khi chng trnh c
thc thi, n s gi n hm main.
Dng 06: Trong C++, khi nim stream ch mt dng d liu (u vo hoc u ra). Trong trng
hp ny cout l dng d liu ra (mc nh l mn hnh). S dng ton t <<, chng ta thc hin vic
a 2 d liu ln lt l xu k t "Hello every body!" v k t xung dng endl ra mn hnh.

Lp trnh C++

Nguyn Ph Qung

Dng 07: getchar() l hm gip chng trnh dng li v i ngi dng g mt phm bt k. Thc
cht, trong v d ny khng cn phi dng chng trnh. Nhng do c tnh ca mi trng DevC
v VC l mn hnh output s bin mt sau khi chng trnh chy xong, do chng ti a thm
lnh ny dng chng trnh li, gip cc bn quan st thy xu k t in trn mn hnh.

I.3.

II.

Input & Output

NGN NG

II.1.

C bn v ngn ng

Ngn ng lp c nhiu im tng t vi ngn ng t nhin

-

Cha mt tp t kha (ging vi t vng ca ngn ng t nhin)

Cha mt lot cc quy tc kt hp cc t kha, ton t vi nhau (ging vi ng php trong

ngn ng t nhin)

Khi bn tho mt ngn ng lp trnh, vic hc mt ngn ng khc l tng i n gin (cng
nh bn hc ting Anh th c th hc ting Php rt nhanh v hai ngn ng ny c nhiu t tng
ng vi nhau).
Vic hc ngn C++ (cng nh hc ting Anh) em li cho bn li th rt ln v y l ngn ng
c s dng ph bin nht. Hn th na c rt nhiu cc ngn ng lp trnh khc c xy dng
trn c s c php ca C++ (gi l cc ngn ng ging-C C-like), do bn c th tip cn rt
nhanh vi cc ngn ng ny nu thng tho vi C++.

II.2.
II.2.1.

Kiu
Cc kiu c bn

Phn ny trnh by cc kiu d liu c bn ca C++. Trong gii hn ca ti liu ny, ti khng trnh
by v con tr. Mc d con tr l mt trong nhng c im ni bt ca C++ nhng tnh phc tp
ca con tr d gy nhm ln cho ngi mi lm quen. Chng ta s gii quyt cc bi ton trn C++
m khng hoc hn ch ti a s dng con tr.
a.

Kiu s

S nguyn
-

Kiu char (1 byte): (-128 n 127)

Kiu short (2 byte): (-32768 n 32767)

Kiu int, long (4 byte): (-2 t n 2 t)

Tt c cc kiu trn, nu b sung unsign :

o unsign char:
o unsign short:
o unsign int:

Vic la chn kiu d liu trong bi ton phc thuc vo vng gi tr ca bin. Khong gi
tr cng ln, bin cng chim nhiu b nh. Chng trnh C++ dch trn DevC hot ng
trn mi trng Windows thng l h iu hnh 32 bit, s nguyn c s dng ph bin
nht l kiu int.
5

Lp trnh C++

Nguyn Ph Qung

V d

char a;
int b = 20;
long c = 30;
unsign char d = 200;

S thc
-

float (4 byte): S thc chnh xc n.

double (8 byte): S thc chnh xc kp.

Logic
-

bool: c 2 gi tr l true v false

II.2.2.

Cc kiu phc

a.

Kiu mng
-

Mng l mt dy cc phn t cng kiu c sp lin tip nhau trong b nh

Cc phn t c phn bit vi nhau bi ch s, l cc s tun t bt u t 0

V d

int a[100];

//
//
//
//
//

long b[10];

Mng c khai bo theo v d trn l mng 1 chiu. Chiu ca mng l s ch s s dng

xc nh mt phn t (ging nh h ta 1 chiu, 2 chiu, 3 chiu)

V d khai bao v s dng mng nhiu chiu nh sau

int a[3][3];

a[1][1] = 5;

b.

Khai bo mng gm 100 s int

a[0] l 1 s int, phn t u tin ca mng
a[1] l 1 s int, phn t th 2 ca mng
a[99] l 1 s int, phn t cui cng ca mng
Khai bo mng gm 10 s long

//
//
//
//
//
//
//
//

Khai bo a l mng 2 chiu (ging nh 1 bng)

a[0] l mt mng 1 chiu gm 3 s nguyn (ging nh 1 dng ca bng)
a[0][0] l s int u tin ca dng
a[0][1] l s int th 2 ca dng
a[0][2] l s int cui cng ca dng
a[1] l dng th 2 ca bng
a[2] l dng cui cng ca bng
Gn gi tr ca s nguyn dng 1, ct 1 l 5

Kiu struct

Struct l kiu d liu cho php bn tp hp nhiu thnh phn vo trong cng mt bin. Ly v d
thng tin ca mt im gm 2 ta x, y, thng tin ca mt on thng gm im u v im
cui.
Struct l kiu d liu, do bn phi khai bo kiu d liu bng lnh typedef ri mi c th khai
bo c cc bin thuc kiu ny. C php khai bo struct nh sau:
struct <Tn_kiu> {
// Khai bo kiu struct
<Kiu_trng_1> <Tn_trng_1>;
// Trng ca struct (ging khai bo bin)
<Kiu_trng_2> <Tn_trng_2>, <Tn_trng_3>;
};
<Tn_kiu> <bin_1>, <bin_2>;

// Khai bo bin thuc kiu mi to ra

<bin_1>.<Tn_trng_1> = <Gi_tr>;

// Truy cp trng d liu ca bin

Cc thnh phn khai bo bn trong struct c gi l trng (field). Mt struct gm nhiu trng,
bin thuc kiu struct

Lp trnh C++

II.2.3.

Nguyn Ph Qung

Cc kiu stl

a.

Kiu string

b.

Kiu vector

c.

Kiu vector

II.3.

Chuyn i gia cc kiu

II.4.

Biu thc & ton t

II.4.1.

Biu thc

Biu thc l kt hp ca cc ton t v ton hng. Ton hng c th l cc s hoc cc bin.

II.4.2.

Ton t

a.

Cc php ton s hc
-

Php cng +
o a+b

Php tr o a-b

Php nhn *
o a*b

Php chia /: Ch trong php chia

o Nu c 2 ton hng cng l s nguyn th php chia l chia nguyn

10 / 3 cho gi tr 3

o Nu 1 trong 2 ton hng l s thc th php chia l chia s thc

10.0 / 3 cho gi tr 3.3333333

Php ly d: %
o 10 % 3 cho gi tr 1

b.

Cc php ton so snh

-

So snh bng ==
o 10 == 3 cho gi tr false
o 10 == 10 cho gi tr true

So snh khc !=
o 10 != 3 cho gi tr true
7

Lp trnh C++

Nguyn Ph Qung

So snh ln hn >

So snh nh hn <

So snh ln hn hay bng >=

So snh nh hn hay bng <=

c.

Cc php ton logic

-

Php ton and &&

o 10==3 && 5>4: cho gi tr false
o 10>3 && 5>4: cho gi tr true

Php ton or ||
o 10==3 || 5>4: cho gi tr true
o 10==3 || 5<4 cho gi tr false

Php ton not !

o !(10==3) cho gi tr

d.

Cc php ton trn bit

-

Php ton and tng bit &

o 10 & 3 = 10102 & 00112 = 00102
o 10 & 15 = 10102 & 11112 =10102

Php ton or tng bit |

o 10 | 3 = 10102 | 00112 = 10112
o 10 | 15 = 10102 | 11112 = 11112

e.

Cc php ton 1 ngi

-

Php tng 1 n v
o i++ (ch dnh cho bin c gi tr nguyn)

Php gim 1 n v
o i

Php tng gi tr ca bin

o i += 2

Php gim gi tr ca bin

o i -= 2

Php nhn gi tr ca bin vi 1 s

o i *= 5

Php chia gi tr ca bin cho 1 s

o i /= 5

Cc php ton khc nh &=, |=, &&=, ||= ... tng t

Lp trnh C++

III.

Nguyn Ph Qung

LNH

III.1.

Lnh dng biu thc

III.1.1.

Php gn

Tn bin = Biu thc;

-

Biu thc c th l 1 hng s

Biu thc c th l 1 bin

Biu thc c th l bin v hng s kt hp vi nhau bi ton t

III.2.

Khi lnh

Cc khi lnh phn chng trnh thnh nhiu khi con. Vic phn khi gip chng trnh r
rng, d hiu hn theo nguyn tc chia tr. Mt khi lnh c t trong cp ngoc { } v c
coi nh mt lnh n.
C++ cho php khai bo bin ti bt k ni no trong chng trnh. Bin khai bo trong khi lnh
no th ch tn ti trong khi chng trnh (bin khai bo trong khi chng trnh trong khng
th s dng trong khi chng trnh ngoi).
V d v vic s dng cc khi chng trnh.
if (a>b) {
int m;
//
m = 1;
//
if (d>e) {
m = 5; //
}
} else {
m = 10;
//
}

III.3.

Bin m khai bo trong khi if (a>b)

m c th c s dng ti cng khi chng trnh
m c th c s dng ti khi chng trnh bn trong
m khng th s dng c khi chng trnh ngoi

Lnh r nhnh

Lnh if s dng c hay khng thc hin mt on chng trnh theo mt iu kin (gi l r
nhnh). Lnh if gm 2 dng: rt gn v y
-

Dng rt gn: Nu <iu_kin> ng th thc hin <Lnh>

if (<iu_kin>) {
<Lnh>

o <iu_kin> c th l

Mt biu thc logic

Mt biu thc kiu s (s khc 0 c coi l ng, bng 0 l sai)

o Nu <Lnh> ch l 1 lnh n, bn khng cn trong khi chng trnh bng cp

ngoc {}. Tuy nhin, vic ny khng c khuyn khch.
-

Dng y : Nu <iu_kin> l ng th thc hin <Lnh_nu_ng>, ngc li thc

hin <Lnh_nu_sai>
if (<iu_kin>) {
<Lnh_nu_ng>;
} else {
<Lnh_nu_sai>;
}

If l mt cu trc iu khin c s dng ph bin nht. on chng trnh sau s nu v d s

dng lnh if.
9

Lp trnh C++

Nguyn Ph Qung

#include <iostream>
#include <stdlib.h>
using namespace std;
int main ()
{
int gio;
cout << "Nhap vao gio (0-24): ";
cin >> gio;
if (gio<12)
{
cout << "Chao buoi sang";
} else
{
cout << "Chao buoi chieu";
}
getchar();
getchar();
}

III.4.

Vng lp for

III.4.1.

C php vng lp for

Vng lp for ca C++ khi qut hn vng lp for ca Pascal. Bn c th s dng vng lp vi c
php rt mm do cho nhiu hon cnh khc nhau. C php ca vng lp for nh sau:
for (<Lnh_khi_to> ; <iu_kin> ; <Lnh_thay_i>)
{
<Lnh_lp>;
}

Trnh t thc hin ca vng lp nh sau:

-

Thc hin <Lnh_khi_to>

Kim tra <iu_kin>

o Nu <iu_kin> l ng:

Thc hin <Lnh_lp>

Thc hin <Lnh_thay_i> thay i trng thi

Lp li bc th 2 (Kim tra iu kin)

o Nu <iu_kin> sai, thot khi vng lp

Xt v d sau:
for (int i=0; i<3; i++)
{
cout << "i = " << i << endl;
}

Thc hin lnh khi to (i=0)

Kim tra iu kin (i<3)

o i=0 nn iu kin l ng

Thc hin lnh cout...

lnh ny vit ra mn hnh dng ch "i = 0"

Thc hin lnh thay i

i++ (i tng t 0 thnh 1)

Lp li bc kim tra

Kim tra iu kin (i<3)

o i=1 nn iu kin l ng

Thc hin lnh cout...

lnh ny vit ra mn hnh dng ch "i = 1"

10

Lp trnh C++

Nguyn Ph Qung

Thc hin lnh thay i

Lp li bc kim tra

i++ (i tng t 1 thnh 2)

Kim tra iu kin (i<3)

o i=2 nn iu kin l ng

Thc hin lnh cout...

lnh ny vit ra mn hnh dng ch "i = 2"

Thc hin lnh thay i

i++ (i tng t 2 thnh 3)

Lp li bc kim tra

Kim tra iu kin (i<3)

o i=3 nn iu kin sai, thot khi vng lp

Nh vy, vi vng lp nu trn, chng trnh thc hin lnh lp 3 ln, vit ra mn hnh 3 dng
i=0
i=1
i=2
Vng lp kt thc khi i = 3 (iu kin kim tra sai)

III.4.2.

Vng lp for lng nhau

V d s dng vng lp for lng nhau vit bng cu chng ra mn hnh. Trong trng hp ny
vng lp for s hot ng nh sau:
i=0
- Thc hin vng lp for vi j = 0, 1, 2,... , 8, 9 (10 ln lp, mi ln vit ra tch i*j), sau
vit xung dng.
i= 1
- Thc hin vng lp vi j = 0, 1, 2,... 9
i=2
- ....
i=9
- Thc hin vng lp vi j = 0, 1, 2,... 9
#include <iostream>
#include <stdlib.h>
#include <iomanip>
using namespace std;
int main ()
{
for (int i=0; i<10; i++)
{
for (int j=0; j<10; j++) cout << setw(4) << i*j;
cout << endl;
}
getchar();

Kt qu ca on chng trnh s nh sau:

11

Lp trnh C++

Nguyn Ph Qung

Vng lp for ca C++ c th thay th vng lp for... downto ca Pascal bng cch thay i iu kin
kim tra v lnh tng thnh lnh gim. V d sau vit ra 100 s t 990, 980, 970 n 0
#include <iostream>
#include <stdlib.h>
#include <iomanip>
using namespace std;
int main ()
{
for (int i=990; i>=0; i-=10)
{
cout << i << " ";
}
getchar();
}

III.4.3.

S dng break v continue trong vng lp for

Trong vng lp for, bn c th s dng cc lnh sau:

- break thot khi vng lp
- continue tip tc thc hin bc tip theo ca vng lp
Sau y l v d s dng break v continue:
#include <iostream>
#include <stdlib.h>
#include <math.h>
using namespace std;
int main()
{
int n = 100;
int i, j, m;
for (i=1; i<=n; i++) {

// Vit tt c cc s nguyn t t 1 n n ra mn hnh

// Xt tng s
// Xt tt c cc s t 2 n cn 2 ca i
for (j=2, m = sqrt(i); j<=m; j++) {
if (i%j==0) break; // Nu c 1 s l c th thot
}
// Nu thot khi i chia ht cho j th i ko phi l s nguyn t
// Nu i khng chia ht cho j, s i l nguyn t
if (i%j!=0) cout << i << " ";

}
getchar();
}

12

Lp trnh C++

Nguyn Ph Qung

III.5.

Vng lp while

C php
while (<iu_kin>)
{
<Lnh_lp>;
}

Trong khi <iu_kin> cn ng th thc hin <Lnh_lp>

Vng lp while t khi c s dng v bn c th s dng vng lp for thay cho while.
Vng lp while v do... while u c th s dng break v continue tng t vng lp

III.6.

Vng lp do...while

do
{

<Lnh_lp>;
} while (<iu_kin>);

Thc hin <Lnh_lp> cho n khi <iu_kin> sai.

III.7.

Nhy khng iu kin

Lnh goto s dng nhy n mt v tr trong chng trnh. Lnh goto ph v tnh cu trc ca
chng trnh nhng nu bit tn dng s lm gim phc tp ca chng trnh. Vn vi v d vit
ra cc s nguyn t, bn c th chnh sa chng trnh cho n gin hn bng cch s dng goto:
#include <iostream>
#include <stdlib.h>
#include <math.h>
using namespace std;
int main()
{
int n = 100;
int i, j, m;
for (i=1; i<=n; i++) {
for (j=2, m = sqrt(i); j<=m; j++) {
// Nu i chia ht cho j, nhy n v tr "KoNguyenTo"
if (i%j==0) goto KoNguyenTo;
}
// Nu i khng chia ht cho bt c j no, i l s nguyn t
cout << i << " ";
// Nu i chia ht cho 1 s j, Chng trnh s nhy trc tip n
// v tr KoNguyenTo

KoNguyenTo:;
}
getchar();
}

IV.

HM

IV.1.

nh ngha hm

C php:
<Kiu_hm> <Tn_hm>([Danh_sch_tham_s])
{
<Lnh>;
return <Gi_tr_tr_v>;
<Lnh>;
}

Trong :
- <Kiu_hm>: Kiu gi tr tr v ca hm, (nu hm khng tr v gi tr, kiu hm l void)
13

Lp trnh C++

Nguyn Ph Qung

- <Tn_hm>: Tn ca hm (quy c ging nh t tn bin khng c du cch, khng

cha k t c bit)
- Nu hm c kiu void, c th dng lnh return thot khi hm
- Nu hm c kiu khc void, bn phi tr v gi tr tng ng vi kiu (v d kiu int th
phi l return 1)
- Nu khng c tham s, bn vn phi c cp ngoc ()
Danh sch tham s c lit k nh sau:
<Kiu_tham_s_1> <Tn_tham_s_1>, <Kiu_tham_s_2> <Tn_tham_s_2>,...

IV.2.

V d khai bo hm

#include <iostream>
#include <fstream>
#include <stdio.h>
using namespace std;
// Hm tnh tng ca 2 s
// C 2 tham s a, b (kiu int)
// Tr v tng ca a v b (kiu int)
int Tong(int a, int b)
{
return a+b;
}
int main()
{
cout << "Ham tinh tong: " << Tong(20,34) << endl;
getchar();
}

IV.3.

Khi no s dng hm

Hm c s dng trong cc trng hp sau:

- Mt on lnh c lp i, lp li nhiu ln
- Mt on chng trnh qu di, cn chia nh d qun l

IV.4.

Hm c gi nh th no?

Cc bin v tham s ca hm c lu trong stack, mi khi bn gi hm, my tnh thc hin cc

cng vic sau:
- Ln lt a cc tham s vo trong stack
- Lu li v tr gi hm (ca hm hin ti)
- Tr chng trnh sang v tr mi (ca hm c gi)
- Ly cc tham s ra khi stack
- Mi bin c khai bo trong chng trnh con s c a vo stack
Khi thot khi chng trnh con, my tnh lm vic theo quy trnh ngc li
- Ly cc bin khai bo ra khi stack
- Lu li gi tr tr v ca hm (trong thanh ghi)
- Tr chng trnh v v tr c (trc khi gi hm)
Vi quy trnh ny, c th nhn ra cc c im sau:
- Khi gi hm, b nh ca stack y ln bng tng kch thc ca cc tham s v cc bin
khai bo trong hm
14

Lp trnh C++

Nguyn Ph Qung

- Sau khi thot khi hm, vng b nh cp cho cc tham s v bin trong hm c khi
phc, stack tr v trng thi c
- Cc hm c th gi ln nhau, mi ln gi hm stack li y thm. Stack cha thng tin th
t cc hm gi nhau v cc bin trong hm (thng tin ny gi l Call stack)

IV.5.

Hm gi quy

quy l c ch mt hm t gi chnh n. Nh s dng stack, mi hm s c vng nh lu gi

tham s v bin ca ring n. Cc vng nh ny c sp xp trn stack (hm gi cui cng s
c ly ra trc tin).
Xt v d kinh in sau:
#include <iostream>
#include <fstream>
#include <stdio.h>
using namespace std;
// Hm tnh giai tha ca mt s
// S dng cng thc truy hi n! = n * (n-1)!
// Hm GiaiThua(n) c tnh t hm GiaiThua(n-1)
// Tc l hm GiaiThua t gi li chnh n ( quy)
int GiaiThua(int n)
{
if (n>=1) return n*GiaiThua(n-1); else return 1;
}
int main()
{
int n;
cout << "n = "; cin >> n;
cout << "n! = " << GiaiThua(n) << endl;
fflush(stdin);
getchar();
}

Chng trnh trn tnh giai tha ca mt s bng cch s dng hm GiaiThua. Bn thn hm ny s
dng cng thc truy hi n! = n * (n-1)! Hm GiaiThua(n) gi hm GiaiThua(n-1), GiaiThua(n-1)
gi GiaiThua(n-2). C tun t cho n hm GiaiThua(1), hm ny qu n gin v cho gi tr 1 nn
khng gi quy.
Nh vy, hm GiaiThua(n) c tnh bng cch gi quy n ln thay v dng vng lp. cc bn
hiu r hn v quy, chng ta phn tch hot ng ca hm GiaiThua(n) vi n=4.
Begin

End
return
4*6=24

4>=1

return
3*2=6

4*GiaiThua(3)

return
2*1=2

3*GiaiThua(2)

2>=1

2*GiaiThua(1
)
return
1
1>=1

Chng ta hy th phn tch qu trnh hot ng ca cc hm khi gi quy qua bng sau
15

Lp trnh C++

Nguyn Ph Qung

Bc

M t

main()

Chng trnh bt u hot

ng t hm main()

gi GiaiThua(4)

Hm main() thc hin li gi

hm GiaiThua(4)

Hm GiaiThua(4)
GiaiThua(3)

gi GiaiThua(3)

Stack

gi

hm
4

gi GiaiThua(2)

Hm GiaiThua(3)
GiaiThua(2)

gi

hm
2
3
4

gi GiaiThua(1)

Hm GiaiThua(2)
GiaiThua(1)

gi

hm
1
2
3
4

Tr v gi tr n=1, hm GiaiThua(1) khng

ca
gi quy m tr v gi tr 1,
GiaiThua(1)
sau thot ra, tr v hm
gi n (l hm GiaiThua(2))

1
2
3
4

Tr v gi tr n=2, Tnh n*GiaiThua(1) = 2*1

ca
=2
GiaiThua(2)
Tr v gi tr 2
Thot tr v hm gi hm
ny (l hm GiaiThua(3))
Tr v gi tr n=3, Tnh n*GiaiThua(2) = 3*2
ca
=6
GiaiThua(3)
Tr v gi tr 6
Thot tr v hm gi hm
ny (l hm GiaiThua(4))
Tr v gi tr n=4, tnh n*GiaiThua(3) = 4*6 =
ca
24
GiaiThua(4)
Tr v gi tr 24
16

2
3
4

3
4

Lp trnh C++

Nguyn Ph Qung

Thot tr v hm gi hm
ny (l hm main())

V.

MNG

V.1.

nh ngha

V.2.

Truy cp phn t ca mng

V.3.

Khi to mng

V.4.

Mng nhiu chiu

V.5.

S dng mng lm tham s ca hm

VI.

CON TR

Trong my tnh, b nh c sp xp trong cc lin tip nhau, mi chim 1 byte. Cc nh ny

phn bit vi nhau bi a ch (gn ging cc phn t ca mng phn bit vi nhau bi ch s).
Mi bin, ty theo kch thc s chim 1 hoc nhiu nh lin tc trong b nh. a ch ca bin
l a ch ca nh u tin ca bin .
Trong C++, c mt loi bin lu li a ch ca cc nh, cc bin ny c gi l con tr. Con tr
cng l bin, c kch thc 4 byte, lu 1 s l a ch ca cc bin.

VI.1.

Khai bo con tr

VI.2.

Cc ton t trn con tr

VI.3.

Con tr v mng

VI.4.

Con tr hm

VII.
VII.1.

STRUCT
nh ngha Struct

17

Lp trnh C++

Nguyn Ph Qung

VII.2.

Khai bo bin

VII.3.

Truy cp trng

VIII.

Stream

VIII.1.

File stream

VIII.1.1.

Ghi file

ghi d liu ra file text, bn s dng kiu d liu ofstream (o = output, f = file). Kiu d liu ny
yu cu bn phi khai bo header l <fstream>.
iostream c cc phng thc sau:
-

f.open("tn file"): M file

f.close(): ng file

#include <iostream>
#include <fstream>
using namespace std;
int main () {
ofstream myfile;
myfile.open ("c:/vidu.txt");
myfile << "Ghi thong tin ra file." << endl;
myfile << 123.43 << endl;
myfile.close();
return 0;
}

VIII.1.2.
-

c file

Tng t ghi file, c file text s dng kiu d liu ifstream (i = input, f = file).

#include <iostream>
#include <fstream>
#include <stdio.h>
using namespace std;
int main () {
ifstream myfile;
myfile.open ("c:/vidu.txt");
int a, b, c, d, e;
myfile >> a >> b >> c >> d >> e;
myfile.close();
cout << a << " " << b << " " << c << " " << d << " " << e << endl;
getchar();
return 0;

// Noi dung file

/*
3 4 5 6 7
*/

V d trn mi ch minh ha c cc gi tr lin tip t file. c cc dng, xu k t... ifstream

c cc phng thc sau:
-

f.eof(): Kim tra xem ht file cha? Tr v 0 nu cha ht file, 1 nu ht file

18

Lp trnh C++

Nguyn Ph Qung

f.get(): c 1 k t trn file: S dng c k t xung dng sau khi dng cc ton t dn
hng t stream ra bin (tham kho v d). Tr v k t va c c.

getline(f, str): c mt dng t file (vo xu k t str)

Sau khi c 1 dng t file, bn c th dng istringstream c d liu t lung xu k t

vo cc bin. (tham kho v d)

/*
c vo t file readfile.txt vi cu trc
Dng 1: S dng ca mng 2 chiu
Cc dng tip theo, mi dng l cc phn t ca mng 2 chiu (lu , s phn t
mi dng c th khc nhau, khng c s ghi s lng phn t u)
*/
#include <iostream>
#include <fstream>
// header cho c ghi file
#include <sstream>
// header cho c ghi trn string
#include <stdio.h>
#include <vector>
using namespace std;
int main () {
int n;
typedef vector<int> dong;
vector<dong> a;
string line;
int b;

// Kiu dng (mng s nguyn)

// Mng 2 chiu (mng cc dng)

ifstream f("readfile.txt");
// M file
f >> n; f.get();
// c s dng, f.get(): xung dng
a.resize(n);
// t s dng cho mng 2 chiu
for (int i=0; i<n; i++)
{
getline(f, line);
// c t dng vo xu line
istringstream fs(line);
// To stream fs t xu line
while (fs >> b) a[i].push_back( b ); // c tng s t stream fs
}
f.close();
// ng file
for (int i=0; i<a.size(); i++)
// In cc phn t ca mng
{
for (int j=0; j<a[i].size(); j++) cout << a[i][j] << " ";
cout << endl;
}
}

getchar();

// Noi dung file readfile.txt

/*
3
1 2 3 4
5 6 7 8 9
10 11
*/

VIII.2.

String stream

VIII.2.1.

istringstream

VIII.2.2.

ostringstream

VIII.3.

Ghi c nh dng

C h tr c ghi theo nh dng (v d: s lng ch s sau du phy) bng cch s dng cc tham
s % trong phn nh dng.
19

Lp trnh C++

Nguyn Ph Qung

C++ cng cho php lm tng t vi th vin iomanip (vit tt ca manipulate). s dng th
vin ny, bn khai bo
#include <iomanip>

VIII.3.1.

Ghi vi s lng du phy xc nh

Nu mun ghi s thc vi 3 ch s sau du phy, bn s dng lnh setprecision. Ch

setpresision(n) s ghi ra n-1 ch s sau du phy (tnh c du chm l n ch).
#include <iostream>
#include <stdlib.h>
#include <iomanip>
using namespace std;
int main () {
cout << setprecision(4) << (20.0/3) << endl; // Ghi ra 3 ch s sau du phy 6.667
getchar();
}

VIII.3.2.

Ghi vi s lng k t xc nh

Bn c th s dng lnh setw xc nh s lng k t s c ghi ra cho ln ghi tip theo. Cn l

mc nh l bn phi. Nu bn mun chuyn sang cn l tri bn s dng lnh left. Ch : cc lnh
left v right s cn l tri v phi cho tt c cc lnh vit sau .
#include <iostream>
#include <stdlib.h>
#include <iomanip>
using namespace std;
int main ()
cout
cout
cout

{
<< setw(10) << 123 << setw(10) << 456 << endl;
<< setw(10) << 123 << 456 << endl;
<< left << setw(10) << 123 << setw(10) << 456 << endl;

//
//
// 123

123
123456
456

456

getchar();

VIII.3.3.

Ghi vi h c s 8, 10, 16

Bn c th s dng lnh setbase a cc s vi cc h c s khc nhau ra ostream. Cc h c s

c th s dng l 10, 16 v 8. Ch , lnh setbase c tc dng i vi tt c cc s c vit ra sau
lnh ny. Lnh showbase s hin th cc s cng vi cch ghi trong C
-

123: cch ghi bnh thng ca s 123 h thp phn

0x7b: cch ghi h c s 16 (hexa) ca s 123

0173: cch ghi h c s 8 ca s 123

Sau khi ghi vi h c s khc nhau km theo showbase, bn c th s dng noshowbase tt ch

ny i.
#include <iostream>
#include <stdlib.h>
#include <iomanip>
using namespace std;
int main () {
cout << setbase(16) << 123 << endl;
cout << 123 << endl;
cout << setbase(8) << 123 << endl;
cout << showbase;
cout << setbase(16) << 123 << endl;
cout << setbase(10) << 123 << endl;
cout << setbase(8) << 123 << endl;
cout << noshowbase;
cout << setbase(16) << 123 << endl;
getchar();
}

// 7b
// 7b
// 173
// 0x7b
// 123
// 0173
// 7b

20

Lp trnh C++

Nguyn Ph Qung

IX.

KIU NGI DNG NH NGHA

X.

CP PHT B NH NG

XI.

LP

XII.

MU

XIII.

TH VIN CHUN

C++ c nh gi l ngn ng mnh v tnh mm do, gn gi vi ngn ng my. Ngoi ra, vi

kh nng lp trnh theo mu, C++ khin ngn ng lp trnh tr thnh khi qut, khng c th v
chi tit nh nhiu ngn ng khc. Vi khi nim mu, nhng ngi lp trnh ra khi nim lp
trnh khi qut (generic programming), C++ c cung cp km vi mt b th vin chun STL
(Standard Template Library). B th vin ny thc hin ton b cc cng vic vo ra d liu
(iostream), qun l mng (vector), thc hin hu ht cc tnh nng ca cc cu trc d liu c bn
(stack, queue, map, set...). Ngoi ra, STL cn bao gm cc thut ton c bn: tm min, max, tnh
tng, sp xp (vi nhiu thut ton khc nhau), thay th cc phn t, tm kim (tm kim thng v
tm kim nh phn), trn. Ton b cc tnh nng nu trn u c cung cp di dng mu nn
vic lp trnh lun th hin tnh khi qut ha cao, lm vic d dng trn tt c cc kiu d liu. Nu
bn lp trnh gii quyt cc bi ton thin v thut ton, STL l s la chn ng n, hp l cho
php bn gii bi ton rt nhanh chng, loi b c nhiu cng sc trong vic ci t cc thut
ton c bn.

XIII.1.
XIII.1.1.

Cc khi nim
Container

Container (thng cha) l khi nim ch cc i tng lu tr cc i tng (gi tr) khc. i
tng container s cung cp cc phng thc truy cp cc thnh phn (element) ca n. C th
hn, tt c cc container u cha cc b lp (iterator) cho php duyt qua ton b cc element
ca container.
Cc container c phn loi theo tnh cht th t ca cc element, bao gm cc loi sau:
-

Forward container

Reversible container

Random Access container

Mt s container hay c s dng nht gm vector (tng t nh mng), vector l Random access
container (ngi dng c th truy cp trc tip bt c phn t no trn vector).

XIII.1.2.

Iterator

Iterator (b lp) l khi nim s dng ch mt con tr tr n cc i tng. Mi container c

mt loi iterator khc nhau tr n cc thnh phn ca container. iterator ln lt tr n tng
thnh phn trong container, chng ta s dng cc ton t tng (++).
21

Lp trnh C++

Nguyn Ph Qung

Khi nim iterator cho php bn lm vic mt cch tng qut vi bt k mt kiu d liu no, t
nhng kiu d liu truy cp ngu nhin (vector) n cc nh x (map), tp hp (set), danh sch (list)
cho n nhng kiu d liu n gin nh mng.
Do , iterator gn lin vi tt c cc loi container, y l khi nim bn cn nm rt vng nu
mun lm vic tt vi STL.

XIII.1.3.

Mt s phng thc c bn ca Container

Container gm nhiu loi, nhng tt c cc container u gm cc phng thc c bn sau

Phng thc

M t

a.begin()

Tr v iterator bt u ca container

a.end()

Tr v iterator cui cng ca container

a.size()

Kch thc (s lng element) ca container

a.max_size()

Kch thc ti a ca container

a.empty()

Tr v gi tr != 0 nu container trng (khng c element no), 0 nu

ngc li

a.swap(b)

Hon i 2 container vi nhau (ging vic hon i gi tr ca 2 bin

kiu s)

XIII.2.

Kiu vector

Kiu vector c th coi l kiu mng trong lp trnh C truyn thng. Mng l tp hp cc gi tr cng
kiu, c sp xp ni tip nhau. Cc phn t ca mng c th c truy cp ngu nhin qua ch s.
Vn t ra: Nu vector l mng th ti sao li phi s dng vector khi bn qu quen thuc vi
mng? Chng ti xin phn tch mt s nhc im sau ca mng:
-

Nu bn s dng mng tnh: Mng ny lun c khai bo vi kch thc ti a m bn c

th dng n tn nhiu vng nh tha

Nu bn s dng mng ng: Bn phi xin cp pht b nh, lm vic vi con tr. Con tr l
khi nim hay trong C, C++, nhng n l nguyn nhn ca rt nhiu rc ri trong lp trnh.

Nhc im quan trng nht: Nu bn s dng mng vt ch s vt qu kch thc

khai bo, C++ s khng thng bo li, iu ny dn n li dy chuyn do cc lnh li
tc ng n cc bin khc trong chng trnh (trong Pascal bn c th kim tra trn ch s
mng bng dn bin dch range check).

vector l mt container cung cp kh nng s dng mng mm do, c kim sot range check khi
cn thit, vi kch thc ty (m khng cn phi s dng con tr). Ngoi ra vector cho php bn
chn thm hoc xa i mt s phn t ch bng 1 lnh (khng phi s dng vng lp nh i vi
mng).
s dng vector, bn phi khai bo file header vi c php
#include <vector>

C php khai bo vector nh sau

vector<Kiu> V;

22

Lp trnh C++

XIII.2.1.

Nguyn Ph Qung

V d 1

Trong , bn c th khai bo kiu l bt c kiu bin no. hiu r hn v vector, bn hy theo

di v d sau
#include <iostream>
// Th vin iostream phc v ghi d liu ra mn hnh
#include <vector>
// Th vin vector, s dng kiu vector
#include <stdio.h>
// Th vin stdio (s dng hm getchar() dng ct)
using namespace std;
// S dng namespace std
int main() {
vector<int> V;
// V kiu vector s nguyn (s dng ging mng int)
V.resize(3);
// t kch thc ca bin V l 3 (ging mng 3 pt)
V[0] = 5;
// Gn gi tr cho cc phn t ca bin V
V[1] = 6;
// S dng du mc [] hon ton ging vi mng
V[2] = 7;
for (int i=0; i<V.size(); i++) {
// Ghi gi tr cc phn t ca V ra mn hnh
cout << V[i] << endl;
// Nu s dng mng, bn phi c bin lu kch
}
// thc, cn vector c hm cho bin kch thc
getchar();
// Dng chng trnh xem kt qu
}

V d trn cho bn thy vic s dng vector rt n gin, hon ton ging vi mng nhng b nh
c qun l t ng, bn khng phi quan tm n gii phng cc vng b nh xin cp pht.

XIII.2.2.

V d 2

Tuy nhin, vic s dng vector khng ch dng li nhng u im trn, chng ta hy nghin cu
v d tip theo thy c cc u im khc ca vector.
#include <iostream>
#include <vector>
#include <stdio.h>
using namespace std;
int main() {
int i;
vector<int> V;
for (i=0; i<5; i++)
V.push_back(i);

// Lp 5 ln, mi ln a thm 1 s vo vector

// Nh vy, vector c th c s dng nh stack

cout << endl << "Mang truoc khi insert" << endl;
for (i=0; i<V.size(); i++)
// Ghi li ni dung ca mng ra mn hnh
cout << V[i] << endl;
V.insert( V.begin()+3, 100 );

// Chn vo v tr th 3 ca vector gi tr 100

cout << endl << "Mang sau khi insert" << endl;
for (i=0; i<V.size(); i++)
// In ni dung ca vector sau khi chn
cout << V[i] << endl;
// vector s c 6 phn t, phn t 100 chn vo
// V tr th 3 ca vector
V.erase( V.begin()+3 );
// Xa phn t va chn vo i
cout << endl << "Mang sau khi erase" << endl;
for (i=0; i<V.size(); i++)
// In ni dung ca vector sau khi xa
cout << V[i] << endl;
// Vector li ging nh lc mi khi to
getchar();
}

Vi v d trn, bn c th thy nhng u im sau ca vector

-

Bn c th s dng vector nh 1 stack. Thao tc push_back() ca vector cho php bn thm

1 gi tr mi vo vector. Thao tc ny s t ng tng kch thc ca vector, do bn s
khng phi quan tm n qun l kch thc ca vector.

vector cho php bn chn thm 1 phn t vo cc v tr bt k ca vector, cc phn t nm

sau v tr ny s c dch i 1 v tr n ly khong trng cho phn t mi. Thao tc chn
phn t c th thc hin d dng i vi mng thng bng cch s dng vng lp
chuyn dch cc phn t. Tuy nhin, chng trnh hot ng ng trong mi trng hp,
bn phi tnh n nhiu trng hp: dung lng hin ti ca mng c khng? Nu khng
phi xin cp pht thm... Nu s dng vector, cc bn s d dng thc hin chc nng
ny ch bng 1 lnh v lun m bo rng lnh ny s hot ng chnh xc.
23

Lp trnh C++

Nguyn Ph Qung

Tng t vi thao tc xa mt phn t khi vector, bn cng ch cn s dng 1 lnh.

XIII.2.3.

V d 3

Chng ta tip tc theo di v d tip theo tm hiu tip cc kh nng ca vector

#include <iostream>
#include <vector>
#include <stdio.h>
using namespace std;
int main() {
// Mng cc xu k t (d liu test)
char *Chao[] = {"Xin", "chao", "tat", "ca", "cac", "ban"};
int n = sizeof(Chao)/sizeof(*Chao);
// Tnh kch thc ca mng
// Cch tnh ny s dng mt mo:
// Kch thc ca ton b mng chia cho
// Kch thc ca 1 phn t ca mng
vector<char *> V;
// Vector cha cc xu k t
// (cng ging mng, vector c th cha
// mi loi gi tr)
int i;
cout << endl << "vector truoc khi xoa" << endl;
for (i=0; i<n; i++) {
V.push_back(Chao[i]);
// a cc gi tr t mng vo vector
}
cout << endl << "vector sau khi xoa" << endl;
for (i=0; i<V.size(); i++) {
cout << V[i] << endl;
// In ra cc gi tr ca vector
}
V.erase(V.begin()+2, V.begin()+2+3);

for (i=0; i<V.size(); i++) {

cout << V[i] << endl;
}

// Xa vector t thnh phn 2 n

// thnh phn th 3 sau thnh phn 2
// Tc l xa 3 thnh phn k t
// thnh phn 2
// Li in vector sau khi xa ra mn hnh

cout << endl;

// In s lng thnh phn ca vector
cout << "Vector truoc khi clear co " << V.size() << " thanh phan" << endl;
V.clear();
// Xa ton b cc thnh phn
cout << "Vector sau khi clear co " << V.size() << " thanh phan" << endl;
getchar();
// Li in ra s lng thnh phn
}

Kt qu ca on chng trnh trn nh sau:

vector truoc khi xoa
Xin
chao
tat
ca
cac
ban
vector sau khi xoa
Xin
chao
ban
Vector truoc khi clear co 3 thanh phan
Vector sau khi clear co 0 thanh phan

Nh vy, chng ta bit thm mt s chc nng ca vector

-

Vector khng ch lm vic vi s m cn c th lm vic vi tt c cc dng d liu khc

(y l c im ca lp trnh khi qut vi template)

Vector c th xa nhiu thnh phn mt lc

Vector c th xa tt c cc thnh phn bng phng thc clear().

24

Lp trnh C++

XIII.2.4.

Nguyn Ph Qung

V d 4

Cn mt vn c cp n t khi chng ti gii thiu v vector, l kh nng kim tra

trn ch s mng (range check), bit v kh nng ny, chng ta li tip tc vi mt v d mi
#include <iostream>
#include <vector>
#include <stdio.h>
using namespace std;
int main() {
try {
vector<long> V(3, 10);
cout
cout
cout
cout

<<
<<
<<
<<

"V[0]="
"V[1]="
"V[2]="
"V[3]="

<<
<<
<<
<<

V[0]
V[1]
V[2]
V[3]

<<
<<
<<
<<

endl;
endl;
endl;
endl;

cout << "V[4]=" << V[4] << endl;

cout << "V[0]=" << V.at(0)
cout << "V[1]=" << V.at(1)
cout << "V[2]=" << V.at(2)
cout << "V[3]=" << V.at(3)
cout << "V[4]=" << V.at(4)
getchar();
} catch (exception &e) {
cout << "Co loi xay ra" <<
getchar();
}

<<
<<
<<
<<
<<

endl;
endl;
endl;
endl;
endl;

endl;

//
//
//
//
//
//
//
//
//
//

s dng try...catch by li
Khi to vector gm 3 thnh phn
Tt c gn gi tr 10
a thnh phn 0 ra mn hnh
a thnh phn 1 ra mn hnh
a thnh phn 2 ra mn hnh
Thnh phn 3 (lnh ny hot ng khng
ng v V ch c 3 thnh phn 0,1,2
Thnh phn 4 (cng khng ng)
Nhng 2 lnh trn u khng gy li

//
//
//
//

Khng
Thnh
Thnh
Thnh

s dng
phn 1,
phn 2,
phn 3:

[], dng phng thc at

OK
OK
Li, chng trnh dng

// Dng thng bo li (nu chng trnh

// pht sinh li khi chy

Kt qu ca on chng trnh trn nh sau

V[0]=10
V[1]=10
V[2]=10
V[3]=0
V[4]=196692
V[0]=10
V[1]=10
V[2]=10
Co loi xay ra

<-- OK
<-- OK
<-- OK
<-- Sai, ko c gi tr ny
<-- Sai
<-- OK
<-- OK
<-- OK
<-- Thng bo li khi s dng phn t khng hp l

Trong v d ny, chng ta li c thm mt s kinh nghim sau

-

C th s dng c php vector<kiu> tn_vector(s_phn_t, gi_tr_tt_c_phn_t)

khi to mt vector c s lng phn t bit trc v tt c cc phn t u c cng 1 gi tr

Nu s dng c php bin_vector[ch_s], chng trnh s khng to ra li khi s dng ch

s mng nm ngoi vng hp l (ging nh mng thng). Trong v d, chng ta mi ch
ly gi tr phn t vi ch s khng hp l, trng hp ny ch cho kt qu sai. Nhng nu
chng ta gn gi tr cho phn t khng hp l ny, hu qu s nghim trng hn nhiu v
thao tc s lm hng cc gi tr khc trn b nh.

Phng thc at(ch_s) c tc dng tng t nh dng k hiu [], nhng c mt s khc
bit l thao tc ny c kim tra ch s hp l. Minh chng cho nhn xt ny trong v d khi
chng trnh chy n v tr lnh V.at(3), lnh ny khng cho ra kt qu m to thnh thng
bo li.

XIII.2.5.

V d 5

#include <iostream>
#include <vector>
#include <stdio.h>
using namespace std;
int main() {
typedef vector<long> vlong;
vector<vlong> V(3, vlong(3) );
int i, j;
for (i=0; i<3; i++)

25

Lp trnh C++

Nguyn Ph Qung
for (j=0; j<3; j++) V[i][j] = rand() % 10;

for (i=0; i<3; i++)

{
for (j=0; j<3; j++) cout << V[i][j] << " ";
cout << endl;
}
getchar();

V d ny minh ha vic s dng mng 2 chiu, thc cht y l mt vector ca vector. Mng 2
chiu s dng bin php ny c th c kch thc khc nhau gia cc dng (v d mng 2 chiu l
na trn ca ma trn)

XIII.2.6.
#include
#include
#include
#include
#include

S dng vector c kim tra ch s

<iostream>
<fstream>
<vector>
<algorithm>
<stdlib.h>

using namespace std;

template <typename T>
class mvector : public vector<T> {
// Tao lop mvector (giong vector, nhung co kiem tra chi
so)
public:
T t;
T& operator [] (int i) {
try {
return vector<T>::at(i);
} catch (exception &e) {
cout << "Tran chi so " << i << " " << vector<T>::size()-1 << endl;
getchar();
return t;
}
}
};
mvector< int > chiso;
int n;
int main()
{
chiso.resize( 5 );
chiso[5] = 10;
}
/*
5
Duc
Anh
Van
Thu
Ba
*/

XIII.3.

Kiu string

Khi mi hc C, chc cc bn u rt bi ri khi lm vic vi xu k t, vic s dng con tr lu xu

k t rt phc tp, d gy li khin nhiu ngi so snh n vi xu k t trong Pascal.
Do , STL cung cp kiu string (xu k t), gip cc bn trnh khi hon ton cc phin phc nu
trn. string thc cht l mt vector<char> c b sung thm mt s phng thc v thuc tnh, do
, n c ton b cc tnh cht ca 1 vector.
String cng c cc hm size, push_back, ton t [] ging vector.
ni string, bn c th s dng ton t +, += ni cc xu k t.
26

Lp trnh C++

XIII.3.1.

Nguyn Ph Qung

Hm chn xu (insert)

// inserting into a string

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;
int main ()
{
string str="day la .. xau thu";
string istr = "them";
str.insert(8, istr);
cout << str << endl;
getchar();
}

XIII.3.2.

Hm xa xu (erase)

// inserting into a string

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;
int main ()
{
string str="day cung la xau thu";
str.erase(0, 3);
// " cung la xau thu"
cout << str << endl;
str.erase(6, 2);
cout << str << endl;
// " cung xau thu"
getchar();
}

XIII.3.3.

Hm thay th xu k t (replace)

// inserting into a string

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;
int main ()
{
string str="con cho la con cho con. Con meo ko phai la con cho";
str.replace(4, 3, "CHO"); // "con CHO la con cho con. Con meo ko phai la con cho";
cout << str << endl;
getchar();
}

XIII.3.4.

Hm ly xu con (string)

// inserting into a string

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;
int main ()
{
string str="ConCho chay qua rao";
string str2 = string(str.begin()+0, str.begin()+3);
cout << str2 << endl;
str2 = string(str.begin()+7, str.begin()+11);
cout << str2 << endl;
getchar();
}

27

// "Con"
// "chay"

Lp trnh C++

XIII.3.5.

Nguyn Ph Qung

Hm tm kim xui (find)

// inserting into a string

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;
int main ()
{
string str="ConCho chay qua rao";
cout << str.find("chay") << endl;
cout << (int)str.find("Chay") << endl;
getchar();
}

XIII.3.6.

// 7
// -1

Hm tm kim ngc (rfind)

// inserting into a string

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;
int main ()
{
string str="ConCho chay qua chay qua rao";
cout << str.find("chay") << endl;
cout << (int)str.rfind("chay") << endl;
getchar();
}

XIII.3.7.

// 7
// 16

V d 1

lm vic vi string ca STL, chng ta cng xem xt v d sau

#include <iostream>
#include <stdio.h>
#include <string>
using namespace std;
int main() {
string s = "Hello string";
cout << "Noi dung string: " << s << endl;
cout << "Chieu dai cua string: " << s.size()
// Chiu di
cout << "Ky tu 0: " << s[0] << endl;
cout << "Ky tu 1: " << s[1] << endl;
cout << "Ky tu 2: " << s[2] << endl;
s += " co the noi string";
cout << "Noi dung string sau khi noi: " << s
s.erase(s.begin()+5, s.begin()+5+7);
cout << "Noi dung string sau khi xoa: " << s
getchar();
}

// Khai bo bin kiu string

// In ni dung string ra mn hnh
<< endl;
//
//
//
//
<<
//
<<

In k t u tin ca xu
In k t th 2
In k t th 3
Ni xu k t
endl;
Xa 1 on trn xu k t
endl;

Trong v d ny, c th nhn thy nhng im sau

-

Xu k t c cc tnh cht ca mt container: Phng thc size() s dng ly s lng

phn t, du [] dng truy cp n cc element, phng thc erase() s dng xa 1 s
cc phn t lin tip nhau

Xu k t c th cng vi nhau bng cc ton t +, +=

XIII.3.8.

V d 2: Tch xu k t

Trong vic x l xu k t, khng th thiu c cc thao tc tch xu k t thnh nhiu xu k t

con thng qua cc k t ngn cch. Cc hm ny c sn trong cc ngn ng khc nh Visual Basic,
Java... Vi STL, cc bn c th d dng t xy dng mt hm vi chc nng tng t
#include <iostream>
#include <vector>

28

Lp trnh C++

Nguyn Ph Qung

#include <stdio.h>
#include <string>
using namespace std;
int main() {
string S = "Xin
chao tat ca cac
ban";
string::iterator t, t2;
vector<string> split;
for (t=S.begin(); t<S.end();) {
t2=find(t, S.end(), ' ');
// k t v tr t
if (t!=t2) split.push_back(string(t, t2));
t = t2+1;
}
for (int i=0; i<split.size(); i++) {
cout << split[i] << endl;
}
getchar();
return 0;
}

//
//
//
//
//

Khi to gi tr ca xu
Cc bin lp
Mng cc xu (lu kt qu tch)
Lp t v tr bt u
Tm k t space ' ' u tin

// Ly xu k t gia 2 v tr
// Chuyn sang v tr sau
// In mng cc xu k t

Kt qu ca chng trnh nh sau

Xin
chao
tat
ca
cac
ban

on chng trnh s dng cc k thut sau

-

Phng thc find(v_tr_u, v_tr_cui, k_t_tm) dng tm v tr u tin ca

k_t_tm bt u t v_tr_u. Hm ny tr v v tr ca k t tm c (nu tm thy)
hoc v_tr_cui (nu khng tm thy)

string c th khi to t mt on k t con ca mt xu k t khc vi c php

string(v_tr_u, v_tr_cui)

on chng trnh thc hin tch cc xu k t k c trong trng hp c nhiu k t cch

nm lin tip nhau.

XIII.4.

Kiu list (danh sch)

list l kiu danh sch lin kt 2 chiu (hy lin h vi cc kin thc ca mn Cu trc d liu v
Gii thut). Khc bit ca kiu danh sch lin kt vi kiu mng ch:
-

Mng cn nhiu thi gian thm hoc xa phn t (dch chuyn cc phn t pha sau sang
phi hoc sang tri), cn danh sch lin kt thc hin cc thao tc thm, xa vi thi gian
khng ng k (ch cn ct t lin kt c, to ra lin kt mi).

Mng cho php truy xut cc phn t ngay lp tc thng qua ch s (truy cp ngu nhin random access), cn danh sch lin kt phi truy cp cc phn t theo th t tun t.

29

Lp trnh C++

Nguyn Ph Qung

s dng list, bn phi khai bo file header list vi c php sau

#include <list>

Cc phng thc c bn ca list

Phng thc M t
c.size()

S lng phn t ca list

c. empty ()

Tr v 1 nu danh sch l trng, 0 nu ngc li

c.max_size()

Tr v s lng phn t ti a ca list

c1 == c2

Tr v 1 nu hai danh sch ging nhau

c1 != c2

Tr v 1 nu hai danh sch khc nhau (nhanh hn !(c1==c2))

c1 < c2

Tr v 1 nu danh sch c1 < danh sch c2

c.front()

Tr v phn t u tin ca list

c.back()

Tr v phn t cui cng ca list

c.begin()

Tr v phn t lp u tin ca danh sch

c.end()

Tr v phn t lp cui cng ca danh sch

c.sort()

Sp xp danh sch vi ton t <

c1.merge(c2) Trn danh sch c1 vi danh sch c2 (vi iu kin c 2 danh sch u
sp xp vi ton t <). Danh sch c trn cng s c sp xp vi
ton t <. y l thut ton trn 2 ng vi 2 danh sch c sp
xp ( phc tp l tuyn tnh)

XIII.4.1.
#include
#include
#include
#include

V d 1: Duyt list theo 2 chiu

<iostream>
<algorithm>
<stdlib.h>
<list>

using namespace std;

int main() {
int A[] = {3,2,3,1,2,3,5,3};
int n = sizeof(A)/sizeof(*A);
list<int> V;
for (int i=0; i<n; i++) {
V.push_back(A[i]);
}
list<int>::iterator vi;
cout << endl << "Danh sach theo chieu xuoi" << endl;
for (vi=V.begin(); vi!=V.end(); vi++) {
cout << *vi << endl;
}
list<int>::reverse_iterator rvi;
cout << endl << "Danh sach theo chieu nguoc" << endl;
for (rvi=V.rbegin(); rvi!=V.rend(); rvi++) {
cout << *rvi << endl;
}
}

getchar();

30

Lp trnh C++

XIII.4.2.
#include
#include
#include
#include

Nguyn Ph Qung

V d 2: Chn thm phn t, xa phn t

<iostream>
<algorithm>
<stdlib.h>
<list>

using namespace std;

void printint(const int &i) {
cout << i << endl;
}
int main() {
int A[] = {1,2,3,4,5};
int n = sizeof(A) / sizeof(*A);
list<int> V(A, A+n);
list<int>::iterator i;
cout << endl << "Danh sach ban dau" << endl;
for_each( V.begin(), V.end(), printint );
cout << endl << "Danh sach sau khi chen vao cuoi" << endl;
V.push_back(100);
for_each( V.begin(), V.end(), printint );
cout << endl << "Danh sach sau khi chen vao dau" << endl;
V.push_front(200);
for_each( V.begin(), V.end(), printint );
}

getchar();

XIII.4.3.

V d 3: Tch list

XIII.4.4.

V d 4: Sp xp list

#include
#include
#include
#include

<iostream>
<algorithm>
<stdlib.h>
<list>

using namespace std;

int main() {
int A[] = {3,2,3,1,2,3,5,3};
int n = sizeof(A)/sizeof(*A);
list<int> V(A, A+n);
V.sort();
list<int>::iterator vi;
cout << endl << "Danh sach sau khi sap xep" << endl;
for (vi=V.begin(); vi!=V.end(); vi++) {
cout << *vi << endl;
}
getchar();
}

XIII.4.5.
#include
#include
#include
#include

V d 5: Trn list
<iostream>
<algorithm>
<stdlib.h>
<list>

using namespace std;

int main() {
int A[] = {5,1,3,9,7};
int B[] = {8,6,4,2};
int na = sizeof(A)/sizeof(*A);
int nb = sizeof(B)/sizeof(*B);
list<int> Va(A, A+na), Vb(B, B+nb);

31

Lp trnh C++

Nguyn Ph Qung

list<int>::iterator vi;
cout << endl << "Danh sach A sau khi sap xep" << endl;
Va.sort();
for (vi=Va.begin(); vi!=Va.end(); vi++) {
cout << *vi << endl;
}
cout << endl << "Danh sach B sau khi sap xep" << endl;
Vb.sort();
for (vi=Vb.begin(); vi!=Vb.end(); vi++) {
cout << *vi << endl;
}
cout << endl << "Danh sach A sau khi tron voi danh sach B" << endl;
Va.merge(Vb);
for (vi=Va.begin(); vi!=Va.end(); vi++) {
cout << *vi << endl;
}
getchar();
}

XIII.5.

Kiu set (tp hp)

#include <iostream>
#include <set>
#include <stdio.h>
using namespace std;
int main() {
set<int> A;
A.insert(5);
A.insert(7);
A.insert(10);
A.insert(15);
cout << (A.find(3)!=A.end()) << endl;
cout << (A.find(5)!=A.end()) << endl;
cout << (A.find(7)!=A.end()) << endl;
cout << (A.find(10)!=A.end()) << endl;
getchar();
}

XIII.6.
XIII.6.1.

Kiu map (nh x)

Gii thiu

Kiu map cho php bn ly tng ng gia mt gi tr vi mt gi tr khc, hai gi tr ny to thnh

mt cp gi tr. Trong gi tr u ca cp l kha (key), key l duy nht (khng c 2 key cng
xut hin trong 1 map). Do , t key bn c th tm c gi tr tng ng vi key trong cp.

32

Lp trnh C++

Nguyn Ph Qung

Nu thc hin tm kim bnh thng trn mt mng N phn t, bn phi mt trung bnh N/2 php
tm kim. D liu ca cc key c t chc di dng cy heap (l tri nh hn gc, l phi ln
hn gc) nn vic tm kim cc cp theo kha rt nhanh, thi gian trung bnh l log 2N (v su
ca cy l log2N).
Nu bn bit tn dng, map c th ng dng gii rt nhiu dng bi ton khc nhau. Trong phn
ny, chng ti xin gii thiu mt s ng dng ca map
-

S dng lm t in: V d: tra cu thng tin ca sinh vin theo m s

m s lng ca mt thnh phn (cho mt lot cc phn t, tm xem c bao nhiu phn t
v mi phn t xut hin bao nhiu ln)

S dng lu ma trn tha (ma trn tha l ma trn gm rt nhiu phn t bng 0). Trong
cc bi thi Tin hc, nhiu trng hp cc bn gp phi nhng ma trn c kch thc rt ln
(1 triu x 1 triu chng hn) nhng s lng phn t khc 0 ch khong vi trm nghn.
Trng hp ny s dng map lu ma trn l rt thch hp.

XIII.6.2.

Cc phng thc

Phng thc M t
c.size()

S lng phn t ca list

c1 == c2

Tr v 1 nu hai map ging nhau

c1 != c2

Tr v 1 nu hai map khc nhau (nhanh hn !(c1==c2))

c1 < c2

Tr v 1 nu map c1 < map c2

c.begin()

Tr v phn t lp u tin ca danh sch

c.end()

Tr v phn t lp cui cng ca danh sch

c[k]

Tr v gi tr tng ng vi kha k (ch : nu cha c cp no c kha

k, map s t to mt cp mi c kha k v gn gi tr mc nh. i vi
kiu s, gi tr mc nh l 0)

c.find(k)

Tr v iterator tng ng vi kha k, nu khng tm thy th tr v end()

XIII.6.3.

V d: s dng map

#include <iostream>
#include <stdlib.h>
#include <map>
using namespace std;
int main() {
int a[] = {2,4,1,3,5,3,5,3,2,1,2,3,4,4,3,1,2};
int n = sizeof(a)/sizeof(a[0]);
map<int, int> m;
for (int i=0; i<n; i++) {
m[a[i]] ++;
}

map<int, int>::iterator j;
for (j=m.begin(); j!=m.end(); j++)
cout << "Phan tu " << j->first << " xuat hien "
<< j->second << " lan " << endl;
getchar();

33

Lp trnh C++

XIII.6.4.

Nguyn Ph Qung

V d: t in

#include <iostream>
#include <stdio.h>
#include <map>
using namespace std;
class sv {
public:
int maso;
string ten;
string lop;

};

void print() {
cout << "****************************************" << endl
<< "Ma so: " << maso << endl
<< "Ho ten: " << ten << endl
<< "Lop: " << lop << endl;
}

int main () {
sv a[] = {
{1342,
"Mai", "48th"},
{43212, "Lan", "47th"},
{33133, "Cuc", "47th"},
{43321, "Truc", "45th"},
{1234,
"Dao", "42th"}};
int n = sizeof(a)/sizeof(a[0]);
map<int, sv> 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: m

#include <iostream>
#include <stdlib.h>
#include <map>
using namespace std;
int main() {
string a[] = {"chuoi", "na", "oi", "tao", "chuoi", "oi", "na", "tao", "oi"};
int n = sizeof(a)/sizeof(a[0]);
map<string, int> m;
for (int i=0; i<n; i++) {
m[a[i]] ++;
}

map<string, int>::iterator j;
for (j=m.begin(); j!=m.end(); j++)
cout << "Xau ky tu '" << j->first << "' xuat hien "
<< j->second << " lan " << endl;
getchar();

XIII.6.6.
XIII.7.

V d: ma trn tha
Kiu hash_map (nh x dng mng bm)

Kiu map cho php nh x gia tp kha v tp gi tr vi thi gian O(logN). Map s dng cu trc
d liu kiu cy nn phc tp l log2N. Tuy nhin, bn c th s dng cu trc d liu mnh hn
l mng bm (hash_map). Hash_map c th tm kim theo kha vi phc tp O(1).

34

Lp trnh C++

XIII.8.

Nguyn Ph Qung

Kiu hash_set (tp hp)

Trong lp trnh gii cc bi ton Tin hc bng Pascal, nhiu bn qun mt mt kiu d liu rt
mnh l kiu tp hp (kiu d liu ny cho php kim tra xem mt phn t c nm trong tp hp
hay khng, tm phn giao, hp, hiu ca hai tp hp vi nhau). Pascal l mt trong t ngn ng c
kiu d liu nguyn thy l tp hp. C v C++ khng c kiu d liu ny. Tuy nhin, bn c th s
dng kiu d liu tp hp trong STL. Tp hp trong STL cn mnh hn tp hp trong Pascal rt
nhiu v n h tr tt c cc kiu d liu (tp hp trong Pascal ch h tr dng s) vi s lng phn
t khng hn ch (tp hp ca Pascal ch c ti a 256 phn t).

XIII.9.

Thut ton (Algorithm)

Nh gii thiu trong cc phn trc, STL cung cp cc thut ton c bn nhm mc ch gip
bn khng phi code li nhng gii thut qu c bn nh (sp xp, thay th, tm kim...). Cc cng
c ny khng nhng gip bn rt ngn thi gian lp trnh m cn c thi gian g ri khi thut ton
c bn c ci t khng chnh xc. Ngoi ra, vi STL Algorithm, bn c nhiu la chn cho
nhng thut ton c bn. V d, vi thut ton sp xp, bn c th la chn gia thut ton sp xp
nhanh (quicksort) cho kt qu rt nhanh vi phc tp NlogN trong a s cc trng hp, nhng
li c phc tp N*N trong trng hp xu nht v thut ton sp xp vung ng (heapsort) chy
chm hn quicksort nhng c phc tp trong mi trng hp l NlogN.
Ch rng cc thut ton ca STL Algorithm c th p dng cho mi kiu iterator, k c con tr
thng (khng phi l iterator ca STL). Nh vy, cc thut ton sp xp, tm kim, thay th khng
nhng p dng c cho cc kiu vector, list... m cn c th p dng cho mng thng thng.
khai bo s dng STL algorithm, cc bn phi inlucde file header algorithm
#include <algorithm>

Do th vin <algorithm> gm rt nhiu hm khc nhau, ngi ta phn thnh cc nhm hm sau:
-

Nhm cc hm khng thay i gi tr ca container

Nhm cc hm thay i gi tr ca container

Nhm cc hm sp xp

Nhm cc hm trn danh sch c sp xp

Nhm cc hm trn

Nhm cc lm trn heap

Nhm cc hm tm min/max

XIII.9.1.
a.

Nhm cc hm khng thay i gi tr ca container

Cc thut ton tm kim

#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
int main() {
int A[] = {3,4,2,6,3,1,2,3,2,3,4,5,6,4,3,2,1};
int N = sizeof(A) / sizeof(*A);
int first = find(A, A+N, 1) - A;
cout << "So thu tu cua phan tu dau tien = 1: " << first << endl;
getchar();
return 0;
}

#include <iostream>

35

Lp trnh C++

Nguyn Ph Qung

#include <stdio.h>
#include <algorithm>
using namespace std;
int main() {
int A[] = {3,4,2,6,3,1,2,3,2,3,4,5,6,4,3,2,1};
int B[] = {1,2,3};
int NA = sizeof(A) / sizeof(*A);
int NB = sizeof(B) / sizeof(*B);
int vitri = search(A, A+NA, B, B+NB) - A;
cout << "Vi tri dau tien xuat hien B trong A: " << vitri << endl;
getchar();
return 0;
}

#include
#include
#include
#include

<iostream>
<stdio.h>
<algorithm>
<string>

using namespace std;

int main() {
string A = "Xin chao tat ca moi nguoi!!!!!";
string B = "chao";
string C = "Xin";
int vitri = search(A.begin(), A.end(), B.begin(), B.end()) - A.begin();
cout << "Vi tri dau tien xuat hien B trong A: " << vitri << endl;
vitri = search(A.begin(), A.end(), C.begin(), C.end()) - A.begin();
cout << "Vi tri dau tien xuat hien C trong A: " << vitri << endl;
getchar();
return 0;
}

b.

Cc thut ton m

#include
#include
#include
#include

<iostream>
<stdio.h>
<vector>
<algorithm>

using namespace std;

int main() {
int A[] = {3,4,2,6,3,1,2,3,2,3,4,5,6,4,3,2,1};
int N = sizeof(A) / sizeof(*A);
int i;
cout
cout
cout
cout

"So
"So
"So
"So

luong so
luong so
nho nhat
lon nhat

1 trong mang:
3 trong mang:
trong mang: "
trong mang: "

" << count(A, A+N,

" << count(A, A+N,
<< *min_element(A,
<< *max_element(A,

1) << endl;
3) << endl;
A+N) << endl;
A+N) << endl;

getchar();
return 0;

XIII.9.2.
a.

<<
<<
<<
<<

Nhm cc hm thay i gi tr ca container

Gn gi tr 1 vng (fill)

Bn c th s dng lnh fill ca th vin <algorithm> t mt vng gi tr ca 1 container

(thng l 1 mng, 1 vector)
// fill algorithm example
#include <iostream>
#include <algorithm>
#include <vector>
#include <stdlib.h>
using namespace std;
int main () {
vector<int> myvector (8);

// myvector: 0 0 0 0 0 0 0 0

fill (myvector.begin(),myvector.begin()+4,5);

36

// myvector: 5 5 5 5 0 0 0 0

Lp trnh C++

Nguyn Ph Qung

fill (myvector.begin()+3,myvector.end()-2,8);

// myvector: 5 5 5 8 8 8 0 0

cout << "myvector contains:";

int i, n = myvector.size();
for (i=0; i<n; i++)
cout << myvector[i] << " ";
cout << endl;
getchar();
return 0;
}

b.

Thay th cc gi tr (replace)

Lnh replace tm kim 1 gi tr trong container, thay th gi tr tm c bi gi tr mi.

// replace algorithm example
#include <iostream>
#include <algorithm>
#include <vector>
#include <stdlib.h>
using namespace std;
int main () {
int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };
vector<int> a (myints, myints+8);
// 10 20 30 30 20 10 10 20
replace(a.begin(), a.end(), 20, 99);
// 10 99 30 30 99 10 10 99
cout << "a contains: ";
int i, n;
for (i=0, n=a.size(); i<n; i++)
cout << a[i] << " ";
}

c.

getchar();

Thay th cc gi tr theo iu kin (replace_if)

Lnh replace_if cho php tm gi tr theo iu kin do mt hm tr v. s dng lnh ny bn

phi khai bo 1 hm c gi tr tr v l bool nhn tham s l gi tr ca 1 element. Khi hm tr v
true, gi tr tng ng s b thay th bi gi tr mi. Hm kim tra nn khai bo inline tc
nhanh hn.
// replace_if example
#include <iostream>
#include <algorithm>
#include <vector>
#include <stdlib.h>
using namespace std;
inline bool SoLe(int i) { return ((i%2)==1); }
int main () {
vector<int> a;
// set some values:
for (int i=1; i<10; i++) a.push_back(i);
replace_if(a.begin(), a.end(), SoLe, 0);

d.

// 1 2 3 4 5 6 7 8 9
// 0 2 0 4 0 6 0 8 0

cout << "a contains: ";

int i, n;
for (i=0, n=a.size(); i<n; i++)
cout << a[i] << " ";
getchar();

o ngc containter (reverse)

Bn c th s dng lnh reverse o ngc 1 vector hoc 1 list.

// reverse algorithm example
#include <iostream>
#include <algorithm>
#include <vector>

37

Lp trnh C++

Nguyn Ph Qung

#include <stdlib.h>
using namespace std;
int main () {
vector<int> a;
// set some values:
for (int i=1; i<10; ++i) a.push_back(i); // 1 2 3 4 5 6 7 8 9
reverse(a.begin(),a.end());
// 9 8 7 6 5 4 3 2 1
// print out content:
cout << "a contains:";
int i, n = a.size();
for (i=0; i<n; i++)
cout << a[i] << " ";

cout << endl;

getchar();

XIII.9.3.

Nhm cc hm sp xp

a.

Cc thut ton sp xp
#include
#include
#include
#include

<iostream>
<stdio.h>
<vector>
<algorithm>

using namespace std;

int main() {
vector<int> V;
int i;
for (i=0; i<10; i++) V.push_back(rand()%10);
sort(V.begin(), V.end());
for (i=0; i<V.size(); i++) {
cout << V[i] << endl;
}
getchar();
return 0;
}

#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
int main() {
int A[] = {3,4,2,6,3,1,2,3,2,1};
int N = sizeof(A) / sizeof(*A);
int i;
cout << "Sap xep danh sach theo chieu tang dan" << endl;
sort(A, A+N);
for (i=0; i<N; i++)
cout << A[i] << endl;
cout << "Sap xep danh sach theo chieu giam dan" << endl;
sort(A, A+N, greater<int>() );
for (i=0; i<N; i++)
cout << A[i] << endl;
getchar();
return 0;
}

#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;

38

Lp trnh C++

Nguyn Ph Qung

class sv {
public:
double diem;
char *ten;
bool operator < (const sv &b) const {
return diem < b.diem;
}
};
int main () {
sv a[] = {{6,"Mai"},{7,"Lan"},{5,"Cuc"},{4,"Truc"},{3,"Dao"}};
int n = sizeof(a)/sizeof(*a);
sort(a, a+n);
for (int i=0; i<n; i++) {
cout << a[i].diem << " " << a[i].ten << endl;
}
getchar();
return 0;
}

XIII.9.4.

Nhm cc hm trn danh sch c sp xp

Mt s thut ton nh tm kim, thm vo danh sch... hot ng nhanh hn ( phc tp l log 2n
thay v n). Th vin <algorithm> h tr mt s hm lm vic ring vi cc danh sch sp xp
theo th t tng dn.
a.

Tm cn di v cn trn (lower_bound, upper_bound)

Hm lower_bound(first, last, value) tr v iterator ca element cui cng trong danh sch sp
xp c gi tr khng vt qu [value].
Hm upper_bound(first, last, value) tr v iterator ca element u tin c gi tr ln hn
[value].
// lower_bound/upper_bound example
#include <iostream>
#include <algorithm>
#include <vector>
#include <stdlib.h>
using namespace std;
int main () {
int myints[] = {10,20,30,30,20,10,10,20};
int size = sizeof(myints)/sizeof(myints[0]);
vector<int> v(myints,myints+size);
// 10 20 30 30 20 10 10 20
vector<int>::iterator low,up;
sort (v.begin(), v.end());
// 10 10 10 20 20 20 30 30
low=lower_bound (v.begin(), v.end(), 20); //
^
up= upper_bound (v.begin(), v.end(), 20); //
^
cout << "lower_bound tro vao vi tri: " << int(low- v.begin()) << endl;
cout << "upper_bound tro vao vi tri: " << int(up - v.begin()) << endl;
}

b.

getchar();

Tm kim (binary_search)

Hm binary_search(first, last, value) tr v true nu tm thy gi tr value trong danh sch sp

xp t first n last.
// binary_search example
#include <iostream>
#include <algorithm>
#include <vector>
#include <stdlib.h>
using namespace std;
inline bool LonHon (int i,int j) { return (i>j); }
int main () {
int myints[] = {1,2,3,4,5,4,3,2,1};

39

Lp trnh C++

Nguyn Ph Qung

vector<int> v(myints,myints+9);

// 1 2 3 4 5 4 3 2 1

// Su dung phep so sanh nho hon de tim kiem

sort (v.begin(), v.end());
cout << "Tim phan tu 3... ";
if (binary_search (v.begin(), v.end(), 3))
cout << "Tim thay!\n"; else cout << "Khong tim thay!\n";
// Su dung phep so sanh lon hon de sap xep va tim kiem
sort (v.begin(), v.end(), LonHon);
cout << "Tim phan tu 6... ";
if (binary_search (v.begin(), v.end(), 6, LonHon))
cout << "Tim thay!\n"; else cout << "Khong tim thay!\n";
getchar();
}

c.

Trn 2 danh sch c sp xp (merge)

Bn c th s dng hm merge trn 2 danh sch c sp xp thnh 1 danh sch khc.

// merge algorithm example
#include <iostream>
#include <algorithm>
#include <vector>
#include <stdlib.h>
using namespace std;
int main () {
int first[] = {5,10,15,20,25};
int second[] = {50,40,30,20,10};
vector<int> v(10);
vector<int>::iterator it;
sort (first,first+5);
sort (second,second+5);
merge (first,first+5,second,second+5,v.begin());
cout << "The resulting vector contains:";
for (it=v.begin(); it!=v.end(); ++it)
cout << " " << *it;
getchar();
}

d.

Trn 2 danh sch c sp xp (merge_inplace)

// inplace_merge example
#include <iostream>
#include <algorithm>
#include <vector>
#include <stdlib.h>
using namespace std;
int main () {
int first[] = {5,10,15,20,25};
int second[] = {50,40,30,20,10};
vector<int> v(10);
vector<int>::iterator it;
sort (first,first+5);
sort (second,second+5);
copy (first,first+5,v.begin());
copy (second,second+5,v.begin()+5);
inplace_merge (v.begin(),v.begin()+5,v.end());
cout << "The resulting vector contains:";
for (it=v.begin(); it!=v.end(); ++it)
cout << " " << *it;
}

getchar();

40

Lp trnh C++

e.

Nguyn Ph Qung

Hp 2 danh sch c sp xp (set_union)

// set_union example
#include <iostream>
#include <algorithm>
#include <vector>
#include <stdlib.h>
using namespace std;
int main () {
int first[] = {5,10,15,20,25};
int second[] = {50,40,30,20,10};
vector<int> v(10);
vector<int>::iterator it;
sort (first,first+5);
sort (second,second+5);

// 0

// 5 10 10 20 25
// 10 20 30 40 50

it=set_union (first, first+5, second, second+5, v.begin());

// 5 10 15 20 25 30 40 50 0 0
cout << "union has " << int(it - v.begin()) << " elements.\n";
getchar();
}

f.

Giao 2 danh sch c sp xp (set_difference)

// set_difference example
#include <iostream>
#include <algorithm>
#include <vector>
#include <stdlib.h>
using namespace std;
int main () {
int first[] = {5,10,15,20,25};
int second[] = {50,40,30,20,10};
vector<int> v(10);
vector<int>::iterator it;
sort (first,first+5);
sort (second,second+5);

// 0

// 5 10 15 20 25
// 10 20 30 40 50

it=set_difference (first, first+5, second, second+5, v.begin());

// 5 15 25 0 0 0 0 0 0 0
cout << "difference has " << int(it - v.begin()) << " elements.\n";
getchar();
}

XIII.9.5.
a.

Cc hm trn heap
To heap (make_heap)

// range heap example

#include <iostream>
#include <algorithm>
#include <vector>
#include <stdlib.h>
using namespace std;
int main () {
int myints[] = {10,20,30,5,15};
vector<int> v(myints,myints+5);
vector<int>::iterator it;
make_heap (v.begin(),v.end());
cout << "initial max heap
: " << v.front() << endl;
pop_heap (v.begin(),v.end()); v.pop_back();
cout << "max heap after pop : " << v.front() << endl;
v.push_back(99); push_heap (v.begin(),v.end());
cout << "max heap after push: " << v.front() << endl;
sort_heap (v.begin(),v.end());

41

Lp trnh C++

Nguyn Ph Qung

cout << "final sorted range :";

for (unsigned i=0; i<v.size(); i++) cout << " " << v[i];
getchar();
}

b.

Thm phn t vo heap (push_heap)

// range heap example

#include <iostream>
#include <algorithm>
#include <vector>
#include <stdlib.h>
using namespace std;
int main () {
int myints[] = {10,20,30,5,15};
vector<int> v(myints,myints+5);
vector<int>::iterator it;
make_heap (v.begin(),v.end());
cout << "initial max heap
: " << v.front() << endl;
pop_heap (v.begin(),v.end()); v.pop_back();
cout << "max heap after pop : " << v.front() << endl;
v.push_back(99); push_heap (v.begin(),v.end());
cout << "max heap after push: " << v.front() << endl;
sort_heap (v.begin(),v.end());
cout << "final sorted range :";
for (unsigned i=0; i<v.size(); i++) cout << " " << v[i];
getchar();
}

Kt qu
initial max heap
:
max heap after pop :
max heap after push:
final sorted range :

c.

30
20
99
5 10 15 20 99

Xa phn t khi heap (pop_heap)

// range heap example
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main () {
int myints[] = {10,20,30,5,15};
vector<int> v(myints,myints+5);
vector<int>::iterator it;
make_heap (v.begin(),v.end());
cout << "initial max heap
: " << v.front() << endl;
pop_heap (v.begin(),v.end()); v.pop_back();
cout << "max heap after pop : " << v.front() << endl;
v.push_back(99); push_heap (v.begin(),v.end());
cout << "max heap after push: " << v.front() << endl;
sort_heap (v.begin(),v.end());
cout << "final sorted range :";
for (unsigned i=0; i<v.size(); i++) cout << " " << v[i];
cout << endl;
}

return 0;

42

Lp trnh C++

Nguyn Ph Qung

Kt qu
initial max heap
:
max heap after pop :
max heap after push:
final sorted range :

d.

30
20
99
5 10 15 20 99

Sp xp heap (sort_heap)

// range heap example

#include <iostream>
#include <algorithm>
#include <vector>
#include <stdlib.h>
using namespace std;
int main () {
int myints[] = {10,20,30,5,15};
vector<int> v(myints,myints+5);
vector<int>::iterator it;
make_heap (v.begin(),v.end());
cout << "initial max heap
: " << v.front() << endl;
pop_heap (v.begin(),v.end()); v.pop_back();
cout << "max heap after pop : " << v.front() << endl;
v.push_back(99); push_heap (v.begin(),v.end());
cout << "max heap after push: " << v.front() << endl;
sort_heap (v.begin(),v.end());
cout << "final sorted range :";
for (unsigned i=0; i<v.size(); i++) cout << " " << v[i];
getchar();
}

Kt qu
initial max heap
:
max heap after pop :
max heap after push:
final sorted range :

XIV.

30
20
99
5 10 15 20 99

GII MT S BI TON BNG STL

XIV.1.
XIV.1.1.

Qun l sinh vin

bi

Tn file: SVIEN.*
D liu vo: t file B1.INP, gm:
-

Dng 1: S sinh vin ca trng (n n<=10000)

3*n dng tip theo: Thng tin ca 1 sinh vin c ghi trn 3 dng, bao gm: H tn (ti a
20 k t), lp (ti a 6 k t), qu qun (ti a 10 k t)

Yu cu: Tm v lit k:
-

S lng lp trong trng v danh sch cc lp

Vi mi lp:
o S lng v danh sch cc a phng l qu qun ca sinh vin trong lp

D liu ra: ti file B1.OUT vi khun dng nh sau:

-

Dng 1: S lp ca trng (k)

Cc dng tip theo l thng tin ca tng lp (mi mc c lit k di y c trnh by
trn 1 dng):
43

Lp trnh C++

o
o
o
o
o
o

Nguyn Ph Qung

Ten lop
s sinh vin ca lp, s lng a phng (m)
s lng sinh vin qu a phng 1, tn a phng 1
s lng sinh vin qu a phng 2, tn a phng 2
...
s lng sinh vin qu a phng m, tn a phng m

B1.INP

B1.OUT

Nguyen Van A

46pm1

46pm1

2 1

Hung Yen

2 Hung Yen

Tran Van B

47th1

47th1

3 2

Hai Duong

2 Hai Duong

Nguyen Thi C

1 Binh Dinh

46pm1
Hung Yen
Vu Van D
47th1
Binh Dinh
Cao Thi E
47th1
Hai Duong

XIV.1.2.
#include
#include
#include
#include

Bi gii
<iostream>
<fstream>
<string>
<map>

using namespace std;

#define INPUT "b1.inp"
#define OUTPUT "b1.out"
int main() {
ifstream fi;
int n, i;
map<string, int> lop;
// map gia tn lp v s sinh vin
map<string, map<string, int> > que;
// map gia tn lp v bin m s
// sinh vin ca tng qu
// bin m ny cng l nh x gia qu
// v s sinh vin qu
fi.open(INPUT);
fi >> n;
char sLop[100], sQue[100];
fi.getline(sLop, 100);
for (int i=0; i<n; i++) {
fi.getline(sLop, 100);
fi.getline(sLop, 100);
lop[sLop]++;
fi.getline(sQue, 100);
que[sLop][sQue]++;

// M file input
// S lng sinh vin
// c xung dng (sau n)
// c tn (ko s dng)
// c tn lp
// Thm s sinh vin ca lp
// c qu
// Thm s sinh vin thuc qu ca lp

44

Lp trnh C++

Nguyn Ph Qung

}
fi.close();

// ng file input

ofstream fo;
fo.open(OUTPUT);
// M file output
map<string, int>::iterator j;
fo << lop.size() << endl;
// Ghi s lng lp
for (j=lop.begin(); j!=lop.end(); j++) {// Lp qua tng lp
fo << j->first << endl;
// Ghi tn lp (thnh phn u ca pair)
map<string, int> &quei = que[j->first];
// Gn bin tham chiu n bin m qu
// Ca lp tng ng
fo << j->second << " " << quei.size() << endl;
// Ghi s lng sinh vin ca lp v
// s lng qu qun ca sv trong lp
map<string, int>::iterator t;
for (t=quei.begin(); t!=quei.end(); t++) {
// Vi mi vng qu, ghi s lng sv
// qu v tn qu
fo << t->second << " " << t->first << endl;
}
}
fo.close();
// ng file output
}
/********************* Test1 ***************************
5
Nguyen Van A
46pm1
Hung Yen
Tran Van B
47th1
Hai Duong
Nguyen Thi C
46pm1
Hung Yen
Vu Van D
47th1
Binh Dinh
Cao Thi E
47th1
Hai Duong
********************************************************/

XIV.2.
XIV.2.1.

Ro t
bi

Tn file: RAO.*
-

Mt mnh t hnh ch nht (kch thc ti a 32000x32000) c ro bng cc tng ro

song song vi cc cnh ca hnh ch nht
Mt khong t c gi l c bo v nu n c gii hn bi cc tng ro
Hy tm khong t c din tch ln nht c bo v

D liu vo: t file RAO.INP

-

Dng u: 2 s nguyn w h l chiu rng v chiu cao ca mnh t

Dng th 2: s dng lng tng ro (n<=100)
n dng tip theo: mi dng gm 4 s nguyn (cch nhau bi du cch) l ta 2 im
u v cui ca ro. D liu vo m bo l ro song song vi cnh ca hnh ch nht

D liu ra: ti file B2.OUT, gm:

- Dng 1: Din tch ca vng c bo v c din tch ln nht, nu khng c th in ra gi tr -1

45

Lp trnh C++

XIV.2.2.
XIV.3.

Nguyn Ph Qung

Bi gii
Robot

XIV.3.1.

bi

Bi 3 (Robot). Tn file: ROBOT.*

Mt con robot di chuyn trn mt li vung bng cch nhn mt trong cc lnh sau:
R: Quay phi 45
L: Quay tri 45
G n: Tin v pha trc 1 khong n (n < 1000)
U: Nhc chi ln
D: H chi xung
(ch rng khi h chi xung l c t mu)
Trng thi ban u ca robot l nhc chi, ta ban u l im (0, 0)
Input: Nhp d liu t file input.txt gm cc thng tin sau
Mi dng l 1 trong 5 lnh k trn (ti a 1000 lnh)
Output: Kt qu ghi ra file output.txt
Dng u tin l 1 s nguyn ch ra s lng c t mu

XIV.3.2.
#include
#include
#include
#include

Bi gii
<iostream>
<fstream>
<string>
<map>

using namespace std;

#define INPUT "robot.inp"
#define OUTPUT "robot.out"
class diem {
// Lp im, lu ta ca im
public:
int x, y;
// To ca im
diem() {}
// Hm khi to im (khng tham s)
diem(int _x, int _y) { // Hm khi to dim theo ta
x = _x; y = _y;
}
// Hm so snh im vi im khc
// Hm ny s dng sp xp cc kha trong map
bool operator < (const diem& b) const {
return (x<b.x) || (x==b.x && y<b.y);
}
};
map<diem, int> A;
// nh x gia im v mt s nguyn (nu s nguyn
// khc 0 tc l im i qua)
int main() {
ifstream fi;
fi.open(INPUT);
string s;
int huong = 0;
// Hng khi u
int dx[] = {1,0,-1,0}; // Vector di chuyn tng ng theo hng
int dy[] = {0,-1,0,1};
int n, i, x=0, y=0;
// Ta u tin
bool choi = false;
// Trng thi ca chi
while (!fi.eof()) {
s = "";
fi >> s;

// c n khi ht file
// c xu k t

46

Lp trnh C++

Nguyn Ph Qung
switch (s[0]) {
// Kim tra k t u
case 'R':
// R: Quay phi
huong = (huong+1)%4;
break;
case 'L':
// L: Quay tri
huong = (huong+3)%4;
break;
case 'G':
// Tin theo hng hin ti
fi >> n;
// c thm gi tr n
for (i=0; i<n-1; i++) {
x += dx[huong];
// dch chuyn tng bc
y += dy[huong];
// m cc nu trng thi chi l h xung
if (choi) A[diem(x, y)] ++;
}
break;
case 'U':
// Nhc chi
choi = false;
break;
case 'D':
// H chi
choi = true;
A[diem(x, y)] ++;
// m lun va h
break;
}

}
fi.close();
ofstream fo;
fo.open(OUTPUT);
fo << A.size();
fo.close();

/****** Test 1 *********

U
D
U
D
***********************/
/****** Test 2 *********
U
D
U
D
G 100
L
L
G 100

XIV.4.

Dijsktra

XIV.4.1.

bi

XIV.4.2.

Bi gii

XIV.5.
XIV.5.1.

Hp din tch hnh ch nht

bi

Cho n hnh ch nht c cnh song song vi cc trc Ox, Oy. Tm tng din tch khng gian b che
bi cc hnh ch nht ny (Din tch phn hp ca cc hnh ch nht);

XIV.5.2.

Bi gii

- Ri rc ha cc thng tin bng cch:

47

Lp trnh C++

Nguyn Ph Qung

. Ko di cc cnh ng
. Ko di cc cnh ngang
. Cc cnh ny chia khng gian thnh mt li hnh ch nht.
- Mi hnh ch nht s che mt s trong li ny
- m tng din tch ca cc b che, bn tnh c din tch ca phn che ph ca tt c
cc hnh ch nht.
/*
Cho 1 danh sach cac hinh chu nhat co canh song song voi man hinh
Tim hinh chu nhat co dien tich la hop cua cac hinh chu nhat nay
*/
#include
#include
#include
#include
#include

<iostream>
<fstream>
<vector>
<map>
<algorithm>

#define input "dientich.inp"

#define output "dientich.out"
using namespace std;
typedef vector<int> dong;
struct chunhat
{
double xmin, ymin, xmax, ymax;
};
int n;
vector<dong> a;
vector<chunhat> cn;
vector<double> tx, ty;
inline void swap(double &a, double &b)
{
double t = a; a = b; b = t;
}

// Thng tin ca 1 hnh ch nht

// xmin, xmax, ymin, ymax

// Bng nh du cc b che
// Danh sch cc hnh ch nht
// Ta cc li dc v ngang
// Hm i ch 2 s thc
// Hm khai bo inline chy nhanh hn

int main()
{
fstream f(input);
f >> n; f.get();

// S hnh ch nht

cn.resize(n);
for (int i=0; i<n; i++)
// c thng tin tng hnh ch nht
{
chunhat &a = cn[i];
// i ch nu cc ta khng hp l
f >> a.xmin >> a.ymin >> a.xmax >> a.ymax; f.get();
if (a.xmin>a.xmax) swap(a.xmin, a.xmax);
if (a.ymin>a.ymax) swap(a.ymin, a.ymax);
tx.push_back(a.xmin);
tx.push_back(a.xmax);
ty.push_back(a.ymin);
ty.push_back(a.ymax);

// To mng tx: ta cc li ng
// To mng ty: ta cc li ngang

}
f.close();
sort(tx.begin(), tx.end());
sort(ty.begin(), ty.end());

// Sp xp cc ta li dng v ngang

map<double, int> mx, my;

for (int i=0; i<2*n; i++)
{
mx[tx[i]] = i;
my[ty[i]] = i;
}

// Bng nh x gia ta (s thc)

// v s th t
// ca ta trn li (s nguyn)

a.resize(2*n);
// To mng (2n)*(2n), ton s 0
for (int i=0; i<2*n; i++) a[i].resize(2*n, 0);

48

Lp trnh C++

Nguyn Ph Qung

double dt = 0;
for (int i=0; i<n; i++)
{
chunhat b = cn[i];
int xmin = mx[b.xmin];
int ymin = my[b.ymin];
int xmax = mx[b.xmax];
int ymax = my[b.ymax];

// Tnh tng din tch

//
//
//
//

xmin, xmax: ch s cnh tri, phi

trn li
ymin, ymax: ch s cc cnh trn, di
trn li

for (int x=xmin; x<xmax; x++) // Duyt qua tt c cc thuc hcnht

for (int y=ymin; y<ymax; y++) {
if (a[x][y]==0)
// Nu cha c nh du
{
a[x][y] = 1;
// nh du , v tnh thm din tch
dt += (tx[x+1]-tx[x])*(ty[y+1]-ty[y]);
}
}
}
ofstream fo;
fo.open(output);
fo << dt;
fo.close();

// Tng din tch ca cc hnh ch nht

}
/*
2
0 0 1 1
0 0 2 2
*/

XV.

INPUT V OUTPUT

49