Bài giảng Nguyên lý ngôn ngữ lập trình - Chương 3: Cấu trúc điều khiển

Chương 3: Cꢀu trúc ñiꢁu

khiꢂn

Giꢀng viên: Ph.D Nguyꢁn Văn Hòa

Khoa KT-CN-MT – ðH An Giang

1

Giꢃi thiꢄu

ꢀ Dꢂ liꢃu và tác vꢄ là 2 yꢅu tꢆ cơ bꢀn cꢇa CT

ꢀ Mꢈi sꢉ kꢅt hꢊp cꢇa chúng gꢋn liꢌn vꢍi cꢎu trúc

ñiꢌu khiꢏn

ꢀ Cꢎu trúc ñiꢌu khiꢏn là tꢐp hꢊp các qui tꢋc xác

ñꢑnh thꢒ tꢉ thꢉc hiꢃn chương trình

ꢀ Xét vꢌ cꢎu trúc thì có 3 loꢓi ñiꢌu khiꢏn

ꢁ ðiꢌu khiꢏn trong biꢏu thꢒc

ꢁ ðiꢌu khiꢏn giꢂa các lꢃnh (phát biꢏu): như cꢎu trúc ñiꢌu

kiꢃn hay cꢎu trúc lꢔp

ꢁ ðiꢌu khiꢏn trong chương trình con: gꢕi trꢀ vꢌ hay ñꢃ

qui

2

Giꢃi thiꢄu (tt)

ꢀ Xét vꢌ thiꢅt kꢅ ngôn ngꢂ thì có 2 loꢓi ñiꢌu khiꢏn

ꢁ ðiꢌu khiꢏn ngꢖm: ñưꢊc thiꢅt kꢅ trong ngôn ngꢂ LT,

VD qui tꢋc ưu tiên cꢇa các toán tꢗ

ꢁ ðiꢌu khiꢏn tưꢘng minh: ñưꢊc xác ñꢑnh bꢙi programmer

ꢀ Hai cꢎu trúc ñiꢌu khiꢏn

ꢁ ðiꢌu khiꢏn tuꢖn tꢉ

ꢁ ðiꢌu khiꢏn cꢓnh tranh (concurrency) : 2 hoꢔc nhiꢌu

hơn ñoꢓn chương trình ñưꢊc thꢉc thi song song

ꢀ Cꢎu trúc ñiꢌu khiꢏn tꢆt

ꢁ Dꢁ viꢅt

ꢁ Dꢁ ñꢕc

3

Nꢅi dung chính cꢆa chương

ꢀ ðiꢌu khiꢏn trong biꢏu thꢒc

ꢀ Lꢃnh lꢉa chꢕn hay ñiꢌu kiꢃn

ꢀ Lꢃnh lꢔp

ꢀ Rꢚ nhánh không ñiꢌu kiꢃn

ꢀ Luꢛng ñiꢌu khiꢏn không tuꢖn tꢉ

4

ðiꢁu khiꢂn trong biꢂu thꢇc

ꢀ Cơ chꢅ ñiꢌu khiꢏn trong biꢏu thꢒc là sꢉ chꢛng

chꢎt hàm (functional composition)

ꢁ Tác vꢄ hay phép toán

ꢁ Các ñꢆi sꢆ hay toán hꢓng

ꢀ Toán hꢓng: hꢜng, các kꢅt quꢀ cꢇa các phép tham

khꢀo dꢂ liꢃu (biꢅn) hoꢔc kꢅt quꢀ cꢇa các phép

toán khác

*

ꢀ Cơ chꢅ chꢛng ñưꢊc biꢏu

-

+

diꢁn bꢙi mꢝt cꢎu trúc cây

A

B C

A

(A+B)*(C-A)

5

ðiꢁu khiꢂn trong biꢂu thꢇc (tt)

ꢀ Thꢒ tꢉ ưu tiên cꢇa các toán tꢗ

ꢀ Các toán tꢗ cùng ñꢝ ưu tiên

ꢀ Thꢒ tꢉ các toán hꢓng

ꢁ Hiꢃu ꢒng lꢌ

ꢀ Tính ña năng cꢇa toán tꢗ

6

Thꢇ tꢈ ưu tiên các toán tꢉ

ꢀ Kꢅt quꢀ cꢇa biꢏu thꢒc 3 + 5 * 2 ?? → phꢄ thuꢝc

thꢒ tꢉ thꢉc hiꢃn các toán tꢗ

ꢀ Thꢒ tꢉ thꢉc hiꢃn các toán tꢗ trong NNLT

