Giáo trình Lập trình cơ bản (Nghề Lập trình máy tính)

BỘ NÔNG NGHIỆP VÀ PHÁT TRIỂN NÔNG THÔNG
TRƯỜNG CAO ĐẲNG CƠ GIỚI NINH BÌNH

GIÁO TRÌNH
MƠN HỌC: MH 11_LẬP TRÌNH CĂN BẢN
NGHỀ: LẬP TRÌNH MÁY TÍNH
TRÌNH ĐỘ: CAO ĐẲNG NGHỀ/ TRUNG CẤP NGHỀ
Ban hành kèm theo Quyết định số:
/QĐ-… ngày…….tháng….năm ......... …………
của……………………………….

Ninh Bình, năm 2016

1


MỤC LỤC
TRANG
LỜI GIỚI THIỆU.............................................................................................................................3
MƠN HỌC LẬP TRÌNH CĂN BẢN...............................................................................................4
Chương 1. THUẬT TỐN...............................................................................................................6
1.Ví dụ..............................................................................................................................................6
2. Khái niệm.....................................................................................................................................6
3. Các đặc trưng của thuật toán:.......................................................................................................8
4. Các phương pháp biểu diễn thuật toán.........................................................................................8
CHƯƠNG 2: GIỚI THIỆU NGƠN NGỮ LẬP TRÌNH C++........................................................11
2. Đặc điểm.....................................................................................................................................11
3. Cấu trúc một chương trình C++..................................................................................................12
4. Một số ví dụ mẫu........................................................................................................................13
5. Cài đặt chương trình...................................................................................................................14
6. Khởi động chương trình..............................................................................................................15

7. Soạn thảo chương trình...............................................................................................................15
8. Thốt khỏi chương trình.............................................................................................................15
CHƯƠNG 3: CÁC THÀNH PHẦN VÀ CÁC KIỂU DỮ LIỆU CƠ BẢN...................................17
1. Các thành phần...........................................................................................................................17
2. Các kiểu dữ liệu căn bản.............................................................................................................22
3. Hằng............................................................................................................................................25
4. Các phép toán của C++...............................................................................................................28
5. Xuất nhập dữ liệu........................................................................................................................34
CHƯƠNG 4: CÁC CẤU TRÚC ĐIỀU KHIỂN.............................................................................40
1. Lệnh đơn và lệnh phức...............................................................................................................40
2. Cấu trúc điều kiện if…else.........................................................................................................40
3. Cấu trúc lựa chọn switch … case...............................................................................................42
4. Các cấu trúc lặp..........................................................................................................................44
5. Câu lệnh break, continue, goto và hàm exit...............................................................................55
CHƯƠNG 5: HÀM........................................................................................................................58
1. Khái niệm...................................................................................................................................58
2. Khai báo hàm..............................................................................................................................58
3. Kết quả trả về của hàm – lệnh return..........................................................................................62
4. Cách truyền tham số cho hàm.....................................................................................................62
5. Đệ qui.........................................................................................................................................69
CHƯƠNG 6: MẢNG (ARRAY)....................................................................................................72
1. Khái niệm...................................................................................................................................73
2. Khai báo mảng............................................................................................................................73
4. Dùng mảng làm tham số.............................................................................................................89
CHƯƠNG 7: CON TRỎ (POINTER)............................................................................................99
1. Khái niệm.................................................................................................................................100
2. Toán tử (&)...............................................................................................................................100
3. Toán tử (*)................................................................................................................................100
4. Khai báo biến kiểu con trỏ........................................................................................................100
5. Các phép toán...........................................................................................................................101

6. Con trỏ hằng.............................................................................................................................101
7. Con trỏ mảng............................................................................................................................101
2


8. Khởi tạo con trỏ........................................................................................................................102
9. Con trỏ tới con trỏ.....................................................................................................................103
10. Con trỏ không kiểu.................................................................................................................103
11. Con trỏ hàm............................................................................................................................104
CHƯƠNG 8: CẤU TRÚC (STRUCTURE).................................................................................106
1. Khái niệm cấu trúc....................................................................................................................107
2. Khai báo cấu trúc......................................................................................................................107
3. Truy nhập đến các thành phần của cấu trúc..............................................................................109
4. Ví dụ cấu trúc............................................................................................................................113

LỜI GIỚI THIỆU
3


Giáo Trình Lập trình căn bản C++ được biên soạn nhằm đáp ứng yêu cầu học
tập của sinh viên bước đầu làm quen với cơng việc lập trình, đồng thời giúp cho
sinh viên có một tài liệu học tập, rèn luyện tốt khả năng lập trình, tạo nền tảng vững
chắc cho các mơn học tiếp theo .
Giáo trình khơng chỉ phù hợp cho người mới bắt đầu mà còn phù hợp cho
những người cần tham khảo. Nội dung của giáo trình được chia thành 6 chương:
Chương 1: Làm quen ngơn ngữ lập trình
Chương 2: Các thành phần trong ngơn ngữ lập trình
Chương 3: Các cấu trúc điều khiển
Chương 4: Hàm và thủ tục
Chương 5: Dữ liệu kiểu tập hợp, mảng và bản ghi

Chương 6: Dữ liệu kiểu chuỗi
Khi biên soạn, chúng tơi đã tham khảo các giáo trình và tài liệu giảng dạy môn
học này của một số trường Cao đẳng, Đại học để giáo trình vừa đạt yêu cầu về nội
dung vừa thích hợp với đối tượng là sinh viên của các trường Cao đẳng Nghề.
Chúng tôi hy vọng sớm nhận được những ý kiến đóng góp, phê bình của bạn
đọc về nội dung, chất lượng và hình thức trình bày để giáo trình này ngày một hồn
thiện hơn.

MƠN HỌC LẬP TRÌNH CĂN BẢN
4


Mã mơn học: MH05
Vị trí, tính chất, ý nghĩa và vai trị của mơn học:
Vị trí:
Mơn học được bố trí sau khi học xong các môn cơ sở phương pháp tính tốn, soạn thảo văn
bản, trước các mơn học/ mơ đun đào tạo chun mơn nghề.
Tính chất:
Là mơn học lý thuyết cơ sở.
Mục tiêu của mơn học:
Trích trong chương trình đào tạo đã được xây dựng của môn học tương ứng và cụ thể hóa
cho phù hợp nội dung giáo trình.
- Trình bày được khái niệm về lập máy tính;
- Mơ tả được ngơn ngữ lập trình: cú pháp, cơng dụng của các câu lệnh;
- Phân tích được chương trình: xác định nhiệm vụ chương trình;
- Thực hiện được các thao tác trong môi trường phát triển phần mềm: biên tập
chương trình, sử dụng các cơng cụ, điều khiển, thực đơn lệnh trợ giúp, gỡ rối, bẫy lỗi,v.v.;
- Viết chương trình và thực hiện chương trình trong máy tính.
- Bố trí làm việc khoa học đảm bảo an tồn cho người và phương tiện học tập.
Nội dung của mơn học:

