Đề cương cơ sở kỹ thuật lập trình

TRƢỜNG ĐẠI HỌC SƢ PHẠM KỸ THUẬT HƢNG YÊN
KHOA CÔNG NGHỆ THÔNG TIN

ĐỀ CƢƠNG

CƠ SỞ KỸ THUẬT LẬP TRÌNH

HƢNG YÊN – 2015


MỤC LỤC
MỤC LỤC ..............................................................................................................2
BÀI 1:

CÁC THÀNH PHẦN CƠ BẢN CỦA NGÔN NGỮ LẬP TRÌNH ........8

1.1

Cấu trúc chung của một chương trình .....................................................8

1.1.1 Cấu trúc của một chương trình ............................................................8
1.1.2 Các bước để tạo và thực hiện một chương trình .................................9
1.1.3 Một số quy tắc cần nhớ khi viết chương trình...................................11
1.2

Các thành phần cơ bản của một ngôn ngữ lập trình .............................. 12

1.2.1 Bảng chữ cái ......................................................................................12
1.2.2 Từ khóa .............................................................................................. 12
1.2.3 Tên (định danh) .................................................................................13
1.3

Các kiểu dữ liệu cơ bản .........................................................................14

1.3.1 Kiểu ký tự ..........................................................................................15
1.3.2 Kiểu số nguyên ..................................................................................16
1.3.3 Kiểu dấu phẩy động ...........................................................................16
1.4

Biến, hằng và cách khai báo ..................................................................17

1.4.1 Biến và cách khai báo ........................................................................17
1.4.2 Hằng và cách khai báo.......................................................................18
BÀI 2:

BIỂU THỨC, CÁC PHÉP TOÁN VÀ VẤN ĐỀ NHẬP XUẤT ..........22

2.1

Biểu thức ................................................................................................ 22

2.2

Câu lệnh, khối lệnh ................................................................................22

2.2.1 Câu lệnh ............................................................................................. 22
2.2.2 Các câu lệnh và các khoảng trắng .....................................................23
2.2.3 Khối lệnh ...........................................................................................24
2.3

Các phép toán.........................................................................................24

Đề cương bài giảng Cơ sở kỹ thuật lập trình
2.3.1 Các phép toán số học .........................................................................24
2.3.2 Phép toán so sánh ..............................................................................25
2.3.3 Phép toán logic ..................................................................................25
2.3.4 Phép gán ............................................................................................ 26
2.3.5 Thứ tự ưu tiên các phép toán ............................................................. 26
2.3.6 Phép chuyển đối kiểu ........................................................................27
2.4

Nhập/xuất dữ liệu...................................................................................30

2.4.1 Xuất dữ liệu .......................................................................................30
2.4.2 Nhập dữ liệu ......................................................................................32
2.5

Bài tập ....................................................................................................33

BÀI 3:

CẤU TRÚC ĐIỀU KHIỂN ...................................................................35

3.1

Giới thiệu về cấu trúc điều khiển ...........................................................35

3.2

Cấu trúc điều khiển rẽ nhánh if.............................................................. 35

3.2.1 Cấu trúc rẽ nhánh dạng khuyết ..........................................................35
3.2.2 Cấu trúc rẽ nhánh dạng đủ.................................................................36
3.3

Cấu trúc điều khiển rẽ nhánh swicth......................................................38

3.4

Bài tập ....................................................................................................41

BÀI 4:

CẤU TRÚC LẶP ...................................................................................43

4.1. Giới thiệu về cấu trúc lặp ...........................................................................43
4.2. Cấu trúc lặp xác định .............................................................................43
4.2.1. Cấu trúc lặp For ..................................................................................43
4.1.2 Ví dụ áp dụng ....................................................................................45
4.3. Cấu trúc lặp không xác định ......................................................................46
4.3.1. Cấu trúc lặp while ...............................................................................46
3


Đề cương bài giảng Cơ sở kỹ thuật lập trình
4.3.2. Cấu trúc lặp do.. while ........................................................................49
4.4. Các câu lệnh đặc biệt .................................................................................52
4.4.1. Câu lệnh break ....................................................................................52
4.4.2. Câu lệnh continue ...............................................................................53
4.5. Bài tập ........................................................................................................53

BÀI 5:

THẢO LUẬN/BÀI TẬP VỀ CÁC CẤU TRÚC LẶP VÀ CẤU TRÚC

ĐIỀU KHIỂN 55
BÀI 6:

MẢNG MỘT CHIỀU ............................................................................59

6.1

Giới thiệu về mảng một chiều................................................................ 59

6.1.1 Khái niệm về mảng một chiều...........................................................60
6.1.2 Cách khai báo ....................................................................................60
6.1.3 Đặc điểm của mảng một chiều ..........................................................61
6.1.4 Cách khởi tạo phần tử cho mảng .......................................................62
6.2

Truy xuất các phần tử trong mảng .........................................................62

6.3

Các thao tác với mảng một chiều...........................................................63

6.3.1 Nhập mảng ........................................................................................63
6.3.2 Hiện mảng .........................................................................................64
6.2

Ví dụ áp dụng .........................................................................................65

BÀI 7:

THỰC HÀNH VỀ CẤU TRÚC ĐIỀU KHIỂN VÀ CẤU TRÚC LẶP 72

BÀI 8:

MẢNG HAI CHIỀU ..............................................................................73

8.1.

Giới thiệu về mảng hai chiều .................................................................73

8.1.1 Định nghĩa .........................................................................................73
8.1.2 Các cách khai báo ..............................................................................74
8.2

Truy xuất các phần tử trong mảng hai chiều .........................................75

8.3

Các thao tác với mảng hai chiều ............................................................ 76
4


