Giáo trình Lập trình nâng cao
TRƯꢀNG ðꢁI HꢂC NÔNG NGHIꢃP I - HÀ NꢄI
Bꢄ MÔN CÔNG NGHꢃ PHꢅN MꢆM
TS. DƯƠNG XUÂN THÀNH
Giáo trình
LꢇP TRÌNH NÂNG CAO
( Trên ngôn ngꢀ Pascal )
(Soꢁn theo chương trình ñã ñưꢂc Bꢃ GD&ðT phê chuꢄn)
Hà nꢃi, 2005
Lꢈi mꢉ ñꢊu
Cuꢀn giáo trình này ñưꢁc biên soꢂn theo ñúng ñꢃ cương chi tiꢄt môn hꢅc ñã ñưꢁc Bꢆ
Giáo dꢇc và ðào tꢂo phê chuꢈn. Thꢉi gian hꢅc môn hꢅc này là 60 tiꢄt trong ñó có 10 tiꢄt thꢊc
hành trên máy. Tác giꢋ là ngưꢉi ñã trꢊc tiꢄp giꢋng dꢂy lꢌp trình Pascal trong nhiꢃu năm cho
sinh viên chuyên tin và sinh viên các ngành khác.
ðꢀi tưꢁng sꢍ dꢇng giáo trình là sinh viên chuyên ngành Tin hꢅc hꢎ ñꢂi hꢅc chính quy,
tuy nhiên giáo trình cũng có thꢏ sꢍ dꢇng như là mꢆt tài liꢎu tham khꢋo cho sinh viên chuyên
Tin hꢎ cao ñꢐng và nhꢑng ngưꢉi muꢀn nghiên cꢒu nâng cao vꢃ lꢌp trình.
Mꢇc ñích biên soꢂn cuꢀn giáo trình là cung cꢓp cho ngưꢉi ñꢅc mꢆt tài liꢎu ñơn giꢋn,
cô ñꢅng nhꢑng kiꢄn thꢒc vꢃ lꢌp trình nâng cao. Ngưꢉi ñꢅc có thꢏ tꢊ hꢅc mà không nhꢓt thiꢄt
phꢋi có thày hưꢔng dꢕn.
Giáo trình bao gꢖm 6 chương và 4 phꢇ lꢇc.
Chương 1: Chương trình con - Thꢋ tꢌc và hàm, sinh viên ñã ñưꢁc hꢅc qua trong
chương trình Tin hꢅc ñꢂi cương, do vꢌy ꢗ ñây chꢘ yꢄu ñi sâu vào khái niꢎm tham sꢀ, cách
thꢒc mà hꢎ thꢀng dành bꢆ nhꢔ cho viꢎc lưu trꢑ các tham sꢀ và viꢎc gꢅi chương trình con tꢙ
chương trình con khác.
Chương 2: Các kiꢍu dꢎ liꢏu có cꢐu trúc, tꢌp trung vào các kiꢏu dꢑ liꢎu mà sinh viên
chưa ñưꢁc hꢅc như bꢋn ghi có cꢓu trúc thay ñꢚi, tꢌp hꢁp..
Chương 3: ðơn vꢑ chương trình và thư viꢏn chuꢒn, là chương chưa ñưꢁc hꢅc ꢗ Tin
hꢅc ñꢂi cương , ꢗ ñây hưꢔng dꢕn cách thiꢄt kꢄ các ðơn vꢛ chương trình (Unit), cách thꢒc sꢍ
dꢇng các Unit và tꢂo lꢌp thư viꢎn chương trình .
Chương 4: Con trꢓ và cꢐu trúc ñꢔng, là mꢆt chương khó, vì nó vꢙa liên quan ñꢄn
quꢋn lý bꢆ nhꢔ, vꢙa liên quan ñꢄn kiꢄn thꢒc cꢘa môn hꢅc Cꢓu trúc dꢑ liꢎu và Giꢋi thuꢌt do
vꢌy trong chương này ñã trình bày nhiꢃu ví dꢇ ñꢏ ngưꢉi ñꢅc tham khꢋo.
Chương 5: Giꢕi thuꢖt ñꢏ quy, ñưꢁc trình bày “hơi dài dòng” do ñꢜc thù cꢘa tính ñꢎ
quy. Bài toán Tháp Hanoi ñưꢁc mô tꢋ khác hoàn toàn so vꢔi tꢓt cꢋ các sách vꢃ Pascal ñã có.
Chương 6: ðꢗ hoꢘ, ngoài viꢎc giꢔi thiꢎu các thꢘ tꢇc vꢝ thông thưꢉng, còn dành mꢆt
phꢞn trꢅng tâm cho viꢎc xꢍ lý ꢋnh Bitmap. Trong chương này có sꢍ dꢇng mꢆt vài ví dꢇ cꢘa
các tác giꢋ khác (xem phꢞn tài liꢎu tham khꢋo) nhưng ñã ñưꢁc cꢋi tiꢄn ñi rꢓt nhiꢃu.
Phꢇ lꢇc 1: Bꢋng mã ASCII
Phꢇ lꢇc 2: Tóm tꢟt các thꢘ tꢇc và hàm cꢘa Turbo Pascal 7.0
Phꢇ lꢇc 3: ðꢛnh hưꢔng biên dꢛch
Phꢇ lꢇc 4: Thông báo lꢠi
Các phꢇ lꢇc ñưa ra nhꢡm giúp ngưꢉi lꢌp trình tiꢎn tra cꢒu các thꢘ tꢇc, hàm và xꢍ lý
các lꢠi khi Pascal thông báo lꢠi trên màn hình
Do phꢋi bám sát ñꢃ cương và sꢊ hꢂn chꢄ vꢃ sꢀ trang tác giꢋ nên trong giáo trình chưa
ñưa vào ñưꢁc phꢞn xꢍ lý âm thanh, lꢌp trình hưꢔng ñꢀi tưꢁng....
Viꢎc biên soꢂn lꢞn ñꢞu không thꢏ tránh ñưꢁc thiꢄu sót, tác giꢋ mong nhꢌn ñưꢁc sꢊ góp
ý cꢘa bꢂn ñꢅc và ñꢖng nghiꢎp ñꢏ lꢞn xuꢓt bꢋn sau sꢝ tꢀt hơn. Mꢅi góp ý xin gꢍi vꢃ ñꢛa chꢢ:
Bꢆ môn Công nghꢎ Phꢞn mꢃm, Khoa Công nghꢎ Thông tin,
ðꢂi hꢅc Nông nghiꢎp I , Trâu quỳ, Gia lâm, Hà nꢆi.
Xin trân trꢅng cꢋm ơn.
Hà nꢃi, tháng 5 năm 2005
Ts. Dương Xuân Thành
Chương I
Chương trình con - Thꢋ tꢌc và hàm
Khái niꢎm chương trình con ñã ñưꢁc trình bày trong môn hꢅc Tin hꢅc ñꢂi cương, do vꢌy
trong chương này chúng ta nhꢟc lꢂi sơ qua mꢆt sꢀ khái niꢎm cũ và dành thꢉi gian cho viꢎc tìm
hiꢏu sâu vꢃ tham sꢀ (tham biꢄn và tham trꢛ), lꢉi gꢅi chương trình con, cách thꢒc bꢀ trí
chương trình con trong thân chương trình mꢣ. Sau khi hꢅc chương này bꢂn ñꢅc cꢞn nꢟm ñưꢁc
các nꢆi dung chꢘ yꢄu sau:
ꢀ Thꢄ nào là biꢄn toàn cꢇc, biꢄn ñꢛa phương
ꢀ Các biꢄn toàn cꢇc và biꢄn ñꢛa phương ñưꢁc bꢀ trí ꢗ ñâu
ꢀ Tꢞm tác dꢇng cꢘa tꢙng loꢂi biꢄn
ꢀ Thꢒ tꢊ xây dꢊng các chương trình con có ꢋnh hưꢗng thꢄ nào ñꢄn toàn bꢆ chương
trình
ꢀ Thꢄ nào là tính ñꢎ quy cꢘa chương trình con
ꢀ Lꢉi gꢅi chương trình con thꢄ nào là ñưꢁc phép
ꢀ Cách khai báo trưꢔc ñꢏ gꢅi chương trình con không theo thꢒ tꢊ thiꢄt kꢄ
1. Khái niꢏm vꢙ chương trình con
Chương trình con trong Pascal ñưꢁc hiꢏu là mꢆt chương trình nꢡm trong lòng mꢆt
chương trình khác. Chương trình con gꢖm hai loꢂi: Thꢋ tꢌc (Procedure) và hàm
(Function). Các chương trình con ñưꢁc dùng rꢆng rãi khi xây dꢊng các chương trình lꢔn
nhꢡm làm cho chương trình dꢤ theo dõi, dꢤ sꢍa chꢑa. Mꢆt ñꢜc ñiꢏm nꢚi bꢌt cꢘa chương trình
con là nó có tính ñꢎ quy nhꢉ thꢄ mà nhiꢃu bài toán sꢝ ñưꢁc giꢋi quyꢄt dꢤ dàng.
Khi mꢆt chương trình con ñưꢁc gꢅi thì các biꢄn ñưꢁc khai báo trong chương trình con
(ta gꢅi là biꢄn cꢇc bꢆ) sꢝ ñưꢁc cꢓp phát bꢆ nhꢔ. Kꢄt thúc chương trình con, các biꢄn cꢇc bꢆ
ñưꢁc giꢋi phóng, ñiꢃu này sꢝ ñưꢁc lꢜp lꢂi mꢠi khi chương trình con ñưꢁc gꢅi và nó ñꢖng
nghĩa vꢔi viꢎc thꢉi gian xꢍ lý bài toán sꢝ tăng lên.
Bꢋn thân tên gꢅi cꢘa hai loꢂi chương trình con ñã nói lên phꢞn nào sꢊ khác nhau giꢑa
chúng. Function (Hàm) là mꢆt loꢂi chương trình con cho kꢄt quꢋ là mꢆt giá trꢛ vô hưꢔng. Khi
gꢅi tên Function vꢔi các tham sꢀ hꢁp lꢎ ta sꢝ nhꢌn ñưꢁc các giá trꢛ, bꢗi vꢌy tên hàm có thꢏ
ñưa vào các biꢏu thꢒc tính toán như là các toán hꢂng. Procedure là loꢂi chương trình con khi
thꢊc hiꢎn không cho ra kꢄt quꢋ là mꢆt giá trꢛ, mꢠi Procedure nhꢡm thꢊc hiꢎn mꢆt nhóm công
viꢎc nào ñó cꢘa chương trình mꢣ, vì vꢌy tên cꢘa Procedure không thꢏ ñưa vào các biꢏu thꢒc
tính toán. Bꢡng cách xây dꢊng các chương trình con ngưꢉi lꢌp trình có thꢏ phân mꢋnh chương
trình cho nhiꢃu ngưꢉi cùng làm dưꢔi sꢊ chꢢ ñꢂo thꢀng nhꢓt cꢘa ngưꢉi chꢘ trì. Trong Turbo
Pascal ñã có sꢥn mꢆt sꢀ chương trình con, ví dꢇ: sin(x), sqrt(x).... là các Function, còn read(),
write(), gotoxy (x1,x2)..... là các Procedure.
Trong mꢆt chương trình các chương trình con ñưꢁc bꢀ trí ngay sau phꢞn khai báo
biꢄn. Cꢓu trúc tꢚng quát mꢆt chương trình Pascal như sau:
PROGRAM tên_chương_trình;
USES tên các UNIT; (*khai báo các ñơn vꢛ chương trình cꢞn thiꢄt*)
LABEL
CONST
TYPE
(*khai báo nhãn*).
(*Khai báo hꢡng*)
(*ñꢛnh nghĩa kiꢏu dꢑ liꢎu mꢔi*)
(*khai báo biꢄn*)
VAR
PROCEDURE Tên_CTC1 (danh sách tham sꢀ hình thꢒc);
Begin
............
End;
(*thân thꢘ tꢇc thꢒ nhꢓt*).
PROCEDURE Tên_CTC2 (danh sách tham sꢀ hình thꢒc);
Begin
...................
End;
(*thân thꢘ tꢇc thꢒ hai*)
FUNCTION Tên_HAM1(danh sách tham sꢀ hình thꢒc):kiꢏu hàm;
Begin
...............
End;
(*thân hàm thꢒ nhꢓt*)
...........
BEGIN
..........
END.
(*bꢟt ñꢞu chương trình mꢣ*)
Ghi chú:
1. Các chương trình con vꢅ nguyên tꢆc cũng bao gꢇm các phꢈn khai báo báo như ñꢉi
vꢊi mꢋt chương trình mꢌ, phꢈn nào không cꢈn thiꢍt thì không khai. ðiꢅu khác nhau cơ bꢎn là
thân chương trình con nꢏm giꢐa hai tꢑ khoá Begin và End; (sau End là dꢒu ";" chꢓ không
phꢎi là dꢒu "." như trong chương trình mꢌ) ngoài ra chương trình con còn có thꢔ thêm phꢈn
khai báo các tham sꢉ hình thꢓc, các tham sꢉ hình thꢓc ñưꢕc ñꢖt trong dꢒu () và viꢍt ngay sau
tên chương trình con.
2. Nꢍu chương trình con là Function thì cuꢉi chương trình cꢈn có lꢃnh gán giá trꢗ vào
tên chương trình con.
2. Tham sꢚ trong chương trình con
Các chương trình con có thꢏ không cꢞn tham sꢀ mà chꢢ có các biꢄn riêng (biꢄn cꢇc
bꢆ). Trong trưꢉng hꢁp cꢞn nhꢌn các giá trꢛ mà chương trình mꢣ truyꢃn cho thì chương trình
con cꢞn phꢋi có các tham sꢀ (Parameter). Tham sꢀ ñưꢁc khai báo ngay sau tên chương trình
con và ñưꢁc gꢅi là tham sꢅ hình thꢆc.
Nhꢑng giá trꢛ lưu trꢑ trong các biꢄn toàn cꢇc cꢘa chương trình mꢣ, nꢄu ñưꢁc truyꢃn
cho các thꢘ tꢇc hoꢜc hàm thông qua lꢉi gꢅi tên chúng thì ñưꢁc gꢅi là Tham sꢅ thꢇc.
Tham sꢀ hình thꢒc bao gꢖm hai loꢂi:
2.1 Tham biꢛn (Variabic parameter)
Tham biꢄn là nhꢑng giá trꢛ mà chương trình con nhꢌn tꢙ chương trình mꢣ, các giá trꢛ
này có thꢏ biꢄn ñꢚi trong chương trình con và khi chương trình con kꢄt thúc các giá trꢛ này sꢝ
ñưꢁc trꢋ vꢃ cho tham sꢀ thꢊc.
Cách khai báo tham biꢄn:
Tên chương trình con (Var tên tham biꢛn : kiꢍu dꢎ liꢏu);
2.2 Tham trꢑ (Value parameter)
Nhꢑng tham sꢀ truyꢃn vào cho chương trình con xꢍ lý nhưng khi quay vꢃ chương
trình mꢣ vꢕn phꢋi giꢑ nguyên giá trꢛ ban ñꢞu thì ñưꢁc gꢅi là tham trꢑ.
Cách khai báo tham trꢛ:
Tên chương trình con (tên tham trꢑ : kiꢍu dꢎ liꢏu);
Dưꢔi ñây là mꢆt ví dꢇ khai báo tham sꢀ:
PROCEDURE VIDU(x,y,z: integer; lam:boolean; var qq: char);
Câu lꢎnh khai báo chương trình con trên ñây ñꢖng thꢉi khai báo các tham sꢀ hình thꢒc
trong ñó x, y,z, lam là các tham trꢛ, vꢔi x, y,z có kiꢏu integer, lam có kiꢏu boolean, qq là tham
biꢄn vì nó ñưꢁc viꢄt sau tꢙ khoá VAR.
Ví dꢌ 1.1: Lꢌp chương trình tìm sꢀ lꢔn nhꢓt trong n sꢀ nguyên ñưꢁc nhꢌp tꢙ bàn
phím.
Program Tim_cuc_dai;
Uses Crt;
TYPE dayso = array[1..100] of integer;
(* ðꢛnh nghĩa kiꢏu dꢑ liꢎu dayso là kiꢏu mꢋng
gꢖm nhiꢃu nhꢓt là 100 phꢞn tꢍ*).
VAR
a: dayso
(*khai báo biꢄn cꢘa chương trình mꢣ*)
n: integer;
PROCEDURE nhapso(m:integer; var x:dayso);
(* Nhꢌp dãy sꢀ cꢞn tìm cꢊc ñꢂi vào mꢋng mꢆt chiꢃu x[i]*)
Var i : integer;
(*khai báo biꢄn cꢇc bꢆ cꢘa chương trình con*)
Begin
writeln('Nhap day so kieu integer);
For i:=1 to m Do
Begin
(* m ñưꢁc truyꢃn tꢙ chương trình mꢣ qua tham sꢀ thꢊc n*)
write('a[', i , '] = '); realln (x[i]);
End; End;
FUNCTION Max(m: integer; b:dayso); integer;
(* Hàm MAX dùng ñꢏ tìm sꢀ lꢔn nhꢓt trong dãy sꢀ ñã nhꢌp, kiꢏu giá trꢛ cꢘa hàm là kiꢏu integer *)
VAR
i,t: integer;
Begin
(* Biꢄn riêng cꢘa hàm Max *)
t:=b[1];
(* Gán phꢞn thꢒ nhꢓt cꢘa mꢋng b[i] cho biꢄn t *)
For i:=2 to m Do
if t<b [i] then t:=b[i];
Max:=t;
(* Gán giá trꢛ cho chính hàm Max*)
End;
BEGIN
Write('Ban can nhap bao nhieu so ? '); Readln(n);
NHAPSO(N, A);
(* Thân chương trình mꢣ *)
(* Gꢅi chương trình con NHAPSO vꢔi 2 tham sꢀ thꢊc là n và a. Hai tham
sꢀ này sꢝ thay thꢄ cho hai tham sꢀ hình thꢒc m, x trong chương trình con *)
Writeln (' So lon nhat trong day so da nhap = ', MAX(n,a):5);
(* Viꢄt ra giá trꢛ cꢘa hàm MAX vꢔi 2 tham sꢀ thꢊc n,a ñꢆ dài sꢀ là 5 ký tꢊ *)
Repeat until keypressed;
END.
Ví dꢇ1.1 là mꢆt chương trình bao gꢖm hai chương trình con, chương trình con thꢒ
nhꢓt là mꢆt thꢘ tꢇc (Procedure), chương trình con thꢒ hai là mꢆt hàm (Function).
Chương trình mꢣ có lꢎnh ñꢅc sꢀ phꢞn tꢍ n cꢘa mꢋng dayso (tꢒc là sꢀ lưꢁng con sꢀ sꢝ
nhꢌp vào). Vì mꢋng Dayso ñưꢁc khai báo có 100 phꢞn tꢍ nên không thꢏ ñꢅc vào nhiꢃu quá
100 con sꢀ.
Sau ñó là lꢎnh gꢅi chương trình con NHAPSO vꢔi 2 tham sꢀ thꢊc là n, a, ꢗ ñây a là
tham biꢄn nghĩa là giá trꢛ cꢘa mꢋng a sꢝ ñưꢁc thay ñꢚi trong chương trình con bꢗi tham sꢀ
hình thꢒc x[i]. Chương trình con nhꢌp vào tham biꢄn x[i] kiꢏu mꢋng n con sꢀ thông qua tham
trꢛ m (m=n).
Lꢎnh viꢄt giá trꢛ lꢔn nhꢓt cꢘa dãy sꢀ có kèm lꢉi gꢅi hàm MAX vì hàm MAX thꢊc chꢓt
trong trưꢉng hꢁp này chꢢ là mꢆt con sꢀ.
Hàm MAX dùng ñꢏ tìm sꢀ lꢔn nhꢓt trong các sꢀ ñã nhꢌp, lꢉi gꢅi hàm trong chương
trình mꢣ kèm theo viꢎc truyꢃn hai tham sꢀ thꢊc là n và a thay thꢄ cho hai tham sꢀ hình thꢒc là
m và b. Tên hàm ñưꢁc dùng như là mꢆt biꢄn trong bꢋn thân hàm khi ta dùng phép gán giá trꢛ
MAX:=t;
Chú ý:
1. Kiꢔu dꢐ liꢃu trong khai báo tham sꢉ hình thꢓc chꢘ có thꢔ là: sꢅ nguyên, sꢅ thꢇc, ký
tꢇ, hoꢈc Boolean. Nꢍu muꢉn ñưa các kiꢔu dꢐ liꢃu có cꢒu trúc vào trong khai báo tham sꢉ thì
phꢎi ñꢗnh nghĩa trưꢊc kiꢔu dꢐ liꢃu này ꢙ phꢈn khai báo kiꢔu sau tꢑ khoá Type (xem ví dꢚ 1.1).
2. Vꢊi kiꢔu dꢐ liꢃu chuꢛi, nꢍu chúng ta khai báo tham sꢉ thꢜc trong chương trình mꢌ
và tham biꢍn trong chương trình con ñꢅu là STRING (không quy ñꢗnh ñꢋ dài tꢉi ña cꢝa chuꢛi)
thì không cꢈn phꢎi ñꢗnh nghĩa trưꢊc kiꢔu dꢐ liꢃu ꢙ phꢈn TYPE. ðꢔ thꢒy rõ vꢒn ñꢅ chúng ta
xét ví dꢚ sau ñây:
Ví dꢉ: 1.2
Program Chuong_trinh_me;
Var s:string; m:byte
Procedure Chuong_trinh_con( Var a:string; n:byte);
Cách khai báo trên là ñưꢁc phép trong Pascal .
Nꢄu chúng ta quy ñꢛnh ñꢆ dài chuꢠi như mꢆt trong ba dꢂng sau thì sꢝ bꢛ báo lꢠi:
Dꢘng thꢜ nhꢐt
Program Chuong_trinh_me;
Var s:string[30]; m:byte
Procedure Chuong_trinh_con( Var a:string[30]; n:byte);
Dꢘng thꢜ hai
Program Chuong_trinh_me;
Var s:string[30]; m:byte
Procedure Chuong_trinh_con( Var a:string; n:byte);
Dꢘng thꢜ ba
Program Chuong_trinh_me;
Var s:string; m:byte
Procedure Chuong_trinh_con( Var a:string[30]; n:byte);
Tuy nhiên có mꢆt ngoꢂi lꢎ khi tham sꢀ hình thꢒc trong các chương trình con không
phꢋi là tham biꢄn mà là tham trꢛ thì có thꢏ khai báo theo dꢂng thꢒ hai.
Muꢀn quy ñꢛnh ñꢆ dài chuꢠi trong các khai báo tham biꢄn thì phꢋi khai báo kiꢏu dꢑ
liꢎu theo mꢕu sau:
Program Chuong_trinh_me;
Type S1 = string[30];
Var s:s1; m:byte
Procedure Chuong_trinh_con( Var a:s1; n:byte);
3. Truyꢙn tham sꢚ cho chương trình con
Trꢗ lꢂi ví dꢇ 1.1 ta thꢓy trong mꢠi chương trình con có nhꢑng tham sꢀ riêng cꢘa mình.
Chương trình con nhꢌp sꢀ ñã sꢍ dꢇng hai tham sꢀ hình thꢒc là m và x. Hai tham sꢀ này ñưꢁc
chuꢈn bꢛ ñꢏ nhꢌn các giá trꢛ mà chương trình mꢣ truyꢃn cho thông qua lꢉi gꢅi chương trình
con vꢔi các tham sꢀ thꢊc là n và b. Vì m ñưꢁc khai báo kiꢏu không có tꢙ khoá Var nên nó là
tham trꢛ, nghĩa là khi chương trình con kꢄt thúc thì giá trꢛ cꢘa tham sꢀ thꢊc n vꢕn không thay
ñꢚi, tham sꢀ x là tham biꢄn vì nó ñưꢁc khai báo sau tꢙ khoá Var.
Khi tham sꢀ hình thꢒc trong chương trình con là tham biꢄn thì tham sꢀ thꢊc trong
chương trình mꢣ phꢋi là biꢄn chꢒ không thꢏ là hꢡng. Trong mꢅi trưꢉng hꢁp cꢋ hai tham sꢀ
thꢊc và tham sꢀ hình thꢒc ñꢃu phꢋi cùng kiꢏu dꢑ liꢎu.
Các tham sꢀ thꢊc truyꢃn cho tham biꢄn thì giá trꢛ cꢘa nó có thꢏ thay ñꢚi trong chương
trình con, khi ra khꢦi chương trình con nó vꢕn giꢑ nguyên các giá trꢛ ñã thay ñꢚi ñó. Trong ví
dꢇ 1.1 tham sꢀ thꢊc a là mꢆt mꢋng cꢘa n phꢞn tꢍ và tꢓt cꢋ các phꢞn tꢍ ñꢃu còn rꢠng, khi
truyꢃn a vào tham biꢄn x thì ꢗ thꢉi ñiꢏm ban ñꢞu các phꢞn tꢍ cꢘa x cũng rꢠng. Phép gán trong
chương trình con NHAPSO sꢝ làm thay ñꢚi giá trꢛ các phꢞn tꢍ cꢘa x, sau khꢦi ra chương trình
con nó giꢑ nguyên các giá trꢛ ñã gán tꢒc là các giá trꢛ ta nhꢌp tꢙ bàn phím vào các phꢞn tꢍ cꢘa
mꢋng.
Khi tham sꢀ hình thꢒc là tham trꢛ thì tham sꢀ thꢊc phꢋi là mꢆt giá trꢛ. Chương trình
con nhꢌn giá trꢛ này như là giá trꢛ ban ñꢞu và có thꢏ thꢊc hiꢎn các phép tính làm biꢄn ñꢚi giá
trꢛ ñó, quá trình này chꢢ tác ñꢆng trong nꢆi bꢆ chương trình con, khi ra khꢦi chương trình con
giá trꢛ cꢘa tham sꢀ thꢊc không biꢄn ñꢚi. Cꢇ thꢏ trong ví dꢇ trên biꢄn n nhꢌn giá trꢛ ñꢅc tꢙ bàn
phím trong chương trình mꢣ và ñưꢁc truyꢃn cho tham sꢀ m trong cꢋ hai chương trình con. Sau
lꢉi gꢅi chương trình con NHAPSO giá trꢛ này có thꢏ bꢛ thay ñꢚi nhưng khi rꢉi NHAPSO ñꢄn
lꢉi gꢅi hàm MAX thì n lꢂi vꢕn giꢑ giá trꢛ ban ñꢞu.
Như vꢌy nꢄu muꢀn bꢋo vꢎ giá trꢛ mꢆt tham sꢀ nào ñó khi truyꢃn chúng cho chương
trình con thì phꢋi qui ñꢛnh chúng là tham trꢛ. Còn nꢄu muꢀn nhꢌn lꢂi giá trꢛ mà chương trình
con ñã sinh ra thay thꢄ cho nhꢑng giá trꢛ ban ñꢞu có trong chương trình mꢣ (hoꢜc là dùng
nhꢑng giá trꢛ cꢘa chương trình con thay thꢄ cho biꢄn chưa ñưꢁc gán giá trꢛ trong chương trình
mꢣ như vi dꢇ 1.1) thì tham sꢀ phꢋi là tham biꢄn.
ðꢏ thꢓy rõ hơn ý nghĩa cꢘa các tham sꢀ chúng ta xét ví dꢇ sau ñây:
Ngưꢉi mꢣ trao cho con trai mꢆt chiꢄc nhꢕn và mꢆt túi tiꢃn. Trưꢔc khi con ñi làm ăn ꢗ
phương xa mꢣ dꢜn: "Chiꢄc nhꢕn là tín vꢌt dùng ñꢏ nhꢌn lꢂi gia ñình và hꢅ hàng khi con trꢗ vꢃ,
còn túi tiꢃn là vꢀn ban ñꢞu cho con kinh doanh".
Trong qúa trình làm ăn, ngưꢉi con có thꢏ cꢞm cꢀ chiꢄc nhꢕn nhưng khi trꢗ vꢃ nhà nhꢓt
thiꢄt phꢋi mang chiꢄc nhꢕn ñó vꢃ, còn túi tiꢃn khi quay vꢃ có thꢏ nhiꢃu lên cũng có thꢏ ít ñi,
thꢌm chí không còn ñꢖng nào. Trong ví dꢇ này chiꢄc nhꢕn ñóng vai trò tham trꢛ, còn túi tiꢃn
ñóng vai trò tham biꢄn.
Vꢓn ñꢃ ñꢜt ra là Pascal làm thꢄ nào ñꢏ ñꢋm bꢋo các tính chꢓt cꢘa tham trꢛ và tham
biꢄn. ðiꢃu này sꢝ ñưꢁc làm rõ khi nghiên cꢒu viꢎc bꢀ trí bꢆ nhꢔ (mꢇc 5).
Khi lꢝa chꢞn tham sꢚ cꢊn lưu ý mꢔt sꢚ ñiꢍm sau:
a. Kiꢏu cꢘa tham sꢀ trong chương trình con phꢋi là các kiꢊu vô hưꢋng ñơn giꢌn ñã
ñưꢁc ñꢛnh nghĩa sꢥn trong Pasacl hoꢜc ñã ñưꢁc ñꢛnh nghĩa trong phꢞn ñꢞu cꢘa chương trình
mꢣ. Trong chương trình con không thꢏ ñꢛnh nghĩa kiꢏu dꢑ liꢎu mꢔi.
b. Chương trình con có thꢊc sꢊ cꢞn tham sꢀ hay không? Nꢄu chương trình con chꢢ sꢍ
dꢇng các biꢄn toàn cꢇc và biꢄn ñꢛa phương cũng ñáp ꢒng ñưꢁc yêu cꢞu cꢘa bài toán thì không
nên dùng tham sꢀ. Nꢄu chương trình con thꢊc hiꢎn nhiꢃu công viꢎc trên cùng mꢆt loꢂi ñꢀi
tưꢁng (ñꢀi tưꢁng ꢗ ñây có thꢏ là hꢡng, biꢄn, hàm, thꢘ tꢇc, kiꢏu), nghĩa là lꢉi gꢅi chương trình
con ñưꢁc lꢜp lꢂi nhiꢃu lꢞn trên cùng mꢆt hoꢜc mꢆt nhóm ñꢀi tưꢁng thì cꢞn dùng ñꢄn tham sꢀ.
c. Nꢄu không muꢀn thay ñꢚi giá trꢛ cꢘa các tham sꢀ thꢊc trong chương trình mꢣ khi
truyꢃn nó cho chương trình con thì phꢋi dùng tham sꢀ hình thꢒc dưꢔi dꢂng tham trꢛ (trong
phꢞn khai báo kiꢏu không có tꢙ khoá Var). Nꢄu cꢞn thay ñꢚi giá trꢛ cꢘa tham sꢀ thꢊc trong
chương trình mꢣ và nhꢌn lꢂi giá trꢛ mà chương trình con ñã xꢍ lý thì tham sꢀ trong chương
trình con phꢋi là tham biꢄn (tên tham sꢀ phꢋi ñꢜt sau tꢙ khoá Var).
4. Biꢛn toàn cꢌc và biꢛn ñꢑa phương
4.1 Biꢛn toàn cꢌc
Biꢄn khai báo ꢗ ñꢞu chương trình mꢣ ñưꢁc gꢅi là biꢄn toàn cꢇc. Nó có tác dꢇng trong
toàn bꢆ chương trình, kꢏ cꢋ các chương trình con. Khi thꢊc hiꢎn chương trình máy dành các ô
nhꢔ ꢗ vùng dꢑ liꢎu (Data) ñꢏ lưu giꢑ giá trꢛ cꢘa biꢄn.
Mꢗ rꢆng ra tꢓt cꢋ các ñꢚi tưꢟng trong Pascal (Kiꢏu dꢑ liꢎu, Hꢡng, Biꢄn, Hàm, Thꢘ
tꢇc) khai báo trong chương trình mꢣ ñưꢁc gꢅi là ñꢀi tưꢁng toàn cꢇc. Như vꢌy mꢆt kiꢏu dꢑ liꢎu
ñã ñưꢁc ñꢛnh nghĩa trong chương trình mꢣ thì ñương nhiên ñưꢁc phép sꢍ dꢇng trong các
chương trình con cꢘa nó.
Trong ví dꢇ 1.1 biꢄn a và n là biꢄn toàn cꢇc, hai biꢄn này có thꢏ sꢍ dꢇng trꢊc tiꢄp
trong thꢘ tꢇc NHAPSO và trong hàm MAX mà không cꢞn khai báo lꢂi.
Pascal dành các ô nhꢔ ꢗ vùng Data (vùng dꢑ liꢎu) cho các ñꢀi tưꢁng toàn cꢇc.
4.2 Biꢛn ñꢑa phương
Nhꢑng ñꢀi tưꢁng khai báo trong chương trình con chꢢ có tác dꢇng trong nꢆi bꢆ
chương trình con ñó, chúng ñưꢁc gꢅi là ñꢀi tưꢁng ñꢛa phương. ðꢀi tưꢁng hay ñưꢁc sꢍ dꢇng
nhꢓt là Biꢄn.
Biꢄn ñꢛa phương có thꢏ trùng tên vꢔi biꢄn toàn cꢇc song hꢎ thꢀng dành các ô nhꢔ
trong vùng nhꢔ ngăn xꢄp (Stack) ñꢏ lưu giꢑ các giá trꢛ cꢘa biꢄn. Kꢄt thúc chương trình con hꢎ
thꢀng sꢝ giꢋi phóng ô nhꢔ cꢘa biꢄn ñꢛa phương dùng vào viꢎc khác, giá trꢛ cꢘa các biꢄn lưu
trꢑ trong các ô nhꢔ này sꢝ không còn.
Trưꢉng hꢁp trong chương trình con lꢂi có các chương trình con khác thì biꢄn ñꢛa
phương cꢘa chương trình con cꢓp trên lꢂi ñưꢁc xem là biꢄn toàn cꢇc ñꢀi vꢔi chương trình con
cꢓp dưꢔi.
Mꢆt biꢄn sau khi ñưꢁc khai báo trong mꢆt chương trình sꢝ chꢢ có tꢞm tác dꢇng trong
bꢋn thân chương trình ñó và các chương trình con cꢘa nó. Biꢄn này không có tác dꢇng trong
các chương trình cùng cꢓp khác hoꢜc trong các chương trình con cꢘa chương trình khác. ðiꢃu
này có nghĩa là các chương trình con và chương trình mꢣ có thꢏ có nhiꢃu biꢄn trùng tên,
nhưng tꢞm tác dꢇng thì khác nhau do ñó tính toàn vꢣn cꢘa dꢑ liꢎu luôn ñưꢁc bꢋo ñꢋm.
Ví dꢌ 1.3
Program Chuong_trinh_con;
Uses crt;
Var i,n:byte; c1:string[30];
Procedure Bien_dia_phuong;
Var i,n:byte; c1:string[30];
Begin
n:=3;
C1:='Thu do Ha noi';
Writeln('Gia tri n trong chuong trinh con: ',n);
Writeln('Chuoi C1 trong chuong trinh con: ',C1);
end;
Begin
Clrscr;
(* thân chương trình mꢣ *)
Bien_dia_phuong;
Writeln;
n:=0;
for i:= 1 to 10 do n:= n+i;
c1:='Happy Birth Day';
Writeln('Gia tri n trong chuong trinh me: ',n);
Writeln('Chuoi C1 trong chuong trinh me: ',C1);
Readln;
End.
Ví dꢇ 1.3 thiꢄt kꢄ mꢆt chương trình mꢣ và mꢆt chương trình con dưꢔi dꢂng thꢘ tꢇc.
Phꢞn khai báo biꢄn trong cꢋ hai là như nhau. Phép gán dꢑ liꢎu vào biꢄn n và chuꢠi C1 là khác
nhau.
Sau lꢉi gꢅi chương trình con Bien_dia_phuong màn hình xuꢓt hiꢎn:
Gia tri n trong chuong trinh con: 3
Chuoi C1 trong chuong trinh con: Thu do Ha noi
Tiꢄp ñó là kꢄt quꢋ các lꢎnh viꢄt trong chương trình mꢣ:
Gia tri n trong chuong trinh me: 55
Chuoi C1 trong chuong trinh me: Happy Birth Day
Lꢉi gꢅi chương trình con ñưꢁc thꢊc hiꢎn trưꢔc, kꢄt quꢋ là biꢄn n mang giá trꢛ 3, còn
chuꢠi C1 là ' Thu do Ha noi '. Khi trꢗ vꢃ chương trình mꢣ biꢄn n =55 còn chuꢠi C1 = ' Happy
Birth Day' . ðiꢃu này có nghĩa là biꢄn n và C1 trong chương trình con không ꢋnh hưꢗng ñꢄn
biꢄn n và C1 trong chương trình mꢣ.
5. Cách thꢜc bꢚ trí bꢔ nhꢠ
Khi mꢆt chương trình Pascal dꢂng EXE ñưꢁc chꢂy máy sꢝ cꢓp phát mꢆt vùng nhꢔ cơ
sꢗ 640 Kb. Vùng nhꢔ này sꢝ bao gꢖm các ô nhꢔ nꢡm liꢃn nhau nghĩa là ñꢛa chꢢ các ô nhꢔ tăng
liên tꢇc.
Phân loꢘi vùng nhꢠ
Tên vùng
Heap
Dung lưꢟng
0 - 655360 Bytes
16 - 64 Kb
Cao
Stack Segment
Data Segment
Code Segment
Program Segment Prefix
64 Kb
Mꢠi ñoꢂn có 64 Kb
256 Bytes
Thꢓp
Hình 1.1
Chương trình ñưꢁc bꢀ trí trong bꢆ nhꢔ như sau:
* Program Segment Prefix: ghi ñꢛa chꢢ các hàm, biꢄn, thꢘ tꢇc
* Code Segment: lưu mã chương trình chính và mã các Unit liên quan ñꢄn chương
trình, vùng này có thꢏ gꢖm nhiꢃu ñoꢂn, mꢠi ñoꢂn 64 Kb.
* Data Segment: lưu trꢑ các biꢄn, hꢡng, kiꢏu cꢘa chương trình chính, vùng này chꢢ có
64 Kb nên nꢄu chương trình chính có quá nhiꢃu hꢡng, biꢄn thì có thꢏ gꢜp lꢠi: Too many
variables
* Stack Segment: Lưu mã chương trình con và biꢄn ñꢛa phương
* Heap: vùng nhꢔ tꢊ do dùng cho viꢎc cꢓp phát ñꢆng
Các tham trꢛ và biꢄn cꢇc bꢆ khai báo trong chương trình con ñưꢁc bꢀ trí vào các ô
nhꢔ cꢘa Stack. Khi chương trình mꢣ gꢅi và truyꢃn tham sꢀ cho chương trình con thì giá trꢛ
cꢘa các tham sꢀ này sꢝ ñưꢁc sao chép vào các ô nhꢔ ñã bꢀ trí ꢗ stack. Mꢅi biꢄn ñꢚi diꢤn ra
trong stack không ꢋnh hưꢗng ñꢄn các giá trꢛ cꢘa tham sꢀ thꢊc trong chương trình mꢣ.
Vꢔi các tham biꢄn, Pascal không bꢀ trí ô nhꢔ riêng mà sꢍ dꢇng con trꢦ trꢦ vào ñꢛa chꢢ
cꢘa ô nhꢔ chꢒa biꢄn toàn cꢇc. Khi chương trình con làm thay ñꢚi giá trꢛ cꢘa các tham biꢄn thì
cũng có nghĩa là nó làm thay ñꢚi giá trꢛ cꢘa các biꢄn toàn cꢇc trong chương trình mꢣ. Kꢄt thúc
chương trình con chꢢ các biꢄn ñꢛa phương là bꢛ giꢋi phóng còn biꢄn toàn cꢇc không bꢛ giꢋi
phóng cho nên chúng ta nói chương trình con ñã mang các giá trꢛ mꢔi vꢃ cho chương trình
mꢣ.
Cꢞn chú ý rꢡng Pascal 7.0 chꢢ dành 16 Kb cho vùng Stack, dung lưꢁng này ñáp ꢒng
ñꢞy ñꢘ các ꢒng dꢇng thông thưꢉng. Vꢔi nhꢑng ꢒng dꢇng sꢍ dꢇng tính ñꢎ quy mà sꢀ lꢞn gꢅi ñꢎ
quy là quá lꢔn thì sꢝ có thꢏ bꢛ lꢠi: Stack Overflow (bꢆ nhꢔ ngăn xꢄp bꢛ tràn).
Gꢜp trưꢉng hꢁp này cꢞn phꢋi mꢗ rꢆng vùng nhꢔ Stack bꢡng cách sau:
Trên thanh thꢊc ñơn chꢅn Options/Memory Size sꢝ xuꢓt hiꢎn cꢍa sꢚ (hình 1.2)
Memory Sizes
Stack size
Low heap limit
High heap limit
16384
0
655360
OK
Cancel
Help
F1 Help - Size of your program's stack segment (between 1024 and 65520)
Hình 1.2
Stack size 16384: dung lưꢁng hiꢎn thꢉi cꢘa Stack
Size of your program's stack segment (between 1024 and 65520)
Có thꢏ thay ñꢚi dung lưꢁng Stack trong khoꢋng 1024 - 65520 Bytes
Muꢀn thay ñꢚi dung lưꢁng cꢘa Stack chúng ta chꢢ viꢎc gõ dung lưꢁng mꢔi thay vào
vꢛ trí 16384 hiꢎn thꢉi.
Các tham sꢀ:
Low heap limit
0
High heap limit
655360 Là vùng nhꢔ tꢊ do dành cho cꢓp phát ñꢆng, không nên
nhꢞm chúng vꢔi giá trꢛ tꢀi thiꢏu và tꢀi ña cꢘa Stack.
6. Tính ñꢏ qui cꢋa chương trình con
Thông thưꢉng lꢉi gꢅi mꢆt chương trình con chꢢ ñưꢁc thꢊc hiꢎn khi chương trình con
ñó ñã ñưꢁc thiꢄt kꢄ hoàn chꢢnh. Tuy nhiên Pascal cho phép mꢆt chương trình con ngay trong
quá trình xây dꢊng lꢂi có thꢏ gꢅi tꢔi chính nó, không nhꢑng thꢄ tꢙ mꢆt chương trình con còn
có thꢏ gꢅi tꢔi các chương trình con khác cùng cꢓp hoꢜc chương trình con cꢓp cao hơn nó.
Mꢆt chương trình con có thꢏ có lꢉi gꢅi tꢔi chính tên chương trình con ñó, tính chꢓt này
ñưꢁc gꢅi là tính "ðꢎ qui cꢘa chương trình con". ðꢎ quy có thꢏ sꢍ dꢇng trong cꢋ Procedure và
Function. Giꢀng như mꢋng trong Pascal tương ñương vꢔi ma trꢌn trong toán, ñꢎ quy trong
Pascal tương ñương vꢔi tính Quy nꢂp trong toán hꢅc. Vꢃ ñiꢃu này chúng ta sꢝ ñꢃ cꢌp ñꢄn
trong chương V “Giꢋi thuꢌt ðꢎ quy”.
7. Lꢈi gꢞi chương trình con
Mꢆt chương trình mꢣ có thꢏ có nhiꢃu chương trình con trꢊc thuꢆc, bên trong mꢠi
chương trình con lꢂi có thꢏ có các chương trình con riêng. Nói cách khác trong Pascal tꢖn tꢂi
mꢆt lꢔp chương trình con ngang cꢓp nhau, mꢠi chương trình con này lꢂi có thꢏ ñóng vai trò
chương trình mꢣ cꢘa mꢆt lꢔp chương trình con khác.
Khi thiꢄt kꢄ, mꢠi chương trình con phꢋi là mꢆt khꢀi riêng biꢎt không thꢏ lꢖng nhau
hoꢜc có các lꢎnh nhꢋy Goto tꢙ chương trình con này tꢔi chương trình con khác.
7.1 Gꢞi chương trình con tꢡ trong chương trình mꢢ
Lꢉi gꢅi chương trình con có thꢏ ñꢜt bꢓt kỳ chꢠ nào trong chương trình mꢣ. Nꢄu
chương trình con là mꢆt thꢘ tꢇc thì lꢉi gꢅi chương trình con (tꢒc là tên chương trình con) có
thꢏ tꢂo nên mꢆt câu lꢎnh, ví dꢇ:
Readln; Gotoxy(5,8);
Nꢄu chương trình con là hàm thì tên hàm không thꢏ tꢂo nên mꢆt câu lꢎnh, nói khác ñi
tên hàm phꢋi nꢡm trong mꢆt biꢏu thꢒc hay trong mꢆt thꢘ tꢇc nào ñó, ví dꢇ vꢔi hàm khai căn
bꢌc hai SQRT() chúng ta không thꢏ viꢄt
sqrt(9);
ðiꢃu này là dꢤ hiꢏu vì hàm cho ta giá trꢛ vô hưꢔng, giá trꢛ này không phꢋi là mꢆt lꢎnh
do ñó Pascal không biꢄt phꢋi làm gì vꢔi giá trꢛ ñó.
Cách gꢅi hàm như sau là hꢁp lꢎ:
a:= sqrt(9) + 5;
Witeln('Can bac hai cua 9 bang ',sqrt(9));
7.2 Gꢞi chương trình con tꢡ chương trình con khác
Các chương trình con cùng cꢓp có thꢏ gꢅi tꢔi nhau và truyꢃn tham sꢀ cho nhau.
Nguyên tꢟc gꢅi là: nhꢑng chương trình con xây dꢊng sau có thꢏ gꢅi tꢔi các chương
trình con ñã xây dꢊng trưꢔc nó, ñꢖng thꢉi các chương trình con cꢓp dưꢔi cũng có thꢏ gꢅi tꢔi
các chương trình con cꢓp trên nꢄu chúng cùng mꢆt gꢀc. ðiꢃu này có nghĩa là các chương
trình con xây dꢊng trưꢔc không thꢏ gꢅi tꢔi các chương trình con xây dꢊng sau nꢄu không có
chꢢ báo FORWARD (xem mꢇc 8). Xét mꢆt sꢀ ví dꢇ sau:
Ví dꢇ 1.6
Program Goi_ctc;
Uses crt;
Type dayso=array[1..60] of byte; s1=string[30];
Var
a:s1; b:dayso; i,j,n:byte;
Procedure nhapso(m:byte; var c:dayso);
Begin
For i:=1 to m do
Begin
Write('c[',i,'] = '); readln(c[i]);
End;
End;
Function tinhtong(m:byte; d:dayso):real;
var tong:real;
Begin
tong:=0;
for i:= 1 to m do Tong:=tong+d[i];
tinhtong:=tong;
End;
Procedure viet(k:byte; e:dayso);
Begin
Write('Tong cac phan tu mang = ',tinhtong(k,e):8:0);
readln;
End;
BEGIN
clrscr;
write('Nhap so phan tu n '); readln(n);
nhapso(n,b);
viet(n,b);
END.
Ví dꢇ 1.6 thiꢄt kꢄ ba chương trình con là Nhapso, Tinhtong và Viet. Thꢘ tꢇc Nhapso
dùng ñꢏ nhꢌp các phꢞn tꢍ vào mꢋng mꢆt chiꢃu. Hàm Tinhtong dùng ñꢏ tính tꢚng các phꢞn tꢍ
mꢋng và thꢘ tꢇc Viet dùng ñꢏ hiꢎn kꢄt quꢋ tính tꢚng lên màn hình.
Chương trình mꢣ gꢅi chương trình con Viet và truyꢃn các tham sꢀ là sꢀ phꢞn tꢍ mꢋng
n và giá trꢛ cꢘa các phꢞn tꢍ cꢘa mꢋng ( mꢋng b ). Chương trình con Viet lꢂi gꢅi hàm Tinhtong
và truyꢃn các tham sꢀ cho hàm này. ðây là trưꢉng hꢁp mꢆt chương trình con gꢅi mꢆt chương
trình con cùng cꢓp.
Viꢎc các chương trình con gꢅi tꢔi nhau phꢋi tuân theo quy ñꢛnh sau ñây:
Mꢆt chương trình con chꢢ có thꢏ gꢅi tꢔi mꢆt chương trình con cùng cꢓp ñã thiꢄt kꢄ
trưꢔc chương trình con hiꢎn thꢉi.
Trong ví dꢇ 1.6 nꢄu chúng ta ñưa hàm Tinhtong xuꢀng dưꢔi thꢘ tꢇc Viet thì khi chꢂy
chương trình sꢝ bꢛ báo lꢠi:
Unknown Indentifier.
Ví dꢇ 1.7 dưꢔi ñây trình bày cách thꢒc mà mꢆt chương trình con cꢓp dưꢔi gꢅi tꢔi mꢆt
chương trình con cꢓp trên cùng gꢀc.
Ví dꢌ 1.7
Program goi_ctc;
Uses crt;
Type dayso=array[1..60] of byte;
Var b:dayso;
i,n:byte;
{Hai chương trình con Nhapso và Tinhtong cùng cꢓp vꢔi thꢘ tꢇc Xuly}
Procedure nhapso(m:byte; var c:dayso);
Begin
For i:=1 to m do
Begin
Write('c[',i,'] = '); readln(c[i]);
End;
End;
Function tinhtong(m:byte; d:dayso):real;
Var tong:real;
Begin
tong:=0;
for i:= 1 to m do Tong:=tong+d[i];
tinhtong:=tong;
End;
Procedure xuly(j:byte; ds:dayso);
Procedure viet(k:byte; e:dayso);
Var i:byte;
Begin
Writeln('Tong cac phan tu mang = ',tinhtong(k,e):8:0);
Writeln('Day so sap xep giam dan ');
for i:=1 to k do write(e[i],' ');
readln;
End;
{ Kꢄt thúc thꢘ tꢇc Viet}
Procedure sapxep(m:byte; d:dayso);
Var p,q:byte; Tg:byte;
Begin
For p:= 1 to m-1 do
For q:=p+1 to m do
If d[p]<d[q] then
Begin
tg:=d[p]; d[p]:=d[q]; d[q]:=tg;
End;
viet(m,d);
End; { Kꢄt thúc thꢘ tꢇc sapxep}
Begin {than thu tuc Xuly}
Writeln('Thu tuc xu ly dung de sap xep va viet ket qua');
sapxep(j,ds);
end;
{ Kꢄt thúc thꢘ tꢇc Xuly}
BEGIN {Than chuong trinh me}
clrscr;
write('Nhap so phan tu n '); readln(n);
nhapso(n,b);
xuly(n,b);
END.
Ví dꢇ 1.7 có ba chương trình con cùng cꢓp là Nhapso, Tinhtong và Xuly. Trong thꢘ
tꢇc Xuly có hai chương trình con là Viet và Sapxep trong ñó chương trình con Viet ñưꢁc thiꢄ
kꢄ trưꢔc, Sapxep ñưꢁc thiꢄt kꢄ sau. Chương trình con Sapxep có lꢉi gꢅi ñꢄn chương trình con
Viet cùng cꢓp vꢔi nó, mꢇc ñích cꢘa lꢉi gꢅi này là truyꢃn cho chương trình con Viet nhꢑng dꢑ
liꢎu mꢋng ñã sꢟp xꢄp giꢋm dꢞn. Chương trình con Viet có lꢉi gꢅi ñꢄn hàm Tinhtong là mꢆt
chương trình con cꢓp cao hơn nó, vì Tinhtong ñã ñưꢁc thiꢄt kꢄ trưꢔc Xuly nên lꢉi gꢅi là hꢁp
lý. Nꢄu ñꢋo vꢛ trí cꢘa hai chương trình con Viet và Sapxep, nghĩa là ñưa chương trình con
Viet xuꢀng sau Sapxep thì sꢝ bꢛ báo lꢠi , vꢃ ñiꢃu này chúng ta sꢝ nghiên cꢒu ꢗ mꢇc 8.
8. Khai báo trưꢠc bꢣng Forward
Như ñã nêu trong mꢇc 7 viꢎc các chương trình con gꢅi tꢔi nhau bꢛ hꢂn chꢄ bꢗi thꢒ tꢊ
xây dꢊng các chương trình con ñó. Vì nhꢑng lý do khác nhau ngưꢉi ta không thꢏ thay ñꢚi thꢒ
tꢊ xây dꢊng các chương trình con nhưng lꢂi muꢀn các chương trình con phꢋi gꢅi ñưꢁc tꢔi
nhau không phꢇ thuꢆc vào thꢒ tꢊ xây dꢊng chúng. ðꢏ làm viꢎc này Pascal cho phép sꢍ dꢇng
tꢙ khoá Forward. Nghĩa ñen cꢘa tꢙ Forward là "phía trưꢔc" thưꢉng ñưꢁc dùng ñꢏ báo hiꢎu
mꢆt cái gì ñó ta sꢝ gꢜp sau này ví dꢇ: phía trưꢔc 200 mét là công trưꢉng.
Cú pháp:
Tên chương trình con (danh sách tham sꢚ); Forward;
Dòng khai báo trên ñây phꢋi ñưꢁc ñꢜt trong chương trình trưꢔc khi xây dꢊng tꢓt cꢋ
các chương trình con. Khi tên mꢆt chương trình con ñã ñưꢁc khai báo vꢔi cú pháp nêu trên thì
viꢎc nó nꢡm trưꢔc hay sau mꢆt chương trình con sꢝ gꢅi tꢔi nó là không quan trꢅng. Sꢀ lưꢁng
chương trình con khái báo trưꢔc vꢔi tꢙ khoá Forward là không hꢂn chꢄ.
Cꢞn lưu ý rꢡng nꢄu có nhiꢃu chương trình con cꢞn khai báo trưꢔc thì mꢠi tên chương
trình con phꢋi ñi vꢔi mꢆt tꢙ khoá Forward, không thꢏ ghép nhiꢃu tên chương trình con vꢔi
cùng mꢆt tꢙ Forward.
Ví dꢇ 1.8
Program Tu_khoa_Forward;
uses crt;
Type dayso=array[1..60] of byte;
var
a:string; b:dayso;
i,j,n:byte;
Function c2(m:byte; d:dayso):real; forward;
Procedure c4(p:byte; var q:dayso); forward;
Procedure c1(m:byte; var c:dayso);
Begin
For i:=1 to m do
Begin
Write('c[',i,'] = '); readln(c[i]);
End;
End;
Procedure c3(k:byte; e:dayso);
Var i:byte;
Begin
c4(k,e);
writeln('Mang sau khi sap xep');
for i:= 1 to k do write(e[i],' ');
writeln;
Write('Tong cac phan tu mang = ',c2(k,e):8:0);
readln;
End;
Function c2(m:byte; d:dayso):real;
var tong:real;
Begin
tong:=0;
for i:= 1 to m do Tong:=tong+d[i];
c2:=tong;
End;
Procedure c4(p:byte; var q:dayso);
Var i,j:byte; tg:integer;
Begin
for i:= 1 to (p-1) do
for j:= i+1 to p do
if q[i]>q[j] then
Begin
tg:=q[i]; q[i]:=q[j]; q[j]:=tg;
End;
End;
BEGIN
clrscr;
write('Nhap so phan tu n '); readln(n);
c1(n,b);
c3(n,b);
END.
Ví dꢇ 1.8 có 4 chương trình con trong ñó c1 và c3 thiꢄt kꢄ trưꢔc còn c2 và c4 thiꢄt kꢄ
sau. Trong c3 có lꢉi gꢅi ñꢄn c2 và c4 do vꢌy phꢋi khai báo trưꢔc c2 và c4 . Nꢄu không muꢀn
khai báo trưꢔc thì cꢞn ñưa c2 và c4 lên trên c3.
Bài tꢖp ꢜng dꢌng chương 1
1. Lꢌp chương trình tính diꢎn tích toàn phꢞn và thꢏ tích các hình : Trꢇ tròn, nón.
Yêu cꢞu: Thiꢄt kꢄ menu theo mꢕu sau, Menu có thꢏ dùng con trꢦ dꢛch chuyꢏn ñꢏ chꢅn
các chꢒc năng: Hinh Tru
Hinh Non
Ket thuc
Viꢎc tính toán diꢎn tích, thꢏ tích mꢠi hình ꢒng vꢔi mꢆt chương trình con
Tꢓt cꢋ các hình ñꢃu chung mꢆt chương trình con hiꢎn kꢄt quꢋ. Chꢒc năng Ket thuc
dùng ñꢏ quay vꢃ cꢍa sꢚ Pascal.
2. Lꢌp mꢆt chương trình tꢂo thꢊc ñơn vꢔi các chꢒc năng:
Tính giai thꢡa Tính tꢤ hꢟp Trꢉ vꢙ
Dùng các chương trình con ñã lꢌp ñꢏ giꢋi bài toán sau: Cho n ñiꢏm trên màn hình, qua
hai ñiꢏm bꢓt kỳ bao giꢗ cũng nꢀi ñưꢁc bꢗi mꢆt ñoꢂn thꢋng. Tính xem có bao nhiêu ñoꢂn
thꢐng ñưꢁc tꢂo ra. Tìm ñoꢂn ngꢟn nhꢓt và dài nhꢓt , chúng nꢀi các ñiꢏm nào?
3. Thiꢄt kꢄ thꢊc ñơn vꢔi các chꢒc năng:
1.giai he pt bac nhat
2. giai pt bac hai
3.Ket thuc
Yêu cꢞu: Bꢓm sꢀ ñꢏ chꢅn chꢒc năng trên thꢊc ñơn. Chꢒc năng Ket thuc dùng ñꢏ quay
vꢃ cꢍa sꢚ Pascal.
Chương trình có 2 chương trình con ñꢏ giꢋi hꢎ phương trình bꢌc nhꢓt 2 ꢈn và giꢋi
phương trình bꢌc 2
4. A,B là mꢋng hai chiꢃu cꢘa các sꢀ thꢊc, sꢀ dòng và cꢆt cꢘa tꢙng mꢋng nhꢌp tꢙ bàn
phím, lꢌp chương trình bao gꢖm các chương trình con: nhꢌp dꢑ liꢎu vào mꢋng, kiꢏm tra xem
có thꢏ nhân hai mꢋng hay không, nꢄu có thì chꢂy chương trình con nhân hai mꢋng, nꢄu không
thì thông báo không thꢏ nhân hai mꢋng. Hiꢎn kꢄt quꢋ nhân dưꢔi dꢂng ma trꢌn.
5. Cho hai chuꢠi s1, s2, viꢄt chương trình bao gꢖm các chương trình con:
NHAP dùng ñꢏ nhꢌp vào s1, s2 các ký tꢊ cꢘa bꢋng mã gꢖm cꢋ chꢑ cái và chꢑ sꢀ,
TACH dùng ñꢏ tách riêng các chꢑ sꢀ và chꢑ cái, nhꢑng chꢑ sꢀ tách ra lưu vào mꢋng
mꢆt chiꢃu theo thꢒ tꢊ cꢘa s1 trưꢔc, s2 sau.
CONG dùng ñꢏ cꢆng các chꢑ sꢀ tách ra tꢙ hai chuꢠi
Thông báo kꢄt quꢋ theo mꢕu:
Chuꢠi s1 sau khi tách:..................
Chuꢠi s2 sau khi tách:..................
Tꢚng các chꢑ sꢀ:.........................
6. Lꢌp chương trình vꢔi 4 chương trình con dùng ñꢏ chuyꢏn ñꢚi các sꢀ giꢑa 4 hꢎ ñꢄm:
Hꢎ 10 sang hꢎ 2, 8, 16
Hꢎ 2 sang hꢎ 8, 10, 16
Hꢎ 8 sang hꢎ 2, 10, 16
Hꢎ 16 sang hꢎ 2, 8, 10
Chương 2
Các kiꢍu dꢎ liꢏu có cꢐu trúc
Trong chương này không trình bày chi tiꢄt các kiꢏu dꢑ liꢎu có cꢓu trúc ñơn giꢋn như
kiꢏu mꢋng, chuꢠi. Nꢆi dung trꢅng tâm cꢘa chương là kiꢏu bꢋn ghi (Record) có cꢓu trúc thay
ñꢚi, kiꢏu tꢎp và kiꢏu tꢌp hꢁp. Chương này bꢂn ñꢅc cꢞn nꢟm ñưꢁc các vꢓn ñꢃ sau:
ꢀ Cách thꢒc ñꢛnh nghĩa mꢆt kiꢏu dꢑ liꢎu mꢔi
ꢀ Khai báo biꢄn vꢔi các kiꢏu dꢑ liꢎu do ngưꢉi lꢌp trình tꢊ ñꢛnh nghĩa
ꢀ Cách sꢍ dꢇng toán tꢍ CASE khi khai báo bꢋn ghi có cꢓu trúc thay ñꢚi
ꢀ Cách thꢒc ghi và ñꢅc dꢑ liꢎu cho ba loꢂi tꢎp: tꢎp văn bꢋn, tꢎp có kiꢏu và tꢎp
không kiꢏu, chú trꢅng cách ghi dꢑ liꢎu kiꢏu sꢀ vào tꢎp văn bꢋn và lꢓy sꢀ liꢎu ra
ñꢏ xꢍ lý
ꢀ Xꢍ dꢇng dꢑ liꢎu kiꢏu tꢌp hꢁp trong lꢌp trình
Tải về để xem bản đầy đủ
207 trang
22660
Free
Bạn đang xem 20 trang mẫu của tài liệu "Giáo trình Lập trình nâng cao", để tải tài liệu gốc về máy hãy click vào nút Download ở trên
File đính kèm:
- giao_trinh_lap_trinh_nang_cao.pdf