Trích trong chương trình đào tạo đã xây dựng của mơn học tương ứng và cụ thể hóa cho
phù hợp nội dung giáo trình.

CHƯƠNG 1
THUẬT TỐN
5


Mã chương: MH05_CH01
Mục tiêu:
- Trình bày được các khái niệm về lập trình;
- Trình bày các phương pháp biểu diễn thuật tốn;
- Trình bày được thuật tốn cho một vấn đề cụ thể
- Thực hiện các thao tác an toàn với máy tính.
Nội dung chính:

Chương 1. THUẬT TỐN
1. Ví dụ
Có rất nhiều thuật toán trong tin học, chẳng hạn, cho một dãy các số nguyên,
tìm số lớn nhất; cho một tập hợp, liệt kê các tập con của nó; cho tập hợp các số
nguyên, xếp chúng theo thứ tự tăng dần; cho một mạng, tìm đường đi ngắn nhất
giữa hai đỉnh của nó. Khi được giao cho một bài tốn như vậy thì việc đầu tiên phải
làm là xây dựng một mơ hình dịch bài tốn đó thành ngữ cảnh toán học. Các cấu
trúc rời rạc được dùng trong các mơ hình này là tập hợp, dãy, hàm, hốn vị, quan
hệ, cùng với các cấu trúc khác như đồ thị, cây, mạng.
Lập được một mơ hình tốn học thích hợp chỉ là một phần của q trình giảA.
Để hồn tất q trình giải, cịn cần phải có một phương pháp dùng mơ hình để giải
bài tốn tổng qt. Nói một cách lý tưởng, cái được đòi hỏi là một thủ tục, đó là
dãy các bước dẫn tới đáp số mong muốn. Một dãy các bước như vậy, được gọi là
một thuật toán.

Khi thiết kế và cài đặt một phần mềm tin học cho một vấn đề nào đó, ta cần
phải đưa ra phương pháp giải quyết mà thực chất đó là thuật toán giải quyết vấn đề
này. Rõ ràng rằng, nếu khơng tìm được một phương pháp giải quyết thì khơng thể
lập trình được. Chính vì thế, thuật tốn là khái niệm nền tảng của hầu hết các lĩnh
vực của tin học.

2. Khái niệm
Thuật toán là một bảng liệt kê các chỉ dẫn (hay quy tắc) cần thực hiện theo
từng bước xác định nhằm giải một bài toán đã cho.
6


Thuật ngữ “Algorithm” (thuật toán) là xuất phát từ tên nhà toán học Ả Rập AlKhowarizmA. Ban đầu, từ algorism được dùng để chỉ các quy tắc thực hiện các
phép tính số học trên các số thập phân. Sau đó, algorism chuyển thành algorithm
vào thế kỷ 19. Với sự quan tâm ngày càng tăng đối với các máy tính, khái niệm
thuật toán đã được cho một ý nghĩa chung hơn, bao hàm cả các thủ tục xác định để
giải các bài tốn, chứ khơng phải chỉ là thủ tục để thực hiện các phép tính số học.
Có nhiều cách trình bày thuật tốn: dùng ngơn ngữ tự nhiên, ngơn ngữ lưu đồ
(sơ đồ khối), ngơn ngữ lập trình. Tuy nhiên, một khi dùng ngơn ngữ lập trình thì chỉ
những lệnh được phép trong ngơn ngữ đó mới có thể dùng được và điều này
thường làm cho sự mô tả các thuật tốn trở nên rối rắm và khó hiểu. Hơn nữa, vì
nhiều ngơn ngữ lập trình đều được dùng rộng rãi, nên chọn một ngơn ngữ đặc biệt
nào đó là điều người ta khơng muốn. Vì vậy ở đây các thuật tốn ngồi việc được
trình bày bằng ngơn ngữ tự nhiên cùng với những ký hiệu toán học quen thuộc cịn
dùng một dạng giả mã để mơ tả thuật tốn. Giả mã tạo ra bước trung gian giữa sự
mô tả một thuật tốn bằng ngơn ngữ thơng thường và sự thực hiện thuật tốn đó
trong ngơn ngữ lập trình. Các bước của thuật toán được chỉ rõ bằng cách dùng các
lệnh giống như trong các ngơn ngữ lập trình.
Thí dụ 1: Mơ tả thuật tốn tìm phần tử lớn nhất trong một dãy hữu hạn các số
nguyên.

a) Dùng ngôn ngữ tự nhiên để mô tả các bước cần phải thực hiện:
1. Đặt giá trị cực đại tạm thời bằng số nguyên đầu tiên trong dãy. (Cực đại tạm thời
sẽ là số nguyên lớn nhất đã được kiểm tra ở một giai đoạn nào đó của thủ tục.)
2. So sánh số nguyên tiếp sau với giá trị cực đại tạm thời, nếu nó lớn hơn giá trị cực
đại tạm thời thì đặt cực đại tạm thời bằng số nguyên đó.
3. Lặp lại bước trước nếu còn các số nguyên trong dãy.
4. Dừng khi khơng cịn số ngun nào nữa trong dãy. Cực đại tạm thời ở điểm này
chính là số nguyên lớn nhất của dãy.
b) Dùng đoạn giả mã:
procedure max (a1, a2, ..., an: integers)
max:= a1
for i:= 2 to n
if max {max là phần tử lớn nhất}
Thuật toán này trước hết gán số hạng đầu tiên a 1 của dãy cho biến max. Vòng
lặp “for” được dùng để kiểm tra lần lượt các số hạng của dãy. Nếu một số hạng lớn
hơn giá trị hiện thời của max thì nó được gán làm giá trị mới của max.

7


3. Các đặc trưng của thuật toán:
- Đầu vào (Input): Một thuật tốn có các giá trị đầu vào từ một tập đã được chỉ rõ.
- Đầu ra (Output): Từ mỗi tập các giá trị đầu vào, thuật toán sẽ tạo ra các giá trị đầu
ra. Các giá trị đầu ra chính là nghiệm của bài tốn.
- Tính dừng: Sau một số hữu hạn bước thuật tốn phải dừng.
- Tính xác định: Ở mỗi bước, các bước thao tác phải hết sức rõ ràng, khơng gây nên
sự nhập nhằng. Nói rõ hơn, trong cùng một điều kiện hai bộ xử lý cùng thực hiện
một bước của thuật toán phải cho những kết quả như nhau.
- Tính hiệu quả: Trước hết thuật toán cần đúng đắn, nghĩa là sau khi đưa dữ liệu