Đề cương bài giảng Cơ sở kỹ thuật lập trình
8.3.1 Nhập mảng ........................................................................................76
8.3.2 Hiện mảng .........................................................................................77
8.4

Một số ví dụ về mảng hai chiều ............................................................. 79

BÀI 9:

THỰC HÀNH VỀ MẢNG (BUỔI 1) ....................................................82

BÀI 10:

THẢO LUẬN/BÀI TẬP VỀ MẢNG.................................................83

BÀI 11:

THỰC HÀNH VỀ MẢNG (BUỔI 2) ................................................86

BÀI 12:

THAO TÁC VỚI KÝ TỰ VÀ XÂU KÝ TỰ.....................................87

12.1

Giới thiệu về ký tự và xâu ký tự ............................................................ 87

12.1.1 Sử dụng các biến ký tự ....................................................................88
12.1.2 Mảng của các ký tự .........................................................................89
12.1.3 Khởi tạo các mảng ký tự .................................................................90
12.2

Các thao tác trên xâu ..............................................................................90

12.2.1 Nhập xâu..........................................................................................90

12.2.2 Hiển thị xâu và các ký tự .................................................................93
12.2.3 Một số thư viện hàm sử dụng trên xâu ............................................95
12.3

Bài tập ....................................................................................................96

BÀI 13:

THỰC HÀNH VỀ XỬ LÝ CHUỖI KÝ TỰ......................................98

BÀI 14:

KIỂU CẤU TRÚC VÀ TỆP ............................................................100

14.1

Giới thiệu về kiểu cấu trúc ...................................................................100

14.2

Các thao tác trên biến cấu trúc .............................................................101

14.3

Mảng cấu trúc ......................................................................................102

14.4

Vấn đề vào/ra dữ liệu với tệp ...............................................................102

14.4.1 Khai báo sử dụng tệp: ....................................................................103
14.4.2 Mở tệp - hàm fopen .......................................................................103
5


Đề cương bài giảng Cơ sở kỹ thuật lập trình
14.4.3 Đóng tệp - hàm fclose ...................................................................104
14.4.4 Làm sạch vùng đệm - hàm fflush ..................................................105
14.4.5 Đọc/ghi tệp tin – hàm fprintf() và fscanf() ....................................105
14.5

Bài tập ..................................................................................................106

BÀI 15:

THẢO LUẬN/ BÀI TẬP VỀ KIỂU CẤU TRÚC VÀ TỆP ............108

BÀI 16:

THỰC HÀNH VỀ KIỂU CẤU TRÚC VÀ TỆP .............................111

BÀI 17:

HÀM (2 BUỔI) ................................................................................112

17.1

Giới thiệu chung về hàm ......................................................................112

17.2

Cơ bản về hàm .....................................................................................114

17.2.1 Định nghĩa .....................................................................................114
17.2.2 Cấu trúc của một hàm tự xây dựng như sau: .................................115
17.2.3 Nguyên tắc xây dựng một hàm......................................................119
17.3

Các khái niệm ......................................................................................120

17.3.1 Biến cục bộ ....................................................................................120
17.3.2 Biến toàn cục .................................................................................120
17.3.3 Tham số hình thức .........................................................................120
17.3.4 Tham số thực thụ ...........................................................................121
17.4

Cách gọi hàm .......................................................................................121

17.4.1 Lời gọi hàm ...................................................................................121
17.4.2 Truyền tham số cho hàm ...............................................................122
17.4.3 Đệ qui ............................................................................................122
17.5

Nguyên tắc hoạt động của hàm ............................................................124

17.6

Cấu trúc của một chương trình có nhiều hàm ......................................124

17.7

Bài tập về hàm .....................................................................................125
6


Đề cương bài giảng Cơ sở kỹ thuật lập trình
BÀI 18:

THẢO LUẬN/BÀI TẬP VỀ HÀM .................................................127

BÀI 19:

THỰC HÀNH VỀ HÀM ..................................................................129

BÀI 20:

CON TRỎ VÀ ỨNG DỤNG ...........................................................130

20.1. Giới thiệu về con trỏ ..............................................................................130
20.2. Khai báo và sử dụng con trỏ ..................................................................130
20.2.1. Khai báo con trỏ..............................................................................130
20.2.2. Sử dụng con trỏ ...............................................................................131
20.3. Một số ứng dụng của con trỏ .................................................................133
20.3.1. Con trỏ và mảng một chiều .............................................................133
20.3.2. Con trỏ và mảng hai chiều .............................................................135
20.3.3. Con trỏ và xâu ký tự .......................................................................136
BÀI 21:

THỰC HÀNH VỀ CON TRỎ..........................................................137

BÀI 22:

THẢO LUẬN/BÀI TẬP VỀ CON TRỎ .........................................138

BÀI 23:

KIỂM TRA THỰC HÀNH ..............................................................145

7


Đề cương bài giảng Cơ sở kỹ thuật lập trình

BÀI 1:

CÁC THÀNH PHẦN CƠ BẢN CỦA NGÔN
NGỮ LẬP TRÌNH

MỤC TIÊU
Học xong bài này sinh viên có khả năng:
o Trình bày được cấu trúc chung của một chương trình và các thành phần cơ
bản của ngôn ngữ lập trình;
o Trình bày được đặc điểm, cách sử dụng của các kiểu dữ liệu;
o Trình bày được quy tắc khai báo biến, hằng;
o Sử dụng được các phép toán cơ bản vào bài toán cụ thể;
o Rèn luyện tính tư duy, logic trong lập trình.
1.1

Cấu trúc chung của một chƣơng trình

