›
›

Bài giảng Kỹ thuật lập trình - Chương 2: Một số vấn đề trong kỹ thuật lập trình - Lương Mạnh Bá

Download
Chương II  
Mꢀt sꢁ vꢂn đꢃ trong KTLT  
(6LT – 2BT)  
Last update 8-2010  
SE-SoICT  
KTLT-2.1  
Chương II  
1. Tꢄ chꢅc chương trꢆnh  
2. Biꢇn cꢈc bꢀ/Biꢇn toꢉn cꢈc  
3. Cꢂu trꢊc dꢋ liꢌu đꢀng  
4. Cꢂp phꢍt tꢎnh vꢉ cꢂp phꢍt  
đꢀng  
Last update 8-2010  
SE-SoICT  
KTLT-2.2  
2.1 Tꢄ chꢅc CT  
• Khi giꢀi quyꢁt BT, theo phương phꢂp tiꢁp cꢃn  
cꢄu trꢅc, BT đưꢆc phân chia thꢇnh cꢂc BT con  
vꢇ cꢂc CT con sꢈ đꢀm nhiꢉm. Quꢂ trꢊnh phân rꢋ  
cꢌ tiꢁp tꢍc đꢁn 1 mꢌc đꢎ chi tiꢁt.  
• Mꢏi NNLT đꢐu cung cꢄp phương tiꢉn đꢑ tꢒ  
chꢌc chương trꢊnh con.  
• Gꢏi lꢇ CT con đꢑ phân biꢉt vꢓi CT ꢔ mꢌc ngoꢇi  
(main) đưꢆc gꢀi thꢁc hiꢂn bꢃi ND.  
• CT con cꢕ cꢄu trꢅc giꢖng như main song đưꢆc  
gꢀi vꢄ cꢅ thꢆ gꢀi cꢇc CT con khꢇc.  
Last update 8-2010  
SE-SoICT  
KTLT-2.3  
CT con (tiꢇp)  
• CT con thưꢗng gꢘm 2 loꢙi tꢚy theo cꢂch sꢛ  
dꢍng:  
– CT con Hꢇm  
– CT con Thꢎ tꢍc  
• CT con Hꢇm lꢇ CT con dꢚng đꢑ thꢜc hiꢉn 1 tꢝnh  
toꢂn vꢇ trꢀ vꢐ 1 giꢂ trꢞ cꢎa 1 kiꢑu DL hꢆp lꢉ qui  
đꢞnh bꢔi NNLT đꢕ.  
• CT con thꢎ tꢍc thꢜc hiꢉn 1 nhiꢉm vꢍ phꢌc tꢙp  
hơn (không nhꢄt thiꢁt lꢇ tꢝnh toꢂn) vꢇ không trꢀ  
vꢐ 1 kꢁt quꢀ nꢇo.  
• Trong C không phân biꢉt 2 khꢂi niꢉm nꢇy. Tuy  
nhiên vꢟn đưꢆc dꢚng theo phong cꢂch chung .  
Last update 8-2010  
SE-SoICT  
KTLT-2.4  
Thꢏ dꢈ CT con (tiꢇp)  
• CT con Hꢇm trong C  
int GT(int n)  
{ if ( n==0) return 1;  
else return n * GT(n-1);  
}
• CT con thꢎ tꢍc trong C  
void nhapmang(Mang V, int n)  
{int i;  
for (i=0;i <n;i++)  
{ printf("\n V[ %d ]=",i);  
scanf("%d",&V[i]);  
}
}
Last update 8-2010  
SE-SoICT  
KTLT-2.5  
CT con (tiꢇp)  
• Trong hꢇm, đꢑ trꢀ vꢐ kꢁt quꢀ tꢝnh toꢂn ngưꢗi ta  
dꢚng lꢉnh/biꢑu thꢌc. Lꢉnh/biꢑu thꢌc phꢍ thuꢠc  
vꢇo NNLT. Trong C, lꢉnh trꢀ vꢐ kꢁt quꢀ tꢝnh  
toꢂn: return <bt trꢞ>  
• Trong thꢎ tꢍc không trꢀ vꢐ kꢁt quꢀ nên dꢚng  
dꢙng “void” cꢕ nghꢡa lꢇ rꢢng, không cꢕ: không  
cꢕ giꢂ trꢞ, không cꢕ tham sꢖ.  
• Thꢝ dꢍ void main(void) == main()  
• Lꢉnh gꢏi CT con hꢇm xuꢄt hiꢉn trong bt; lꢉnh  
gꢏi CT con thꢎ tꢍc lꢇ 1 lꢉnh hꢆp lꢉ.  
Last update 8-2010  
SE-SoICT  
KTLT-2.6  
Tham sꢁ thꢐc vꢉ tham  
sꢁ hꢆnh thꢅc  
• Tham sꢖ thꢜc lꢇ tham sꢖ xuꢄt hiꢉn trong lꢗi gꢏi  
CT con.  
• Tham sꢖ hꢊnh thꢌc lꢇ tham sꢖ xuꢄt hiꢉn trong  
chꢣ kꢤ (header) cꢎa CT con.  
N lꢉ tham sꢁ hꢆnh thꢅc  
int GT(int n)  
{ if ( n==0) return 1;  
else return n * GT(n-1);  
}
….  
3 lꢉ tham sꢁ thꢐc  
Printf(“\3!= %d”,GT(3));  
Last update 8-2010  
SE-SoICT  
KTLT-2.7  
Quan hꢌ giꢋa CT gꢑi vꢉ  
CT đưꢒc gꢑi  
• Khi CT con gꢏi (calling) 1 CT con khꢂc (called) “giꢇ trꢈ”  
cꢎa tham sꢖ thꢜc sꢈ truyꢐn cho tham sꢖ hꢊnh thꢌc.  
• Như vꢃy mꢖi quan hꢉ “gꢏi & đưꢆc gꢏi” thông qua tham  
sꢖ (cꢂch thꢌc chuꢥn trong LT).  
• Cꢕ nhiꢐu cꢂch truyꢐn tham sꢖ:  
•Truyꢐn trꢞ (by val): giꢂ trꢞ cꢎa th/sꢖ thꢜc sꢈ truyꢐn  
cho th/sꢖ hꢊnh thꢌc. Mꢏi thay đꢒi giꢂ trꢞ cꢎa tham sꢖ  
hꢊnh thꢌc trong CT con không lꢇm thay đꢒi giꢂ trꢞ cꢎa  
tham sꢖ thꢜc khi quay vꢐ CT gꢏi.  
• Cꢅ phꢂp, ngꢣ nghꢡa cꢎa Th/sꢖ hꢊnh thꢌc!!!  
Last update 8-2010  
SE-SoICT  
KTLT-2.8  
Quan hꢌ giꢋa CT gꢑi vꢉ  
đưꢒc gꢑi (tiꢇp)  
• Truyꢐn theo tham chiꢁu (by reference) hay đꢞa chꢦ  
(address) hay …: đꢞa chꢦ cꢎa th/sꢖ thꢜc truyꢐn cho th/sꢖ  
hꢊnh thꢌc. Mꢏi thay đꢒi giꢂ trꢞ cꢎa th/sꢖ hꢊnh thꢌc trong  
CT con sꢈ tꢂc đꢠng đꢁn th/sꢖ thꢜc khi quay vꢐ CT con  
gꢏi (hiꢉu ꢌng lꢐ – side effect).  
•=> Cꢅ phꢂp, ngꢣ nghꢡa cꢎa Th/sꢖ thꢜc!!!  
• TD: Minh hꢀa 1 sꢉ vꢊ dꢋ  
• Truyꢐn theo tên (macro)  
• Trong NN C chꢦ cꢕ 1 kiꢑu truyꢐn lꢇ theo trꢞ. Tuy nhiên  
LTV vꢟn cꢕ thꢑ dꢚng thꢎ thuꢃt đꢑ truyꢐn theo đꢞa chꢦ  
(xem phꢧn sau).  
Last update 8-2010  
SE-SoICT  
KTLT-2.9  
Tham sꢖ truyꢐn trꢞ  
#include <stdio.h>  
#include <conio.h>  
swap (int a, int b);  
{ int temp = a;  
a = b;  
Kꢇt quꢓ in ra  
c = 5 d = 7  
b= temp);  
}
main()  
{ int c = 5;  
int d = 7;  
clrscr();  
swap (c,d);  
printf("\n c= %d d=%d",c,d);  
getch();  
}
Last update 8-2010  
SE-SoICT  
KTLT-2.10  
Tham sꢖ truyꢐn theo đꢞa chꢦ  
#include <stdio.h>  
#include <conio.h>  
swap (int *a, int *b);  
{ int temp = *a;  
*a = *b;  
Kꢇt quꢓ in ra  
c = 7 d = 5  
*b= temp;  
}
main()  
{ int c = 5;  
int d = 7;  
clrscr();  
swap (&c,&d);  
printf("\n c= %d d=%d",c,d);  
getch();  
}
Last update 8-2010  
SE-SoICT  
KTLT-2.11  
Tꢄ chꢅc CT con  
• Đꢑ tiꢉn sꢛ dꢍng CT con đưꢆc tꢒ chꢌc theo nhiꢐu  
hꢊnh thꢌc khꢂc nhau:  
1. Trong cùng 1 chương trình với CT chꢊnh  
2. Ghép thꢄnh đơn vꢈ CT  
3. Ghép thꢄnh mô đun (đơn thꢆ chương trình)  
• Cꢂch tꢒ chꢌc thꢌ 2 vꢇ 3 tiꢉn dꢍng hơn vꢊ tꢝnh tꢂi sꢛ  
dꢍng. Cꢂc CT con cꢎa ND cꢕ thꢑ chuyꢑn vꢇo Thư  
Viꢉn chương trꢊnh cꢎa NNLT đꢕ (cꢂc NNLT đꢐu cꢕ  
công cꢍ hꢢ trꢆ viꢉc nꢇy.  
• TD: minh hꢏa qua C/ Pascal.  
Last update 8-2010  
SE-SoICT  
KTLT-2.12  
Chương II  
1. Tꢄ chꢅc chương trꢆnh  
2. Biꢇn cꢈc bꢀ/Biꢇn toꢉn cꢈc  
3. Cꢂu trꢊc dꢋ liꢌu thay đꢄi  
4. Cꢂp phꢍt tꢎnh vꢉ cꢂp phꢍt  
đꢀng  
Last update 8-2010  
SE-SoICT  
KTLT-2.13  
2.2 Biꢇn cꢈc bꢀ (local) vꢉ  
toꢉn cꢈc (global)  
• Khi 1 CT đưꢆc gꢏi nꢕ đưꢆc nꢙp vꢇo bꢠ nhꢓ vꢇ thưꢗng  
trꢅ trong bꢠ nhꢓ đꢁn khi kꢁt thꢅc thꢜc hiꢉn. Đꢕ chꢝnh lꢇ  
vòng đꢗi cꢎa CT => Do vꢃy cꢂc đꢙi lưꢆng đꢞnh nghꢡa  
trong CT đꢕ cũng kꢁt thꢅc vòng đꢗi cꢎa mꢊnh. => Nꢀy  
sinh khꢂi niꢉm biꢁn cꢍc bꢠ vꢇ biꢁn toꢇn cꢍc.  
• Biꢁn cꢍc bꢠ (local variables): Cꢂc biꢁn đưꢆc đꢞnh nghꢡa  
trong 1 CT vꢇ chꢦ đưꢆc sꢛ dꢍng trong CT con đꢕ. Nꢅ cꢅ  
cùng vòng đời với CT sinh ra nꢅ. Khꢂi niꢉm cꢍc bꢠ cũng  
lꢇ tương đꢖi vꢇ phꢍ thuꢠc vꢇo cꢂch tꢒ chꢌc CT. Nꢕ lꢇ  
cꢍc bꢠ cꢎa CT con đꢕ song lꢇ toꢇn cꢍc vꢓi CT con cꢎa  
nꢕ.  
Last update 8-2010  
SE-SoICT  
KTLT-2.14  
Biꢇn cꢈc bꢀ vꢉ toꢉn cꢈc  
(tiꢇp)  
• Biꢁn toꢇn cꢍc (global variables): Cꢂc biꢁn đưꢆc đꢞnh  
nghꢡa trong 1 CT vꢇ đưꢆc sꢛ dꢍng trong CT con đꢕ vꢇ  
cꢂc CT con cꢎa nꢕ. => Đ/n ꢔ 1 nơi vꢇ sꢛ dꢍng ꢔ nơi  
khꢂc.  
• Mꢠt loꢙi nꢣa lꢇ static: Nꢕ lꢇ cꢍc bꢠ cꢎa 1 CT song lꢙi  
duy trꢊ vòng đꢗi cꢚng vꢓi mꢌc cao nhꢄt: Khi CT nơi nꢕ  
đ/n kꢁt thꢅc (loꢙi khỏi bꢠ nhꢓ) nꢕ vꢟn còn tꢘn tꢙi. => Ưu  
điꢑm: trꢂnh hiꢉu ꢌng lꢐ.  
• Chꢅ ꢤ cꢂch dꢚng  
Last update 8-2010  
SE-SoICT  
KTLT-2.15  
Thꢏ dꢈ  
int V[…];  
void inmang(int n)  
{
Biꢇn cꢈc bꢀ cꢔa CT con inmang  
int i;  
for (i=0;i <n;i++)  
printf(" %4d",V[i]);  
}
Biꢇn cꢈc bꢀ cꢔa main  
main ()  
{int i,j,n, tam;  
clrscr();  
printf(" So Phan tu cua mang:\n");  
scanf("%d",&n);  
nhapmang(n);  
printf("\n Day so vua nhap:");  
inmang(n);  
}
Last =up>daLteư8u-20ꢤ10sꢛ dꢍng biꢁn toꢇn cꢍc đꢑ liên kꢁt vꢓi CT con!!!  
SE-SoICT  
KTLT-2.16  
Chương II  
1. Tꢄ chꢅc chương trꢆnh  
2. Biꢇn cꢈc bꢀ/Biꢇn toꢉn cꢈc  
3. Cꢂu trꢊc dꢋ liꢌu thay đꢄi  
4. Cꢂp phꢍt tꢎnh vꢉ cꢂp phꢍt  
đꢀng  
Last update 8-2010  
SE-SoICT  
KTLT-2.17  
2.3 Cꢂu trꢊc dꢋ liꢌu thay  
đꢄi  
• Trong quꢂ trinh lꢃp trꢊnh nhiꢐu khi ta cꢧn cꢕ kiꢑu dꢣ  
liꢉu đꢂp ꢌng đưꢆc tꢊnh huꢖng cꢍ thꢑ. TD:  
1. Hꢏc sinh phꢀi hꢏc cꢂc môn hꢏc văn hꢕa như  
nhau. Tuy nhiên viꢉc hꢏc nghꢐ lꢙi phꢍ thuꢠc vꢇo giꢓi  
tꢝnh: Nam hꢏc Mꢠc, Cơ khꢝ; Nꢣ hꢏc Thêu, Cꢨm  
hoa,… Vꢃy cꢄu trꢅc nꢇo hꢢ trꢆ biꢑu diꢩn đꢂp ꢌng  
tꢊnh huꢖng trên.  
• Pascal: cꢄu trꢅc mꢟu tin thay đỏi  
• C: dꢚng cꢄu trꢅc Union  
Last update 8-2010  
SE-SoICT  
KTLT-2.18  
Mꢕu tin biꢇn thꢖ  
struct WORDREGS {  
unsigned int ax, bx, cx, dx, si, di, cflag, flags;  
};  
struct BYTEREGS {  
unsigned char al, ah, bl, bh, cl, ch, dl, dh;  
};  
union REGS {  
struct WORDREGS x;  
struct BYTEREGS h;  
};  
Last update 8-2010  
SE-SoICT  
KTLT-2.19  
Mꢕu tin biꢇn thꢖ (tiꢇp)  
Typedef union {  
struct { long abscisse ;  
long ordonne;  
}cart;  
struct {  
float rho;  
float theta;  
}pol;  
coord p1,p2;// đꢞnh nghꢡa 2 điꢑm p1 vꢇ p2  
=> Truy nhꢃp tꢓi thꢇnh phꢧn cꢎa cꢂc điꢑm:  
P1.cart.abscisse, p2.pol.theta  
Last update 8-2010  
SE-SoICT  
KTLT-2.20  
Tải về để xem bản đầy đủ
ppt 72 trang Thùy Anh 15200 Free
Download
Bạn đang xem 20 trang mẫu của tài liệu "Bài giảng Kỹ thuật lập trình - Chương 2: Một số vấn đề trong kỹ thuật lập trình - Lương Mạnh Bá", để 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:

  • pptbai_giang_ky_thuat_lap_trinh_chuong_2_mot_so_van_de_trong_ky.ppt