vào thuật toán hoạt động và đưa ra kết quả như ý muốn.
- Tính phổ dụng: Thuật tốn có thể giải bất kỳ một bài toán nào trong lớp các bài
tốn. Cụ thể là thuật tốn có thể có các đầu vào là các bộ dữ liệu khác nhau trong
một miền xác định.
4. Các phương pháp biểu diễn thuật tốn
4.1. Bằng lời
Thí dụ: thuật giải nấu cơm có thể diễn đạt như sau:
Bước 1: Lấy gạo theo định lượng cần thiết
Bước 2: Vo gạo và đổ gạo nước vào nồi
Bước 3: Đun sôi cạn nước
Bước 4: Giữ lửa nhỏ
Bước 5: Cách 5 phút một: nếm cơm xem chín chưa
- Nếu chưa chín: quay về bước 5
- Nếu chín cơm chuyển sang bước 6
Bước 6: Tắt lửa và bắc nồi cơm ra. Kết thúc
4.2. Bằng ngơn ngữ lập trình
Một thuật tốn có thể được cài đặt trên rất nhiều ngơn ngữ lập trình khác nhau,
ví dụ như Pascal, C, C++…Trong đó Pascal là một trong các ngơn ngữ thuật giải,
nghĩa là tự nó đã điễn tả thuật giải cần tiến hành, đó cũng là ưu điểm của Pascal.
Ngồi ra cài đặt thuật tốn cịn được diễn đạt thành mã giả hay còn gọi là tự Pascal.
Như vậy, còn C và C++ có những ưu điểm gì trong q trình cài đặt thuật giải,
chúng ta sẽ được nghiên cứu trong qúa trình học.
Ví dụ: Thuật tốn tìm kiếm tuyến tính: Tìm kiếm tuyến tính hay tìm kiếm tuần
tự là bắt đầu bằng việc so sánh x với a 1; khi x=a1, nghiệm là vị trí a1, tức là 1; khi
x≠ a1, so sánh x với a2. Nếu x=a2, nghiệm là vị trí của a2, tức là 2. Khi x≠ a2, so sánh
x với a3. Tiếp tục quá trình này bằng cách tuần tự so sánh x với mỗi số hạng của
bảng liệt kê cho tới khi tìm được số hạng bằng x, khi đó nghiệm là vị trí của số
8

hạng đó. Nếu tồn bảng liệt kê đã được kiểm tra mà khơng xác định được vị trí của
x, thì nghiệm là 0. Giả mã đối với thuật tốn tìm kiếm tuyến tính được cho dưới
đây:
procedure tìm kiếm tuyến tính (x: integer, a1,a2,...,an: integers phân biệt)
i := 1
while (i ≤ n and x ≠ ai)
i := i + 1
if i ≤ n then location := i
else location := 0
{location là chỉ số dưới của số hạng bằng x hoặc là 0 nếu khơng tìm được x}
4.3. Bằng lưu đồ
Các hình cơ bản để xây dựng lưu đồ thuật giải là:

A

A

A

Thực hiện cơng việc A

Gọi chương trình A

Vào/ra dữ liệu

BEGIN
Sai

B

END
Đúng

Một phép thử B. tuỳ thuộc vào
Bắt đầu hay kết thúc 1 thuật giải
trạng thái của B là Đúng hay Sai
mà rẽ nhánh thích hợp.
BÀI TẬP CHƯƠNG I
1. Lập một thuật tốn tính tổng tất cả các số nguyên trong một bảng.
2. Lập thuật tốn tính xn với x là một số thực và n là một số nguyên.
3. Mô tả thuật tốn chèn một số ngun x vào vị trí thích hợp trong dãy các số
nguyên a1, a2, ..., an xếp theo thứ tự tăng dần.
4. Tìm thuật tốn xác định vị trí gặp đầu tiên của phần tử lớn nhất trong bảng liệt kê
các số nguyên, trong đó các số này không nhất thiết phải khác nhau.
9


5. Tìm thuật tốn xác định vị trí gặp cuối cùng của phần tử nhỏ nhất trong bảng liệt
kê các số ngun, trong đó các số này khơng nhất thiết phải khác nhau.
6. Mơ tả thuật tốn đếm số các số 1 trong một xâu bit bằng cách kiểm tra mỗi bit
của xâu để xác định nó có là bit 1 hay khơng.

CHƯƠNG 2
GIỚI THIỆU NGƠN NGỮ LẬP TRÌNH C++
Mã chương: MH05_CH02
10


Mục tiêu:
- Mơ tả được lịch sử hình thành và phát triển của ngôn ngữ C++.

- Hiểu được cấu trúc của một chương trình C++.
- Cài đặt và sử dụng được chương trình C++.
- Soạn thảo được một chương trình C++.
- Thực hiện các thao tác an toàn với máy tính
Nội dung chính:

CHƯƠNG 2: GIỚI THIỆU NGƠN NGỮ LẬP TRÌNH
C++
1. Lịch sử hình thành
•C
– Dennis Ritchie (Bell Laboratories)
– Là ngơn ngữ phát triển của hệ điều hành UNIX
– Độc lập phần cứng => có thể viết các chương trình khả chuyển
– Chuẩn hóa năm 1990 – ANSI C
– Kernighan & Ritchie “The C Programming Language”, 2nd, 1988
• C++
– Là mở rộng của C
– Đầu những năm 1980: Bjarne Stroustrup (phòng thí nghiệm Bell)
– Cung cấp khả năng lập trình hướng đối tượng.
– Ngơn ngữ lai
• Lập trình cấu trúc kiểu C
• Lập trình hướng đối tượng
• Cả hai
• Có cần biết C trước khi học C++?
2. Đặc điểm
C++ là ngôn ngữ lập trình hướng đối tượng được mở rộng từ ngơn ngữ C. Do
vậy, C++ có ưu điểm là kế thừa được các điểm mạnh truyền thống của ngôn ngữ C
như uyển chuyển, tương thích với các thiết bị phần cứng. Hiện nay, C++ là một
ngơn ngữ lập trình phổ biến, được giảng dạy tại các trường đại học trong nước và
trên thế giới và đặc biệt được sử dụng rộng rãi cho nhu cầu phát triển của công