Ngôn ngữ lập trình là một hệ thống được ký hiệu hóa để miêu tả những tính toán
(qua máy tính) dưới dạng mà cả con người và máy đều có thể đọc và hiểu được.
Như vậy, theo định nghĩa ở trên thì một ngôn ngữ lập trình phải thỏa mãn được
hai điều kiện cơ bản sau:
-

Dễ hiểu và dễ sử dụng đối với người lập trình, để có thể dùng để giải quyết
nhiều bài toán khác nhau.

-

Miêu tả một cách đầy đủ và rõ ràng các tiến trình, để chạy được trên các hệ
máy tính khác nhau.

Một tập hợp các chỉ thị được biểu thị qua ngôn ngữ lập trình nhằm mục đích thực
hiện các thao tác nào đó được gọi là một chương trình. Khái niệm này còn có những
tên khác như chương trình máy tính hay chương trình điện toán.
1.1.1 Cấu trúc của một chƣơng trình
Cấu trúc chung của một chương trình gồm những thành phần chính như sau:

8


Đề cương bài giảng Cơ sở kỹ thuật lập trình
1. Lời gọi các thư viện sẽ sử dụng trong chương trình
2. Khai báo hằng, biến toàn cục
3. Khai báo chương trình con
4. Chương trình chính
Để có cái nhìn tổng quan về cấu trúc của một chương trình, hãy xét ví dụ về
chương trình hiện lên dòng chữ “Hello World” trên màn hình. Trong giới lập trình,

chương trình “Hello World” không quá xa lạ gì, vì đó được xem là một chương trình
đầu tiên và chuẩn nhất cho cái nhìn bao quát về một ngôn ngữ nào đó được đề cập đến.
Nhưng nếu bạn chưa biết gì về lập trình thì cũng nên biết về chương trình này, và sau
này nếu có muốn học một ngôn ngữ khác thì bạn vẫn có thể tìm kiếm một “Hello
World” khác để biết ngôn ngữ đó khai báo như thế nào? bắt đầu ra sao? có khác gì so
với ngôn ngữ mà mình đã biết hay không. Và để có câu trả lời, hãy cùng theo dõi ví dụ
sau. Ví dụ được minh họa trên ngôn ngữ lập trình C:
#include <stdio.h>

/* Lời gọi thư viện Nhập xuất */

#include <conio.h>

/* Lời gọi thư viện xử lý màn hình */

int main()

/* Hàm chính(bắt buộc có) của chương trình*/

{
printf("Hello World!");

/* Xuất ra màn hình dòng chữ Hello
World!*/

getch();
return 0;

/* Đợi người dùng nhập vào 1 phím bất
kỳ rồi mới tiếp tục… */

/* Kết thúc hàm*/

}

1.1.2 Các bƣớc để tạo và thực hiện một chƣơng trình
a)

Qui trình viết và thực hiện chương trình

Trước khi viết và chạy một chương trình thông thường chúng ta cần:
1. Xác định yêu cầu của chương trình: Nghĩa là xác định dữ liệu đầu vào (input)
cung cấp cho chương trình và tập các dữ liệu cần đạt được - tức đầu ra (output). Các
tập hợp dữ liệu này ngoài các tên gọi còn cần xác định kiểu của nó. Ví dụ để giải một
9


Đề cương bài giảng Cơ sở kỹ thuật lập trình
phương trình bậc 2 dạng: ax2 + bx + c = 0, cần báo cho chương trình biết dữ liệu đầu
vào là a, b, c và đầu ra là nghiệm x1 và x2 của phương trình. Kiểu của a, b, c, x1, x2 là
các số thực.
2. Xác định thuật toán giải.
3. Cụ thể hoá các khai báo kiểu và thuật toán thành dãy các lệnh, tức viết thành
chương trình thông thường là trên giấy, sau đó bắt đầu soạn thảo vào trong máy. Quá
trình này được gọi là soạn thảo chương trình nguồn.
4. Dịch chương trình nguồn để tìm và sửa các lỗi gọi là lỗi cú pháp.
5. Chạy chương trình, kiểm tra kết quả in ra trên màn hình. Nếu sai, sửa lại
chương trình, dịch và chạy lại để kiểm tra. Quá trình này được thực hiện lặp đi lặp lại
cho đến khi chương trình chạy tốt theo yêu cầu đề ra của lập trình.
b)

Soạn thảo tệp chương trình nguồn

Soạn thảo chương trình nguồn là một công việc đơn giản: gõ nội dung của
chương trình (đã viết ra giấy) vào trong máy và lưu lại nó lên đĩa. Thông thường khi
đã lưu lại chương trình lên đĩa lần sau sẽ không cần phải gõ lại. Mục đích của soạn
thảo là tạo ra một văn bản chương trình và đưa vào bộ nhớ của máy. Văn bản chương
trình cần được trình bày sáng sủa, rõ ràng. Các câu lệnh cần gióng thẳng cột theo cấu
trúc của lệnh (các lệnh chứa trong một lệnh cấu trúc được trình bày thụt vào trong so
với điểm bắt đầu của lệnh). Các chú thích nên ghi ngắn gọn, rõ nghĩa và phù hợp.
c)

Dịch chương trình

Sau khi đã soạn thảo xong chương trình nguồn, bước tiếp theo thường là dịch
(trong C ấn phím F11 hoặc chọn Build/ compile) để tìm và sửa các lỗi gọi là lỗi cú
pháp. Trong khi dịch chương trình sẽ đưa ra thông báo lỗi và chỉ ra nơi gây lỗi. Để
chương trình có thể chạy được thì người lập trình phải sửa hết những lỗi đó. Quá trình
dịch và sửa lỗi cứ diễn ra cho đến khi nào chương trình không còn lỗi và đưa ra thông
báo dịch thành công. Sản phẩm sau khi dịch là một tệp mới gọi là chương trình đích có
đuôi EXE tức là tệp mã máy để thực hiện. Tệp này có thể lưu tạm thời trong bộ nhớ
phục vụ cho quá trình chạy chương trình hoặc lưu lại trên đĩa tuỳ theo tuỳ chọn khi
dịch của lập trình.
10