FORTRAN 95

C

Ada

**, abs

*, /, mod

rem

**

postfix ++,--

prefix ++,

-âm, +dương

*, /, %

*, /

-âm, +dương

+,-

7

Các toán tꢉ cùng ưu tiên (associativity)

ꢀ Các phép toán có cùng ưu tiên, + và -, cꢖn có 1

qui luꢐt ñꢏ xác ñꢑnh thꢒ tꢉ thꢉc hiꢃn

ꢀ VD a-b+c-d

ꢀ Các NNLT qui ñꢑnh thꢒ tꢉ thꢉc hiꢃn

ꢁ Tꢞ trái sang phꢀi

ꢁ Trꢞ Fortran (tꢞ phꢀi sang trái)

ꢀ Ada bꢋt buꢝc phꢀi có dꢎu ngoꢔc ((a-b)+c)-d

ꢀ Nꢅu có ngꢎu ngoꢔc thì thꢒ tꢉ ưu tiên cꢇa các toán

tꢗ bꢑ mꢎt ñi và thꢉc hiꢃn theo dꢎu ngoꢔc

8

Biꢂu thꢇc ñiꢁu kiꢄn

ꢀ Toán tꢗ «?» là toán tꢗ tam phân (ternary)

ꢀ Biꢏu thꢒc ñiꢌu kiꢃn chꢟ có trong ngôn ngꢂ C

ꢀ VD average = (count == 0)? 0 : sum / count

ꢀ Có thꢏ dùng câu lꢃnh if-then-else thay thꢅ

if (count == 0)

average = 0;

else

average = sum /count;

9

Biꢂu thꢇc quan hꢄ

ꢀ Biꢏu thꢒc quan hꢃ: 1 toán tꢗ quan hꢃ và 2 toán

hꢓng có nhiꢌu kiꢏu khác nhau

ꢀ Trꢑ cꢇa biꢏu thꢒc quan hꢃ: ñúng hoꢔc sai

ꢀ VD toán tꢗ quan hꢃ

FORTRAN 95

.EQ. = =

C

Ada

=

B

ꢜ

ng

Không B

n h

Nh

n h

Nh

= =

!=

>

ꢜ

ng

.NE. <>

/=

>

<

>=

<=

Lꢍ

ơ

n

.GT. >

ꢠ

hơ

n

.LT. <

<

Lꢍ

ơ

n or b

ꢜ

ng .GN. >=

>=

<=

ꢠ

hơ

n or b

ꢜ

ng .LN. <=

10

Biꢂu thꢇc logic

ꢀ Biꢏu thꢒc logic: 1 toán tꢗ logic và 2 toán hꢓng có

kiꢏu logic

ꢀ Trꢑ cꢇa biꢏu thꢒc logic: ñúng hoꢔc sai

ꢀ VD các toán tꢗ logic

FORTRAN 77 FORTRAN 90 C Ada

.AND.

.OR.

and

or

&& and

|| or

! not

xor

.NOT.

not

11

Thꢇ tꢈ thꢈc hiꢄn các toán tꢉ : C

ꢀ Hꢐu tꢆ (++, --)

ꢀ Tiꢌn tꢆ (++, --, !) âm dương (+, -)

ꢀ *, /, %

ꢀ +, -

ꢀ <,>,<=,>=

ꢀ ==, !=

ꢀ &&

ꢀ ||

12

Hiꢄu ꢇng lꢁ

ꢀ Hiꢃu ꢒng lꢌ là 1 phép toán trꢀ vꢌ kꢅt quꢀ ꢡn

ꢀ Hàm hiꢃu ꢒng lꢌ là hàm thay ñꢢi biꢅn không cꢄc

bꢝ hoꢔc có truyꢌn quy chiꢅu

int a= 5;

int fun1(){a = 17; return 3;}

void fun2(){a = a + fun1();}

void main(){

fun2();

}

ꢀ Kꢅt quꢀ cꢇa alà 8 hay 20

13

Hiꢄu ꢇng lꢁ

ꢀ Giꢀi pháp ñꢏ giꢀi quyꢅt hiꢃu ꢒng lꢌ

ꢁ NNLT không cho phép hàm tham chiꢅu các biꢅn không

cꢄc bꢝ và truyꢌn quy chiꢅu

ꢀ

Ưu ñiꢏm : dꢁ thꢉc hiꢃn

ꢀ

Khuyꢅt ñiꢏm : không linh hoꢓt

ꢁ NNLT phꢀi qui ñꢑnh thꢒ tꢉ ưu tiên cꢇa các toán hꢓng