nghiệp phần mềm hiện nay.

11


3. Cấu trúc một chương trình C++
Một chương trình C++ có thể được đặt trong một hoặc nhiều file văn bản
khác nhau. Mỗi file văn bản chứa một số phần nào đó của chương trình. Với
những chương trình đơn giản và ngắn thường chỉ cần đặt chúng trên một file.
Một chương trình gồm nhiều hàm, mỗi hàm phụ trách một cơng việc khác nhau
của chương trình. Đặc biệt trong các hàm này có một hàm duy nhất có tên
hàm là main(). Khi chạy chương trình, các câu lệnh trong hàm main() sẽ được
thực hiện đầu tiên. Trong hàm main() có thể có các câu lệnh gọi đến các hàm
khác khi cần thiết, và các hàm này khi chạy lại có thể gọi đến các hàm khác nữa
đã được viết trong chương trình (trừ việc gọi quay lại hàm main()). Sau khi
chạy đến lệnh cuối cùng của hàm main() chương trình sẽ kết thúc.
Cụ thể, thơng thường một chương trình gồm có các nội dung sau:
− Phần khai báo các tệp nguyên mẫu: khai báo tên các tệp chứa những thành
phần có sẵn (như các hằng chuẩn, kiểu chuẩn và các hàm chuẩn) mà NSD sẽ
dùng trong chương trình.
− Phần khai báo các kiểu dữ liệu, các biến, hằng ... do NSD định nghĩa và được
dùng chung trong toàn bộ chương trình.
− Danh sách các hàm của chương trình (do NSD viết, bao gồm cả hàm main()).
Cấu trúc chi tiết của mỗi hàm sẽ được đề cập đến trong chương 4.
Dưới đây là một đoạn chương trình đơn giản chỉ gồm 1 hàm chính là hàm main().
Nội dung của chương trình dùng in ra màn hình dịng chữ: Chào các bạn, bây giờ
là 2 giờ.
#include <iostream.h>
// khai báo tệp nguyên mẫu để
int main()

// được sử dụng toán tử in cout <<
{
int h = 2;
// Khai báo và khởi tạo biến h = 2
cout << “Chào các bạn, bây giờ là ” << h << " giờ" ;
// in ra màn hình
return 0;
}
Dịng đầu tiên của chương trình là khai báo tệp nguyên mẫu iostream.h. Đây
là khai báo bắt buộc vì trong chương trình có sử dụng phương thức chuẩn “cout
<<” (in ra màn hình), phương thức này được khai báo và định nghĩa sẵn trong
iostream.h.
Không riêng hàm main(), mọi hàm khác đều phải bắt đầu tập hợp các câu lệnh
của mình bởi dấu { và kết thúc bởi dấu }. Tập các lệnh bất kỳ bên trong cặp dấu
này được gọi là khối lệnh. Khối lệnh là một cú pháp cần thiết trong các câu lệnh có
cấu trúc như ta sẽ thấy trong các chương tiếp theo.
12


4. Một số ví dụ mẫu
Có lẽ một trong những cách tốt nhất để bắt đầu học một ngôn ngữ lập trình là
bằng một chương trình. Vậy đây là chương trình đầu tiên của chúng ta :
// my first program in C++

Hello World!