Đề cương bài giảng Cơ sở kỹ thuật lập trình
d)

Chạy chương trình

Để chạy chương trình, trong C ấn phím F5 hoặc chọn Build/ Run, nếu chương
trình chưa dịch sang mã máy, máy sẽ tự động dịch lại trước khi chạy. Kết quả của
chương trình sẽ hiện ra trong một cửa sổ kết quả để người lập trình kiểm tra. Nếu kết
quả chưa được như mong muốn thì quay lại văn bản để sửa và lại chạy lại chương
trình. Quá trình này được lặp lại cho đến khi chương trình chạy đúng như yêu cầu đã
đề ra. Khi chương trình chạy, cửa sổ kết quả sẽ hiện ra tạm thời che khuất cửa sổ soạn
thảo. Sau khi kết thúc chạy chương trình cửa sổ soạn thảo sẽ tự động hiện ra trở lại và
che khuất cửa sổ kết quả.

1.1.3 Một số quy tắc cần nhớ khi viết chƣơng trình
a)

Quy tắc 1:

Mỗi câu lệnh có thể viết trên một hay nhiều dòng nhưng phải kết thúc bằng dấu
chấm phẩy (;)
b)

Quy tắc 2:

Có 2 cách ghi chú thích trong chương trình:
-

Cách 1: Các lời giải thích cần đặt giữa các dấu /* và */ và có thể được viết:
 Trên một dòng
 Trên nhiều dòng
 Trên phần còn lại của dòng

-

c)

Cách 2: Các lời chú thích đặt sau dấu // thường được dùng khi lời chú thích
được viết trên 1 dòng.
Quy tắc 3:

Trong chương trình, khi ta sử dụng các hàm chuẩn, ví dụ như getch() mà hàm
này lại được chứa trong file conio.h trong thư mục của C, vì vậy ở đầu chương trình ta
phải khai báo sử dụng:
#include <conio.h>
d)

Quy tắc 4:
11


Đề cương bài giảng Cơ sở kỹ thuật lập trình
Một chương trình có thể chỉ có một hàm chính (hàm main()) hoặc có thể có thêm
vài hàm khác nữa.
1.2

Các thành phần cơ bản của một ngôn ngữ lập trình

1.2.1 Bảng chữ cái
Mọi ngôn ngữ lập trình đều được xây dựng từ một bộ ký tự nào đó. Các ký tự
được nhóm lại theo nhiều cách khác nhau để tạo nên các từ. Các từ lại đươc liên kết
với nhau theo một quy tắc nào đó để tạo nên các câu lệnh. Một chương trình bao gồm
nhiều câu lệnh thể hiện một thuật toán để giải một bài toán cụ thể. Hầu hết các ngôn
ngữ lập trình đều được xây dựng trên bộ ký tự sau:
26 chứ cái hoa: A, B, C,….Z

26 chữ cái thường: a,b,c,….z
10 chữ số: 0,1,2…0
Các ký hiệu toán học như: + - * / = ( )
Ký tự gạch nối: _ (chú ý phân biệt với dấu - )
Các ký hiệu đặc biệt khác như: . , ; [] {} ? ! \ & | % # $ ….
Dấu cách (space) thực sự là một khoảng trống để tách các từ. Ví dụ HUNG YEN
gồm 8 ký tự, còn HUNGYEN gồm 7 ký tự.
 Chú ý: Khi viết chương trình ta không được sử dụng bất kỳ ký hiệu nào khác ngoài
tập các ký tự nói trên.
Chẳng hạn, khi giải phương trình bậc hai:
ax2 + bx + c = 0
ta cần tính biệt thức:
∆ = b2 - 4ac
Ký tự ∆ không cho phép dùng trong ngôn ngữ C, vì vậy ta phải dùng một ký hiệu
khác để thay thế như là d hoặc delta…
1.2.2 Từ khóa
Từ khóa trong ngôn ngữ lập trình là các từ hay ký hiệu mà đã được ngôn ngữ đó
gán cho một ý nghĩa xác định. Người lập trình sẽ không được phép dùng lại các từ
khóa này dưới một ý nghĩa khác. Thường các từ khóa này được ngôn ngữ xác định
12


Đề cương bài giảng Cơ sở kỹ thuật lập trình
dùng trong các kiểu dữ liệu cơ bản hay trong các dòng điều khiển. Ví dụ một số từ
khóa thường sử dụng trong ngôn ngữ C:
break

case

Char

continue

default

double

else

Float

for

goto

if

int

Long

return

short

static

struct

switch

typedef

unsigned

void

while
Ý nghĩa và cách sử dụng của chúng sẽ được lần lượt giới thiệu ở các mục sau. Ở

đây ta chỉ cần nhớ hai trường hợp:
-

Không được dùng từ khóa để đặt tên cho các hằng, biến, mảng, hàm,…

-

Từ khóa phải được viết bằng chữ thường. Chẳng hạn, không được viết
BREAK mà phải viết là break.

1.2.3 Tên (định danh)
Tên (định danh) được dùng để xác định các đối tượng khác nhau trong một
chương trình. Chúng ta có tên hằng, tên biến, tên mảng, tên con trỏ, tên tệp, tên
nhãn,…
Trong ngôn ngữ C, khi đặt tên phải tuân thủ theo quy tắc sau:
-