ꢀ

Khuyꢅt ñiꢏm : giꢀm khꢀ năng tꢆi ưu code cꢇa trình biên dꢑch

ꢁ Ngôn ngꢂ C trꢀ vꢌ giá trꢑ cꢇa alà 20

14

Cú pháp cꢆa biꢂu thꢇc

ꢀ Dꢓng trung tꢆ (infex)

ꢁ Phꢢ biꢅn và tꢉ nhiên nhꢎt: kí hiꢃu phép toán ñưꢊc viꢅt

giꢂa 2 toán hꢓng

ꢁ VD (A + B) * (C - A)

ꢀ Dꢓng tiꢌn tꢆ (prefix)

ꢁ Kí hiꢃu phép toán ñưꢊc viꢅt trưꢍc các toán hꢓng

ꢁ VD * (+ (A B)) – (C A))

ꢀ Dꢓng hꢐu tꢆ (posfix)

ꢁ Kí hiꢃu phép toán ñưꢊc viꢅt sau các toán hꢓng

ꢁ VD ((A B) +) (C A) -)*

15

Toán tꢉ ña năng hóa (overloaded)

ꢀ Mꢝt toán tꢗ có thꢉc hiꢃn nhiꢌu phép toán → toán

tꢗ ña năng hóa

ꢀ Phép toán + vꢍi kiꢏu sꢆ nguyên và kiꢏu sꢆ thꢉc

ꢀ Phép toán &: lꢎy ñꢑa chꢟ và phép toán And (bit)

ꢁ int x, y, z ;

ꢁ x = &y// trꢀ vꢌ ñꢑa chꢟ ô nhꢍ cꢇa y cho x

ꢁ x = y&z// trꢀ vꢌ giá trꢑ cꢇa phép toán And trên y,z

ꢀ Phép toán *

ꢁ Trꢀ vꢌ trꢑ cꢇa ô nhꢍ mà pointer trꢠ ñꢅn hoꢔc phép toán

nhân

16

Lꢄnh ñiꢁu khiꢂn

ꢀ Ba loꢓi cꢎu trúc ñiꢌu khiꢏn cơ bꢀn

ꢁ Lꢃnh tuꢖn tꢉ

ꢀ

Lꢃnh gán, lꢃnh gꢕi chương trình con

ꢀ

Lꢃnh xuꢎt / nhꢐp

ꢁ Lꢃnh lꢉa chꢕn hay ñiꢌu kiꢃn

ꢁ Lꢃnh lꢔp

ꢀ Lꢃnh rꢚ nhánh không ñiꢌu kiꢃn

17

Lꢄnh lꢈa chꢊn hay ñiꢁu kiꢄn

ꢀ Lꢃnh ñiꢌu kiꢃn là mꢝt lꢃnh biꢏu thꢑ sꢉ lꢉa chꢕn

cꢇa hai hoꢔc ña nhánh ñꢏ thꢉc hiꢃn

ꢀ Chia làm 2 loꢓi

ꢁ Chꢟ có 2 lꢉa chꢕn (lꢃnh IF)

ꢁ Nhiꢌu lꢉa chꢕn (lꢃnh CASE)

18

Lꢄnh lꢈa chꢊn : 2 lꢈa chꢊn

ꢀ Dꢓng phꢢ biꢅn :

if control_expression then clause

else clause

ꢀ Các yꢅu tꢆ trong lꢃnh 2 lꢉa chꢕn

ꢁ Dꢓng và kiꢏu cꢇa biꢏu thꢒc lꢉa chꢕn như thꢅ nào : quan

hꢃ, toán và logic?

ꢁ Các câu lꢃnh gì sau thenvà sau else?

ꢁ Lꢃnh lꢉa chꢕn có lòng nhau hay không?

19

Biꢂu thꢇc lꢈa chꢊn (2 lꢈa chꢊn)

ꢀ ALGOL 60 : chꢟ dùng biꢏu thꢒc logic

if (boolean_expr) then stmt

else stmt

ꢀ C (89 trꢙ vꢌ trưꢍc) : chꢟ dùng biꢏu thꢒc logic

ꢀ C (99) và C++ : biꢏu thꢒc toán và logic

ꢁ VD if(5-3) printf(«A») else printf(«B»);

ꢁ C/C++/Java: if (expr) stmt else stmt

ꢀ Ada, Java và C# chꢟ cho phép dùng biꢏu thꢒc

logic

20

Bài giảng Nguyên lý ngôn ngữ lập trình - Chương 3: Cấu trúc điều khiển - Nguyễn Văn Hòa