#include <iostream.h>
int main ()
{
cout << "Hello World!";

return 0;
}
Chương trình trên đây là chương trình đầu tiên mà hầu hết những người học
nghề lập trình viết đầu tiên và kết quả của nó là viết câu "Hello, World" lên màn
hình. Đây là một trong những chương trình đơn giản nhất có thể viết bằng C++
nhưng nó đã bao gồm những phần cơ bản mà mọi chương trình C++ có. Hãy cùng
xem xét từng dòng một :
// my first program in C++
Đây là dịng chú thích. Tất cả các dịng bắt đầu bằng hai dấu sổ (//) được coi là
chút thích mà chúng khơng có bất kì một ảnh hưởng nào đến hoạt động của chương
trình. Chúng có thể được các lập trình viên dùng để giải thích hay bình phẩm bên
trong mã nguồn của chương trình. Trong trường hợp này, dịng chú thích là một giải
thích ngắn gọn những gì mà chương trình chúng ta làm.
#include <iostream.h>
Các câu bắt đầu bằng dấu (#) được dùng cho preprocessor (ai dịch hộ tơi từ
này với). Chúng khơng phải là những dịng mã thực hiện nhưng được dùng để báo
hiệu cho trình dịch. Ở đây câu lệnh #include <iostream.h> báo cho trình
dịch biết cần phải "include" thư viện iostream. Đây là một thư viện vào ra cơ bản
trong C++ và nó phải được "include" vì nó sẽ được dùng trong chương trình. Đây
là cách cổ điển để sử dụng thư viện iostream
int main ()
Dòng này tương ứng với phần bắt đầu khai báo hàm main. Hàm main là điểm
mà tất cả các chương trình C++ bắt đầu thực hiện. Nó khơng phụ thuộc vào vị trí
của hàm này (ở đầu, cuối hay ở giữa của mã nguồn) mà nội dung của nó ln được
thực hiện đầu tiên khi chương trình bắt đầu. Thêm vào đó, do ngun nhân nói trên,
mọi chương trình C++ đều phải tồn tại một hàm main.
13


Theo sau main là một cặp ngoặc đơn bởi vì nó là một hàm. Trong C++, tất cả các

hàm mà sau đó là một cặp ngoặc đơn () thì có nghĩa là nó có thể có hoặc khơng có
tham số (không bắt buộc). Nội dung của hàm main tiếp ngay sau phần khai báo
chính thức được bao trong các ngoặc nhọn ( { } ) như trong ví dụ của chúng ta
cout << "Hello World";
Dòng lệnh này làm việc quan trọng nhất của chương trình. cout là một dịng
(stream) output chuẩn trong C++ được định nghĩa trong thư viện iostream và những
gì mà dịng lệnh này làm là gửi chuỗi kí tự "Hello World" ra màn hình.
Chú ý rằng dịng này kết thúc bằng dấu chấm phẩy ( ; ). Kí tự này được dùng để kết
thúc một lệnh và bắt buộc phải có sau mỗi lệnh trong chương trình C++ của bạn
(một trong những lỗi phổ biến nhất của những lập trình viên C++ là quên mất dấu
chấm phẩy).
return 0;
Lệnh return kết thúc hàm main và trả về mã đi sau nó, trong trường hợp này là
0. Đây là một kết thúc bình thường của một chương trình khơng có một lỗi nào
trong q trình thực hiện. Như bạn sẽ thấy trong các ví dụ tiếp theo, đây là một
cách phổ biến nhất để kết thúc một chương trình C++.
Chương trình được cấu trúc thành những dịng khác nhau để nó trở nên dễ đọc hơn
nhưng hồn tồn khơng phải bắt buộc phải làm vậy. Ví dụ, thay vì viết
int main ()
{
cout << " Hello World ";
return 0;
}
ta có thể viết
int main () { cout << " Hello World "; return 0; }
cũng cho một kết quả chính xác như nhau.
Trong C++, các dòng lệnh được phân cách bằng dấu chấm phẩy ( ;). Việc chia
chương trình thành các dịng chỉ nhằm để cho nó dễ đọc hơn mà thơA.
5. Cài đặt chương trình
Chương trình học của chúng ta sẽ lập trình trên bộ biên dịch Dev C++ 4.9.2,

đây là một chương trình do một cơng ty của Mỹ viết ra và đã được ứng dụng rất
rộng rãi trong cơng tác giảng dậy lập trình C++ ở một số trường Đại học trong
nước và trên thế giới bởi ưu điểm của nó khác hồn tồn với Tubor C++ có giao
diện Dos. Dev C++ có giao diện đồ họa, dễ sử dụng, có dung lượng nhỏ, gần giống
với lập trình chuyên nghiệp Visual Studio 6.0 của Microsoft.
14


Cài đặt chương trình Dev C++ 4.9.2 như sau:
Bước 1: Mở thư mục có chứa Dev C++, kích đúp.
Bước 2: Lựa chọn ngôn ngữ hiển thị, chọn English và ấn OK

Hình 2.1. Lựa chọn ngơn ngữ hiển thị

Bước 3: Hộp thoại yêu cầu chấp nhận cài đặt xuất hiện, chọn I Agree.

Bước 4: Sau đó chọn Next  Install, quá trình cài đặt diễn ra. Ấn Finish để kết
thúc quá trình cài đặt chương trình.
Hình 2.2. Đồng ý cài đặt chương trình

6. Khởi động chương trình
Cách 1: Start\All Programs\BloodShed Dev-C++\chọn Dev-C++
Cách 2: Kích hoạt biểu tượng Dev-C++ ở Desktop
7. Soạn thảo chương trình
Các bước soạn thảo một chương trình trên Dev-C++ như sau:
Bước 1: Sau khi chạy chương trình Dev-C++, chúng ta vào menu File\Chọn New
Source File, màn hình soạn thảo xuất hiện với tên mặc định là Untitle1. Chúng ta
cần lưu lại với tên mới, phù hợp với yêu cầu bài tập để tiện cho việc tra cứu lạA. Ví
dụ, bạn đang thực hiện một chương trình giải phương trình bậc hai, thì bạn có thể
lưu với tên là giai phuong trinh bac haA.cpp

Bước 2: Sau khi viết xong chương trình bạn có thể.
- Chọn Execute\Compile hoặc chọn Ctrl + F9: Biên dịch chương trình
- Chọn Execute\Run hoặc Ctrl + F10: Chạy chương trình
- Chọn Execute\Compile & Run hoặc ấn F9: Biên dịch và chạy chương trình.
8. Thốt khỏi chương trình
Để thốt khỏi chương trình Dev-C++ bạn vào File\chọn Exit hoặc Ctrl + F4

15


CHƯƠNG 3
CÁC THÀNH PHẦN VÀ CÁC KIỂU DỮ LIỆU CƠ BẢN
Mã chương: MH05_CH03
Mục tiêu:
16


- Biết sử dụng các kiểu dữ liệu căn bản.
- Sử dụng được các phép tốn căn bản để tính toán.
- Sử dụng được các hàm nhập xuất dữ liệu.
- Thực hiện các thao tác an tồn với máy tính
Nội dung chính:

CHƯƠNG 3: CÁC THÀNH PHẦN VÀ CÁC KIỂU
DỮ LIỆU CƠ BẢN
1. Các thành phần
Một ngơn ngữ lập trình (NNLT) bậc cao cho phép người sử dụng (NSD) biểu
hiện ý tưởng của mình để giải quyết một vấn đề, bài tốn bằng cách diễn đạt gần
với ngơn ngữ thơng thường thay vì phải diễn đạt theo ngơn ngữ máy (dãy các kí
hiệu 0,1). Hiển nhiên, các ý tưởng NSD muốn trình bày phải được viết theo một

cấu trúc chặt chẽ thường được gọi là thuật toán hoặc giải thuật và theo đúng các qui
tắc của ngôn ngữ gọi là cú pháp hoặc văn phạm. Trong giáo trình này chúng ta bàn
đến một ngơn ngữ lập trình như vậy, đó là ngơn ngữ lập trình C++ và làm thế nào
để thể hiện các ý tưởng giải quyết vấn đề bằng cách viết thành chương trình trong
C++.
Trước hết, trong mục này chúng ta sẽ trình bày về các qui định bắt buộc đơn
giản và cơ bản nhất. Thông thường các qui định này sẽ được nhớ dần trong q
trình học ngơn ngữ, tuy nhiên để có một vài khái niệm tương đối hệ thống về
NNLT C++ chúng ta trình bày sơ lược các khái niệm cơ bản đó. Người đọc đã từng
làm quen với các NNLT khác có thể đọc lướt qua phần này.
1.1. Bộ chữ cái của C++
Hầu hết các ngôn ngữ lập trình hiện nay đều sử dụng các kí tự tiếng Anh, các
kí hiệu thơng dụng và các con số để thể hiện chương trình. Các kí tự của những
ngơn ngữ khác khơng được sử dụng (ví dụ các chữ cái tiếng Việt). Dưới đây là
bảng kí tự được phép dùng để tạo nên những câu lệnh của ngôn ngữ C++.
- Các chữ cái la tinh (viết thường và viết hoa): a .. z và A .. Z. Cùng một chữ cái
nhưng viết thường phân biệt với viết hoa. Ví dụ chữ cái 'a' là khác với 'A'.
- Dấu gạch dưới: _
- Các chữ số thập phân: 0, 1, . ., 9.
- Các ký hiệu toán học: +, -, *, /, % , &, ||, !, >, <, = ...
- Các ký hiệu đặc biệt khác: , ;: [ ], {}, #, dấu cách, ...
1.2. Từ khóa
17


Một từ khoá là một từ được qui định trước trong NNLT với một ý nghĩa cố
định, thường dùng để chỉ các loại dữ liệu hoặc kết hợp thành câu lệnh. NSD có thể
tạo ra những từ mới để chỉ các đối tượng của mình nhưng khơng được phép trùng
với từ khố. Dưới đây chúng tơi liệt kê một vài từ khoá thường gặp, ý nghĩa của các
từ này, sẽ được trình bày dần trong các đề mục liên quan.

auto, break, case, char, continue, default, do, double, else, externe, float, for, goto,
if, int, long, register, return, short, sizeof, static, struct, switch, typedef, union,
unsigned, while ...
Một đặc trưng của C++ là các từ khố ln ln được viết bằng chữ thường.
1.3. Tên gọi
Để phân biệt các đối tượng với nhau chúng cần có một tên gọA. Hầu hết một
đối tượng được viết ra trong chương trình thuộc 2 dạng, một dạng đã có sẵn trong
ngơn ngữ (ví dụ các từ khố, tên các hàm chuẩn ...), một số do NSD tạo ra dùng để
đặt tên cho hằng, biến, kiểu, hàm ... các tên gọi do NSD tự đặt phải tuân theo một
số qui tắc sau:
- Là dãy ký tự liên tiếp (không chứa dấu cách) và phải bắt đầu bằng chữ cái hoặc
gạch dướA.
- Phân biệt kí tự in hoa và thường.
- Khơng được trùng với từ khóa.
- Số lượng chữ cái dùng để phân biệt tên gọi có thể được đặt tuỳ ý.
- Chú ý các tên gọi có sẵn của C++ cũng tuân thủ theo đúng qui tắc trên. Trong một
chương trình nếu NSD đặt tên sai thì trong quá trình xử lý sơ bộ (trước khi chạy
chương trình) máy sẽ báo lỗi (gọi là lỗi văn phạm).
Ví dụ 3.1:
- Các tên gọi sau đây là đúng (được phép): i, i1, j, tinhoc, tin_hoc, luu_luong
- Các tên gọi sau đây là sai (không được phép): 1i, tin hoc, luu-luong-nuoc
- Các tên gọi sau đây là khác nhau: ha_noi, Ha_noi, HA_Noi, HA_NOI, ...
1.4. Dấu chấm phẩy
Dấu chấm phẩy ; được dùng để ngăn cách các câu lệnh của C++ và không thể
thiếu được. Không nên hiểu dấu ; là kết thúc lệnh.
1.5. Lời giải thích (command)
Một chương trình thường được viết một cách ngắn gọn, do vậy thông thường
bên cạnh các câu lệnh chính thức của chương trình, NSD cịn được phép viết vào
chương trình các câu ghi chú, giải thích để làm rõ nghĩa hơn chương trình. Một chú
thích có thể ghi chú về nhiệm vụ, mục đích, cách thức của thành phần đang được

chú thích như biến, hằng, hàm hoặc công dụng của một đoạn lệnh ... Các chú thích

18


sẽ làm cho chương trình sáng sủa, dễ đọc, dễ hiểu và vì vậy dễ bảo trì, sửa chữa về
sau.
Có 2 cách báo cho chương trình biết một đoạn chú thích:
- Nếu chú thích là một đoạn kí tự bất kỳ liên tiếp nhau (trong 1 dòng hoặc trên
nhiều dòng) ta đặt đoạn chú thích đó giữa cặp dấu đóng mở chú thích /* (mở) và */
(đóng).
- Nếu chú thích bắt đầu từ một vị trí nào đó cho đến hết dịng, thì ta đặt dấu // ở
vị trí đó. Như vậy // sử dụng cho các chú thích chỉ trên 1 dòng.
Như đã nhắc ở trên, vai trò của đoạn chú thích là làm cho chương trình dễ hiểu đối
với người đọc, vì vậy đối với máy các đoạn chú thích sẽ được bỏ qua. Lợi dụng đặc
điểm này của chú thích đơi khi để tạm thời bỏ qua một đoạn lệnh nào đó trong
chương trình (nhưng khơng xố hẳn để khỏi phải gõ lại khi cần dùng đến) ta có thể
đặt các dấu chú thích bao quanh đoạn lệnh này (ví dụ khi chạy thử chương trình, gỡ
lỗi ...), khi cần sử dụng lại ta có thể bỏ các dấu chú thích.
Chú ý: Cặp dấu chú thích /* ... */ khơng được phép viết lồng nhau, ví dụ dịng chú
thích sau là khơng được phép
/* Đây là đoạn chú thích /* chứa đoạn chú thích này */ như đoạn chú thích con */
cần phải sửa lại như sau:
- hoặc chỉ giữ lại cặp dấu chú thích ngồi cùng
/* Đây là đoạn chú thích chứa đoạn chú thích này như đoạn chú thích con */
- hoặc chia thành các đoạn chú thích liên tiếp nhau
/* Đây là đoạn chú thích */ /*chứa đoạn chú thích này*/ /*như đoạn chú thích con
*/
1.6. Cấu trúc chung của một chương trình C++
Một chương trình C++ có thể được đặt trong một hoặc nhiều file văn bản khác

nhau. Mỗi file văn bản chứa một số phần nào đó của chương trình. Với những
chương trình đơn giản và ngắn thường chỉ cần đặt chúng trên một file.
Một chương trình gồm nhiều hàm, mỗi hàm phụ trách một cơng việc khác
nhau của chương trình. Đặc biệt trong các hàm này có một hàm duy nhất có tên
hàm là main(). Khi chạy chương trình, các câu lệnh trong hàm main() sẽ được thực
hiện đầu tiên. Trong hàm main() có thể có các câu lệnh gọi đến các hàm khác khi
cần thiết, và các hàm này khi chạy lại có thể gọi đến các hàm khác nữa đã được viết
trong chương trình (trừ việc gọi quay lại hàm main()). Sau khi chạy đến lệnh cuối
cùng của hàm main() chương trình sẽ kết thúc.
Cụ thể, thơng thường một chương trình gồm có các nội dung sau:

19


- Phần khai báo các tệp nguyên mẫu: khai báo tên các tệp chứa những thành phần
có sẵn (như các hằng chuẩn, kiểu chuẩn và các hàm chuẩn) mà NSD sẽ dùng trong
chương trình.
- Phần khai báo các kiểu dữ liệu, các biến, hằng ... do NSD định nghĩa và được
dùng chung trong tồn bộ chương trình.
- Danh sách các hàm của chương trình (do NSD viết, bao gồm cả hàm main()).
Cấu trúc chi tiết của mỗi hàm sẽ được đề cập đến trong chương 4.
Ví dụ 3.2.
Dưới đây là một đoạn chương trình đơn giản chỉ gồm 1 hàm chính là hàm main().
Nội dung của chương trình dùng in ra màn hình dịng chữ: Chào các bạn, bây giờ là
2 giờ.
#include <iostream.h> // khai báo tệp nguyên mẫu để
int main() // được sử dụng toán tử in cout <<
{
int h = 2, // Khai báo và khởi tạo biến h = 2
cout << “Chào các bạn, bây giờ là ” << h << " giờ" ; // in ra màn hình

return 0;}
Dịng đầu tiên của chương trình là khai báo tệp nguyên mẫu iostream.h. Đây là khai
báo bắt buộc vì trong chương trình có sử dụng phương thức chuẩn “cout <<” (in ra
màn hình), phương thức này được khai báo và định nghĩa sẵn trong iostream.h.
Không riêng hàm main(), mọi hàm khác đều phải bắt đầu tập hợp các câu lệnh của
mình bởi dấu { và kết thúc bởi dấu }. Tập các lệnh bất kỳ bên trong cặp dấu này
được gọi là khối lệnh. Khối lệnh là một cú pháp cần thiết trong các câu lệnh có cấu
trúc như ta sẽ thấy trong các chương tiếp theo.
1.7. Các bước cơ bản khi viết một chương trình.
Bước 1. 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:
A. 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 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.
iA. Xác định thuật toán giảA.
iiA. Cụ thể hoá các khai báo kiểu và thuật tố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.
20


iv. 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.
v. 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 NSD.
Bước 2. 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ạA. Có thể soạn
chương trình nguồn trên các bộ soạn thảo (editor) khác nhưng phải chạy trong mơi
trường tích hợp C++ (Borland C, Turbo C). 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.
Bước 3. 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
(ấn tổ hợp phím Alt-F9) để tìm và sửa các lỗi gọi là lỗi cú pháp. Trong khi dịch C+
+ sẽ đặt con trỏ vào nơi gây lỗi (viết sai cú pháp) trong văn bản. Sau khi sửa xong
một lỗi NSD có thể dùng Alt-F8 để chuyển con trỏ đến lỗi tiếp theo hoặc dịch lạA.
Để chuyển con trỏ về ngược lại lỗi trước đó có thể dùng Alt-F7. Q trình sửa lỗi −
dịch được lặp lại cho đến khi văn bản đã được sửa hết lỗi cú pháp.
Sản phẩm sau khi dịch là một tệp mới gọi là chương trình đích có đ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
NSD. Trong và sau khi dịch, C++ sẽ hiện một cửa sổ chứa thơng báo về các lỗi
(nếu có), hoặc thơng báo chương trình đã được dịch thành cơng (khơng cịn lỗi).
Các lỗi này được gọi là lỗi cú pháp. Để dịch chương trình ta chọn menu
\Execute\Compile hoặc F9.
Bước 4. Chạy chương trình
Ấn F9 để chạy chương trình, 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ả để NSD kiểm tra. Nếu kết quả chưa được như mong muốn, 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ả. Để

21


xem lại kết quả đã hiện ấn Alt-F5. Sau khi xem xong để quay lại cửa sổ soạn thảo
ấn phím bất kỳ.
2. Các kiểu dữ liệu căn bản
2.1. Khái niệm về kiểu dữ liệu
Thông thường dữ liệu hay dùng là số và chữ. Tuy nhiên việc phân chia chỉ 2
loai dữ liệu là không đủ. Để dễ dàng hơn cho lập trình, hầu hết các NNLT đề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, NSD 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 tố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. Dưới đây chúng ta sẽ xét đến
một số kiểu dữ liệu chuẩn được qui định sẵn bởi C++.
Một biến như đã biết là một số ơ nhớ liên tiếp nào đó trong bộ nhớ dùng để
lưu trữ dữ liệu (vào, ra hay kết quả trung gian) trong quá trình hoạt động của
chương trình. Để quản lý chặt chẽ các biến, NSD cần khai báo cho chương trình
biết trước tên biến và kiểu của dữ liệu được chứa trong biến. 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 tốn trên biến theo ngun tắc: chỉ có các dữ liệu cùng kiểu
với nhau mới được phép làm tốn với nhau. Do đó, khi đề cập đến một kiểu chuẩn
của một NNLT, 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. NSD
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 là bảng tóm tắt một số kiểu chuẩn đơn giản và các thơng số của nó được
sử dụng trong C++

Loại dữ liệu

Tên kiểu

Số ô nhớ

22

Miền giá trị


Kí tự

Số nguyên

char

1 byte
1 byte
unsigned
char2 byte
int
2 byte
unsigned

int2 byte
short
4 byte
long float double 4 byte
8 byte

− 128 .. 127
0 .. 255
− 32768 .. 32767
0 .. 65535

− 32768 .. 32767
− 215 .. 215 – 1
± 10 -37 . . ± 10
+38
Hình 3.1. Các loại kiểu đơn giản
Trong chương này chúng ta chỉ xét các loại kiểu đơn giản trên đây. Các loại kiểu có
cấu trúc do người dùng định nghĩa sẽ được trình bày trong các chương sau.
2.2. Kiểu ký tự
Một kí tự là một kí hiệu trong bảng mã ASCIA. Như đã biết một số kí tự có
mặt chữ trên bàn phím (ví dụ các chữ cái, chữ số) trong khi một số kí tự lại khơng
(ví dụ kí tự biểu diễn việc lùi lại một ơ trong văn bản, kí tự chỉ việc kết thúc một
dòng hay kết thúc một văn bản). Do vậy để biểu diễn một kí tự người ta dùng chính
mã ASCII của kí tự đó trong bảng mã ASCII và thường gọi là giá trị của kí tự. Ví
dụ phát biểu "Cho kí tự 'A'" là cũng tương đương với phát biểu "Cho kí tự 65" (65
là mã ASCII của kí tự 'A'), hoặc "Xố kí tự xuống dịng" là cũng tương đương với
phát biểu "Xố kí tự 13" vì 13 là mã ASCII của kí tự xuống dịng.
Như vậy một biến kiểu kí tự có thể được nhận giá trị theo 2 cách tương đương
- chữ hoặc giá trị số: ví dụ giả sử c là một biến kí tự thì câu lệnh gán c = 'A' cũng
tương đương với câu lệnh gán c = 65. Tuy nhiên để sử dụng giá trị số của một kí tự

c nào đó ta phải u cầu đổi c sang giá trị số bằng câu lệnh int(c). Theo bảng trên ta
thấy có 2 loại kí tự là char với miền giá trị từ -128 đến 127 vànsigned char (kí tự
không dấu) với miền giá trị từ 0 đến 255. Trường hợp một biến được gán giá trị
vượt ra ngoài miền giá trị của kiểu thì giá trị của biến sẽ được tính theo mã bù −
(256 − c). Ví dụ nếu gán cho char c giá trị 179 (vượt khỏi miền giá trị đã được qui
định của char) thì giá trị thực sự được lưu trong máy sẽ là − (256 − 179) = −77.
Ví dụ 3.3:
char c, d ; // c, d được phép gán giá trị từ -128 đến 127
unsigned e ; // e được phép gán giá trị từ 0 đến 255
c = 65 ; d = 179 ; // d có giá trị ngồi miền cho phép e = 179; f = 330 ;
// f có
giá trị ngồi miền cho phép cout << c << int(c) ; // in ra chữ cái 'A' và giá trị số
65 cout << d << int(d) ; // in ra là kí tự '|' và giá trị số -77 cout << e << int(e)
23


// in ra là kí tự '|' và giá trị số 179 cout << f << int(f)
// in ra là kí tự 'J' và
giá trị số 74
Chú ý: Qua ví dụ trên ta thấy một biến nếu được gán giá trị ngồi miền cho phép sẽ
dẫn đến kết quả khơng theo suy nghĩ thông thường. Do vậy nên tuân thủ qui tắc chỉ
gán giá trị cho biến thuộc miền giá trị mà kiểu của biến đó qui định. Ví dụ nếu
muốn sử dụng biến có giá trị từ 128 .. 255 ta nên khai báo biến dưới dạng kí tự
khơng dấu (unsigned char), còn nếu giá trị vượt quá 255 ta nên chuyển sang kiểu
nguyên (int) chẳng hạn.

2.3. Kiểu số nguyên
Các số nguyên được phân chia thành 4 loại kiểu khác nhau với các miền giá trị
tương ứng được cho trong bảng 1. Đó là kiểu số nguyên ngắn (short) tương đương
với kiểu số nguyên (int) sử dụng 2 byte và số nguyên dài (long int) sử dụng 4 byte.

Kiểu số nguyên thường được chia làm 2 loại có dấu (int) và khơng dấu (unsigned
int hoặc có thể viết gọn hơn là unsigned). Qui tắc mã bù cũng được áp dụng nếu giá
trị của biến vượt ra ngoài miền giá trị cho phép, vì vậy cần cân nhắc khi khai báo
kiểu cho các biến. Ta thường sử dụng kiểu int cho các số nguyên trong các bài toán
với miền giá trị vừa phải (có giá trị tuyệt đối bé hơn 32767), chẳng hạn các biến
đếm trong các vòng lặp, ...
2.4. Kiểu số thực
Để sử dụng số thực ta cần khai báo kiểu float hoặc double mà miền giá trị của
chúng được cho trong bảng 1. Các giá trị số kiểu double được gọi là số thực với độ
chính xác gấp đơi vì với kiểu dữ liệu này máy tính có cách biểu diễn khác so với
kiểu float để đảm bảo số số lẻ sau một số thực có thể tăng lên đảm bảo tính chính
xác cao hơn so với số kiểu float. Tuy nhiên, trong các bài tốn thơng dụng thường
ngày độ chính xác của số kiểu float là đủ dùng.
Như đã nhắc đến trong phần các lệnh vào/ra ở chương 1, liên quan đến việc in
ấn số thực ta có một vài cách thiết đặt dạng in theo ý muốn, ví dụ độ rộng tối thiểu
để in một số hay số số lẻ thập phân cần in ...
Ví dụ 3.4 : Chương trình sau đây sẽ in diện tích và chu vi của một hình trịn có bán
kính 2cm với 3 số lẻ.
#include <iostream.h>
#include <iomanip.h>
int main()
{
float r = 2 ; // r là tên biến dùng để chứa bán kính
24


cout << "Diện tích = " << setiosflags(ios::showpoint) ;
cout << setprecision(3) << r * r * 3.1416 ;
system(“pause”); // dừng màn hình
return 0;

}
3. Hằng
Hằng là một giá trị cố định nào đó ví dụ 3 (hằng ngun), 'A' (hằng kí tự), 5.0
(hằng thực), "Ha noi" (hằng xâu kí tự). Một giá trị có thể được hiểu dưới nhiều kiểu
khác nhau, do vậy khi viết hằng ta cũng cần có dạng viết thích hợp.
3.1. Hằng nguyên
- kiểu short, int: 3, -7, ...
- kiểu unsigned: 3, 123456, ...
- kiểu long, long int: 3L, -7L, 123456L, ... (viết L vào cuối mỗi giá trị)
Các cách viết trên là thể hiện của số nguyên trong hệ thập phân, ngồi ra chúng cịn
được viết dưới các hệ đếm khác như hệ cơ số 8 hoặc hệ cơ số 16. Một số nguyên
trong cơ số 8 luôn luôn được viết với số 0 ở đầu, tương tự với cơ số 16 phải viết với
0x ở đầu. Ví dụ ta biết 65 trong cơ số 8 là 101 và trong cơ số 16 là 41, do đó 3 cách
viết 65, 0101, 0x41 là như nhau, cùng biểu diễn giá trị 65.
3.2. Hằng thực
Một số thực có thể được khai báo dưới dạng kiểu float hoặc double và các giá trị
của nó có thể được viết dưới một trong hai dạng.
a. Dạng dấu phảy tĩnh
Theo cách viết thông thường. Ví dụ: 3.0, -7.0, 3.1416, ...
b. Dạng dấu phảy động
Tổng quát, một số thực x có thể được viết dưới dạng: men hoặc mEn, trong đó m
được gọi là phần định trị, n gọi là phần bậc (hay mũ). Số men biểu thị giá trị x = m
x 10n. Ví dụ số π = 3.1416 có thể được viết:
π = … = 0.031416e2 = 0.31416e1 = 3.1416e0 = 31.416e−1 = 314.16e−2 = …
vì
π = 0.031416 x 102 = 0.31416 x 101 = 3.1416 x 100 = …
Như vậy một số x có thể được viết dưới dạng mEn với nhiều giá trị m, n khác nhau,
phụ thuộc vào dấu phảy ngăn cách phần nguyên và phần thập phân của số. Do vậy
cách viết này được gọi là dạng dấu phảy động.

3.3. Hằng kí tự
25