Không chứa dấu cách

-

Không bắt đầu bằng số

-

Không chứa các ký tự đặc biệt (như: % ? / + =,…)

-

Không trùng với từ khóa, kiểu dữ liệu

Ví dụ 1.1: Cách đặt tên đúng:
sinh_vien;

gptb_2;

Ví dụ 1.2: Cách đặt tên sai:
4abc_3; // ký tự đầu tiên là số
abc#3; //sử dụng ký tự
13


Đề cương bài giảng Cơ sở kỹ thuật lập trình
f(x); //sử dụng các dấu ngoặc tròn
int; //trùng với từ khóa
del ta; //sử dụng khoảng trống
A-1; //sử dụng dấu gạch ngang

 Chú ý: Trong C, với các tên thì chữ hoa và chữ thường được xem là khác nhau,
như vậy tên HocSinh và hocsinh là khác nhau. Thường dùng chữ hoa để đặt tên cho

các hằng và dùng chữ thường để đặt tên cho hầu hết các đối tượng khác như biến,
hằng, mảng, hàm, cấu trúc. Tuy nhiên, đây không phải là điều bắt buộc.
Các kiểu dữ liệu cơ bản

1.3

Thông thường, dữ liệu hay dùng là số và chữ. Tuy nhiên việc phân chia chỉ 2 loại
dữ liệu là không đủ. Để dễ dàng hơn cho việc lập trình, hầu hết các ngôn ngữ lập trình
đều phân chia dữ liệu thành nhiều kiểu khác nhau được gọi là các kiểu cơ bản hay
chuẩn. Trên cơ sở kết hợp các kiểu dữ liệu chuẩn, người sử dụng có thể tự đặt ra các
kiểu dữ liệu mới để phục vụ cho chương trình giải quyết bài toán của mình. Có nghĩa
lúc đó mỗi đối tượng được quản lý trong chương trình sẽ là một tập hợp nhiều thông
tin hơn và được tạo thành từ nhiều loại (kiểu) dữ liệu khác nhau.
Tất cả các biến cần phải được khai báo trước khi sử dụng và kiểu của chúng phải
được mô tả ngay khi khai báo. Việc khai báo này sẽ làm chương trình quản lý các biến
dễ dàng hơn như trong việc phân bố bộ nhớ cũng như quản lý các tính toán trên biến
theo nguyên tắc: chỉ có các dữ liệu cùng kiểu với nhau mới được phép làm toán với
nhau. Do đó, khi đề cập đến một kiểu chuẩn của một ngôn ngữ lập trình, thông thường
chúng ta sẽ xét đến các yếu tố sau:
-

Tên kiểu: là một từ dành riêng để chỉ định kiểu của dữ liệu.

-

Số byte trong bộ nhớ để lưu trữ một đơn vị dữ liệu thuộc kiểu này: Thông
thường số byte này phụ thuộc vào các trình biên dịch và hệ thống máy khác
nhau, ở đây ta chỉ xét đến hệ thống máy PC thông dụng hiện nay.

-

Miền giá trị của kiểu: Cho biết một đơn vị dữ liệu thuộc kiểu này sẽ có thể lấy
giá trị trong miền nào, ví dụ nhỏ nhất và lớn nhất là bao nhiêu. Hiển nhiên các
giá trị này phụ thuộc vào số byte mà hệ thống máy qui định cho từng kiểu.
14


Đề cương bài giảng Cơ sở kỹ thuật lập trình
Người sử dụng cần nhớ đến miền giá trị này để khai báo kiểu cho các biến cần
sử dụng một cách thích hợp.
Dưới đây sẽ lần lượt trình bày về 3 kiểu dữ liệu đơn giản chuẩn và thông dụng:
Kiểu ký tự, kiểu nguyên, kiểu dấu phẩy động.

1.3.1 Kiểu ký tự
Một giá trị kiểu ký tự chiếm 1 byte (8 bit) và biểu diễn được một ký tự thông qua
bảng mã ASCII. Ví dụ:
Ký tự

Mã ASCII

0

048

1

049

2

050

A

065

B

066

A

097

B

098

Trong C, có hai kiểu ký tự là signed char và unsigned char. Kiểu thứ nhất biểu
diễn một số nguyên từ -128 đến 127, kiểu thứ hai có giá trị từ 0 đến 255. Bảng dưới
đây cho kích cỡ và phạm vi biểu diễn của giá trị kiểu char.
Kiểu

Phạm vi biểu diễn

Số ký tự

Kích thƣớc (byte)

unsigned char

0 ->255

256

1

Char

-128 ->127

256

1

Phân loại ký tự: Có thể chia 256 ký tự thành 3 nhóm:
-

Nhóm thứ nhất là các ký tự điều khiển có mã từ 0 đến 31. Chẳng hạn ký tự mã
13 dùng để chuyển con trỏ về đầu dòng, ký tự 10 chuyển con trỏ xuống dòng
dưới (trên cùng cột). Các ký tự nhóm này nói chung không hiển thị ra màn
hình.

-

Nhóm thứ hai là các ký tự văn bản có mã từ 32 đến 126. Các ký tự này có thể
đưa ra màn hình và máy in.
15

Đề cương bài giảng Cơ sở kỹ thuật lập trình
-

Nhóm thứ ba là các ký tự đồ họa có mã từ 127 đến 255. Các ký tự này có thể
đưa ra màn hình nhưng không in được.

1.3.2 Kiểu số nguyên
Kiểu số nguyên là kiểu dữ liệu dùng để lưu các giá trị nguyên hay còn gọi là kiểu
đếm được. Kiểu số nguyên trong C được chia thành các kiểu dữ liệu con, mỗi kiểu có
một miền giá trị khác nhau.
Trong C cho phép sử dụng: số nguyên (int), số nguyên dài (long) và số nguyên
không dấu (unsigned). Kích cỡ và phạm vi biểu diễn của chúng được chỉ ra trong bảng
dưới đây:
Kiểu

Phạm vi biểu diễn

Kích thƣớc (byte)

unsigned int

0 -> 65535

2

int

-32768 -> 32767

2

unsigned long [int]

0 -> 4.294967295

4

long [int]

-2147483648 -> 2147483648

4

 Lƣu ý:
Kiểu long int có thể viết gọn thành long, kiểu unsigned int viết gọn thành
unsigned.
Có thế kết hợp nhiều tiền tố với một kiểu dữ liệu cơ sở, chẳng hạn unsigned long
int viết gọn thành unsigned long.
1.3.3 Kiểu dấu phẩy động
Kiểu dấu phẩy động biểu diễn cho các số thập phân có dấu.
Trong C cho phép sử dụng 3 loại giá trị dấu phẩy động là float, double và long
double. Kích cỡ và phạm vi biểu diễn của chúng được chỉ ra trong bảng dưới đây:
Kiểu

Phạm vi biểu diễn

Kích thƣớc (byte)

float

3.4E-38 -> 3.4E+38

4

double

1.7E-308 -> 1.7E+308

8

long double

3.4E4932 -> 3.4E+4932

10

16


Đề cương bài giảng Cơ sở kỹ thuật lập trình
Máy tính có thể lưu trữ được số kiểu float có giá trị tuyệt đối từ 3.4E-38 đến
3.4E+38. Số có giá trị tuyệt đối nhỏ hơn 3.4E-38 được xem bằng 0. Phạm vi biểu diễn
của số double cũng được hiểu theo nghĩa tương tự.
1.4

Biến, hằng và cách khai báo

1.4.1 Biến và cách khai báo
Một biến là một tên gọi cho một đại lượng hoặc một đối tượng nào đó. Mỗi biến
đều được phân bổ một địa chỉ trong bộ nhớ dùng để lưu giữ giá trị của biến. Giá trị này

có thể thay đổi trong khi chương trình thực hiện. Trong C, một biến chỉ có thể được sử
dụng sau khi đã được khai báo. Một khai báo biến cho chương trình dịch biết tên của
biến và kiểu của dữ liệu mà nó lưu giữ.
a)

Khai báo

Quy tắc khai báo:
Kiểu_dữ_liệu  Danh_sách_tên_biến;
Danh sách tên biến: Gồm các tên biến có cùng kiểu dữ liệu, mỗi tên biến được
phân cách nhau bằng dấu phẩy(,), cuối cùng là dấu chấm phẩy (;).
Ví dụ 1.3:
int a;

/* Khai báo biến a kiểu int */

long ax, bx, cx;

/* Khai báo ba biến kiểu long */

char beta, alpha;

/* Khai báo hai biến kiểu char */

float x,y;

/* Khai báo hai biến kiểu float */

double x,y;

/* Khai báo hai biến kiểu double */

Biến kiểu int chỉ nhận được các giá trị kiểu int. Các biến khác nhau cũng có ý
nghĩa tương tự, chẳng hạn biến kiểu char chỉ chứa được một ký tự. Để lưu trữ một xâu
ký tự cần sử dụng một mảng kiểu char.
b)

Khởi tạo cho các biến

Khi khai báo biến, giá trị của nó mặc nhiên là không xác định. Nhưng có thể bạn
sẽ muốn nó mang một giá trị xác định khi được khai báo. Để làm điều đó, bạn chỉ cần
17


Đề cương bài giảng Cơ sở kỹ thuật lập trình
viết dấu bằng và giá trị bạn muốn biến đó sẽ mang. Chúng ta có thể kết hợp việc khai
báo với toán tử gán để biến nhận ngay giá trị cùng lúc với khai báo:
 Khai báo trước, gán giá trị sau:
Kiểu_dữ_liệu  Tên_biến;
Tên_biến = Giá_trị_khởi_tạo;
Ví dụ 1.4:
int a,b,c;

/* Khai báo các biến a,b,c kiểu int */

char ch;

/* Khai báo biến ch kiểu char */

a=0; b=15; c=21; ch=’A’;

/* Khởi tạo giá trị cho các biến */

 Vừa khai báo, vừa gán giá trị
Kiểu_dữ_liệu  Tên_biến = Giá_trị_khởi_tạo;
Ví dụ 1.6:
int a=0,b=15,c=21; /* Khai báo, đồng thời khởi tạo giá trị cho các biến */
char ch=’A’;

1.4.2 Hằng và cách khai báo
Hằng cũng là một biến nhưng giá trị của hằng không thay đổi. Tuy nhiên khi làm
việc với một giá trị được định nghĩa là không thay đổi, ta phải đảm bảo giá trị của nó
không được thay đổi trong suốt chương trình nên khi đó sử dụng biến sẽ không thích
hợp. Chẳng hạn, khi lập một chương trình thí nghiệm hóa học liên quan đến nhiệt độ
sôi hay nhiệt độ đông của nước, chương trình cần khai báo hai biến là DoSoi và
DoDong, nhưng không cho phép giá trị của hai biến này bị thay đổi hay bị gán. Để
ngăn việc gán giá trị khác, ta phải sử dụng biến kiểu hằng.
a)

Cách khai báo hằng

Hằng có thể định nghĩa bằng hai cách:
Cách 1: Dùng toán tử #define nhằm định nghĩa một hằng, ký hiệu
#define <Tenhang>  <Xaukytu>
18


Đề cương bài giảng Cơ sở kỹ thuật lập trình
Cấu trúc này định nghĩa một hằng ký hiệu có tên <Tenhang> bằng <Xaukytu>.
Khi biên dịch chương trình, chương trình dịch thay thế các lần xuất hiện của

<Tenhang> bằng xâu ký tự tương ứng, ví dụ: #define MAX 100
Cách 2: const  kieu_du_kieu  ten_hang = gia_tri_hang;
const int n=20;
b)

Một số loại hằng cơ bản
 Hằng số nguyên(int)
- Hệ thập phân bình thường, ví dụ: 545
- Hệ cơ số 8 (Octal): Bắt đầu bằng số 0 và chỉ biểu diễn số dương, ví dụ:
024=2010
- Hệ cơ số 16 (Hecxa)
Bắt đầu bằng 0x, ví dụ: 0xAB = 16310

 Chú ý: Nếu là hằng kiểu long thì thêm l (hay L) vào đuôi, ví dụ: 123L, 858L
Một hằng số nguyên có giá trị vượt ra ngoài phạm vi cho phép được ngầm hiểu là
hằng long.
 Hằng số thực
Được viết theo hai cách sau:
- Dạng thập phân gồm: Phần nguyên, dấu chấm thập phân, phần thập
phân, ví dụ: 34.2
-344.122
 Chú ý: Phần nguyên hay phần thập phân có thể vắng mặt nhưng dấu chấm thập
phân không được thiếu, ví dụ: 343.
.454
- Dạng khoa học(dạng mũ) gồm: Phần định trị và phần mũ. Phần định trị
là số nguyên hay số thực dạng thập phân, phần mũ bắt đầu bằng E hoặc e theo
sau là số nguyên, ví dụ: 1234.54E-122
 Hằng ký tự
Là một ký hiệu trong bảng mã ASCII được đặt trong hai dấu nháy đơn. Giá trị
của hằng kí tự chính là mã ASCII của kí hiệu, ví dụ: Hằng „A‟ có giá trị là 65.

19


Đề cương bài giảng Cơ sở kỹ thuật lập trình
 Chú ý: Hằng ký tự biểu thị mã của ký tự đó trong bảng mã ASCII. Do vậy một
hằng ký tự cũng có thể tham gia vào các phép toán, ví dụ: „A‟+10 có giá trị
(65+10=75).
Hằng ký tự còn có thể được viết theo cách: „\c1c2c3‟
Trong đó, c1c2c3 là một số hệ 8 mà giá trị của nó chính là mã ASCII của ký tự
cần biểu diễn, ví dụ: „a‟

hay

„\141‟

Một số ký tự đặc biệt:
Viết

Ký tự

Diễn giải

\‟

„

Dấu nháy đơn

\”

“

Dấu nháy kép

\\

\

Dấu gạch chéo ngược

\n

\n

Xuống dòng mới

\0

\0

Ký tự null

\t

Nhảy cách ngang, ký tự tab

\b

Xoá trái

\r

Về đầu dòng

\f

Sang trang

 Hằng xâu ký tự
- Là một dãy các ký tự đặt trong hay dấu nháy “......”
- Xâu ký được lưu trữ trong một mảng ô nhớ liền nhau song còn thêm ô nhớ cuối
cùng chứa mã là 0 (ký hiệu là „\0‟ )
Ví dụ 1.6: Xâu ký tự: “Nguyen Van Anh”
Được tổ chức trong bộ nhớ như sau:
N g

u

y

e

n

V a

n

A n

h

\0

 Chú ý: Chúng ta cần phân biệt “A” và „A‟. Trong đó “A” được chứa trong 2 byte,
còn „A‟ chỉ mất 1 byte và nó có thể tham gia tính toán trong các biểu thức.

20


Đề cương bài giảng Cơ sở kỹ thuật lập trình

TÓM TẮT
 Cấu trúc chung của một chương trình
 Các thành phần cơ bản của một ngôn ngữ lập trình: Bảng chữ cái, từ khóa,
tên.
 Các kiểu dữ liệu cơ bản
 Biến, hằng và cách khai báo

21


Đề cương bài giảng Cơ sở kỹ thuật lập trình

BÀI 2:

BIỂU THỨC, CÁC PHÉP TOÁN VÀ VẤN ĐỀ
NHẬP XUẤT

MỤC TIÊU
Học xong bài này sinh viên có khả năng:
o Phân biệt được câu lệnh và khối lệnh
o Sử dụng được các phép toán cơ bản trong C vào bài toán cụ thể
o Viết được câu lệnh nhập/xuất dữ liệu
o Rèn luyện tính cẩn thận và tư duy sáng tạo trong lập trình.
2.1

Biểu thức
Biểu thức là một sự kết hợp giữa các phép toán và các toán hạng để diễn đạt một

công thức nào đó. Các toán hạng có thể là một đại lượng nào đó có giá trị như: hằng,
biến hay một biểu thức con. Mỗi biểu thức có một giá trị, tùy theo giá trị của biểu thức
mà có các biểu thức nguyên hay biểu thức thực. Các mệnh đề logic có giá trị nguyên
trong đó có giá trị khác 0 tương ứng mệnh đề đúng, còn giá trị 0 tương ứng mệnh đề
sai. Biểu thức được sử dụng trong: Vế phải của lệnh gán; làm tham số thực của các
hàm; làm chỉ số; các câu lệnh if, for, while, do while; các biểu thức lớn hơn của các
hàm; làm chỉ số; các câu lệnh if, for, while, do while; các biểu thức lớn hơn..
Trong C, một biểu thức là một mệnh đề dùng để tính ra một giá trị nào đó. Các
biểu thức C có thể có độ phức tạp tùy ý.
2.2

Câu lệnh, khối lệnh

2.2.1 Câu lệnh
Một câu lệnh là một phương hướng hành động hướng dẫn cho máy tính thực hiện
một nhiệm vụ nào đó. Mỗi câu lệnh được viết trên một dòng, nhưng cũng có những
câu lệnh phải viết trên nhiều dòng. Mỗi câu lệnh được kết thúc bằng dấu chấm phẩy (;)
(trừ các chỉ thị, chẳng hạn như #include và #define). Ngăn cách này chỉ đơn giản

22


Đề cương bài giảng Cơ sở kỹ thuật lập trình
là chỉ cho ngôn ngữ lập trình biết rằng, đã kết thúc một câu lệnh và có thể chuyển qua
câu lệnh mới.
Ví dụ 2.1:
char ten[30];// đây là một câu lệnh
printf(“Nhap vao ten cua ban:”);
scanf(“%s”, ten);
printf(“Chao ban%s”, ten);

2.2.2 Các câu lệnh và các khoảng trắng
Thuật ngữ khoảng trắng (whitespace) là để chỉ các dấu cách, tabs và các dòng
rỗng trong chương trình gốc. Chương trình dịch C không xét đến các khoảng trắng.
Khi chương trình dịch đọc một câu lệnh trong một chương trình gốc, nó sẽ đọc tất cả
các ký tự trong câu lệnh này cho đến khi gặp dấu chấm phẩy nhưng bỏ qua tất cả các
khoảng trắng. Vì vậy, câu lệnh x=2+3; trên đây là hoàn toàn tương đương với
x = 2

+ 3;

và với
x

=

3

;

2
+

Mỗi câu lệnh nên viết trên một dòng và nên có một dấu cách đứng trước và một
dấu cách đứng sau mỗi tên biến. Trước và sau mỗi khối nên có một dòng trống để dễ
nhận biết từng khối một. Ngoài ra, có thể dùng tabs để đẩy một khối thụt vào so với lề
trái nhằm tạo ra một cấu trúc có tính phân cấp trong chương trình.
Tuy nhiên, trong một xâu các ký tự thì các dấu cách và các dấu tabs lại không bị
bỏ qua, chúng được coi là một bộ phận của xâu ký tự này. Một xâu là một dãy các ký
tự. Các hằng ký tự thực sự là các xâu được đặt trong các dấu nháy và được chương
trình dịch xử lý từng ký tự một.

23


Đề cương bài giảng Cơ sở kỹ thuật lập trình
Nếu chỉ có đúng một dấu chấm phẩy trên một dòng nào đó, thì dòng này được
gọi là câu lệnh rỗng. Câu lệnh rỗng không thực hiện bất kỳ hành động nào.

2.2.3 Khối lệnh
Khối lệnh là một tập hợp gồm hai hay nhiều câu lệnh với nhau và được đặt trong
cặp dấu { }.
Ví dụ 2.2:
{ // đây là đầu khối lệnh
char ten[30];
printf(“Nhap vao ten cua ban:”);
scanf(“%s”, ten);
printf(“Chao ban %s”, ten);

} // đây là cuối khối lệnh
2.3

Các phép toán

2.3.1 Các phép toán số học
STT

Phép toán

Ý nghĩa

Ví dụ

Kết quả

1

-

Phép đổi dấu

-(10+2)

-12

2

+

Phép cộng

3+12

15

3

-

Phép trừ

7-2

5

4

*

Phép nhân

2*3

6

5

/

Phép chia

6/3

2

6

%

Phép lấy phần dư

a = 6%4

2

 Chú ý:
- Nếu phép chia hai toán hạng đều nguyên thì phép chia cho kết quả là phần
nguyên của thương hai toán hạng đó, ví dụ: 5/2=2
- Nếu một trong hai toán hạng là kiểu thực thì lúc này kết quả của phép chia cho
ta giá trị đúng, ví dụ 5/2.0=2.5
24


Đề cương bài giảng Cơ sở kỹ thuật lập trình
2.3.2 Phép toán so sánh
Phép toán so sánh được dùng để so sánh giữa hai giá trị, và sau đó trả về kết quả
là một giá trị kiểu bool (true hay false). Ví dụ toán tử so sánh lớn hơn (>) trả về giá trị
là true nếu giá trị bên trái của toán tử lớn hơn giá trị bên phải của toán tử. Do vậy 5 > 2
trả về một giá trị là true, trong khi 2 > 5 trả về giá trị false.

STT

Phép toán

1

>

2

ý nghĩa

Ví dụ

Kết quả

So sánh lớn hơn

1>2

false

>=

So sánh lớn hơn hoặc bằng

2>=2

true

3

<

So sánh nhỏ hơn

3<3

false

4

<=

So sánh nhỏ hơn hoặc bằng

4<2

false

5

==

So sánh bằng nhau

4==5

false

6

!=

So sánh không bằng nhau

2!=7

true

2.3.3 Phép toán logic
Các phép toán logic cũng trả ra giá trị kiểu bool (true hay false).
STT

Phép toán

Ý nghĩa

Ví dụ

Kết quả

1

!

Phép phủ định một ngôi (not)

!(3>1)

false

&&

Liên kết hai biểu thức logic
Phép và (and). Giá trị bằng 1
khi cả 2 toán hạng có giá trị 1

(2>1)&&(5=2)

false

||

Liên kết hai biểu thức logic.
Phép hoặc (or). Giá trị biểu
thức bằng 1 khi một trong hai
toán hạng bằng 1

(4>3)||(1>8)

true

2

3

Bảng giá trị của các phép toán logic:
X

Y

X && Y

X || Y

!X

true

true

true

true

false

true

false

false

true

false

false

true

false

true

true
25