Giáo trình Lập trình cơ bản (Nghề: Lập trình máy tính) - CĐ Cơ Giới Ninh Bình
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (1.01 MB, 118 trang )
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
............................................................................................................................
4
MƠN HỌC LẬP TRÌNH CĂN BẢN
...............................................................................................
5
Chương 1. THUẬT TỐN
..............................................................................................................
6
1.Ví dụ
..............................................................................................................................................
6
2. Khái niệm
.....................................................................................................................................
7
3. Các đặc trưng của thuật tốn:
.....................................................................................................
8
4. Các phương pháp biểu diễn thuật tốn
.......................................................................................
8
CHƯƠNG 2: GIỚI THIỆU NGƠN NGỮ LẬP TRÌNH C++
......................................................
11
2. Đặc điểm
...................................................................................................................................
12
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
..................................................................................................................
15
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
............................................................................................................
16
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++
..............................................................................................................
29
5. Xuất nhập dữ liệu
.....................................................................................................................
35
CHƯƠNG 4: CÁC CẤU TRÚC ĐIỀU KHIỂN
...........................................................................
41
1. Lệnh đơn và lệnh phức
.............................................................................................................
41
2. Cấu trúc điều kiện if…else
.......................................................................................................
41
3. Cấu trúc lựa chọn switch … case
..............................................................................................
43
4. Các cấu trúc lặp
.........................................................................................................................
45
5. Câu lệnh break, continue, goto và hàm exit
...............................................................................
56
CHƯƠNG 5: HÀM
.......................................................................................................................
59
1. Khái niệm
...................................................................................................................................
59
2. Khai báo hàm
..............................................................................................................................
60
3. Kết quả trả về của hàm – lệnh return
.....................................................................................
63
4. Cách truyền tham số cho hàm
...................................................................................................
64
5. Đệ qui
.........................................................................................................................................
71
CHƯƠNG 6: MẢNG (ARRAY)
...................................................................................................
74
1. Khái niệm
...................................................................................................................................
75
2. Khai báo mảng
...........................................................................................................................
75
4. Dùng mảng làm tham số
............................................................................................................
92
CHƯƠNG 7: CON TRỎ (POINTER)
........................................................................................
102
1. Khái niệm
.................................................................................................................................
102
2. Toán tử (&)
...............................................................................................................................
102
3. Toán tử (*)
................................................................................................................................
103
4. Khai báo biến kiểu con trỏ
......................................................................................................
103
5. Các phép toán
...........................................................................................................................
103
2
6. Con trỏ hằng
............................................................................................................................
104
7. Con trỏ mảng
...........................................................................................................................
104
8. Khởi tạo con trỏ
.......................................................................................................................
104
9. Con trỏ tới con trỏ
...................................................................................................................
105
10. Con trỏ không kiểu
................................................................................................................
106
11. Con trỏ hàm
............................................................................................................................
107
CHƯƠNG 8: CẤU TRÚC (STRUCTURE)
................................................................................
109
1. Khái niệm cấu trúc
..................................................................................................................
109
2. Khai báo cấu trúc
.....................................................................................................................
109
3. Truy nhập đến các thành phần của cấu trúc
..........................................................................
112
4. Ví dụ cấu trúc
..........................................................................................................................
116
3
LỜI GIỚI THIỆU
Giáo Trình Lập trình căn bản C++ được biên soạn nhằm đáp ứng 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 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.
4
MƠN HỌC LẬP TRÌNH CĂN BẢN
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.
5
CHƯƠNG 1
THUẬT TỐN
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 tồ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 tố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ố ngun, 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 tố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 tố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 tố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.
6
2. Khái niệm
Thuật tố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 tốn đã cho.
Thuật ngữ “Algorithm” (thuật tốn) là xuất phát từ tên nhà tố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 tố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 tố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 tố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ố
ngun.
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ố ngun đầu tiên trong dãy. (Cực đại tạm
thời sẽ là số ngun 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ố ngun 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ố ngun đó.
3. Lặp lại bước trước nếu cịn các số ngun 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ố ngun lớn nhất của dãy.
b) Dùng đoạn giả mã:
procedure max (a1, a2, ..., an: integers)
7
max:= a1
for i:= 2 to n
if max
Thuật tố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.
3. Các đặc trưng của thuật tố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 tố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 tốn phải cho những kết quả như nhau.
Tính hiệu quả: Trước hết thuật tốn cần đúng đắn, nghĩa là sau khi đưa dữ liệu
vào thuật tố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 tố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ữ
8
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 a1; 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 q 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ố 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
9
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ố ngun 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ố ngun.
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ố
ngun 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ố ngun, trong đó các số này khơng nhất thiết phải khác nhau.
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.
10
CHƯƠNG 2
GIỚI THIỆU NGƠN NGỮ LẬP TRÌNH C++
Mã chương: MH05_CH02
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 tồ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++?
11
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.
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 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.
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 ngun mẫu để
int main()
// được sử dụng tố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;
12
}
Dịng đầu tiên của chương trình là khai báo tệp ngun 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.
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++
#include <iostream.h>
int main ()
{
cout << "Hello World!";
return 0;
}
Hello World!
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
13
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.
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à qn
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; }
14
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 chun nghiệp Visual Studio 6.0 của Microsoft.
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 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, q trình cài đặt diễn ra. Ấn Finish để kết
thúc q trình cài đặt chương trình.
6. Khởi động chương trình
Hình 2.2. Đồng ý cài đặt chương trình
Cách 1: Start\All Programs\BloodShed DevC++\chọn DevC++
Cách 2: Kích hoạt biểu tượng DevC++ ở 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 DevC++ như sau:
Bước 1: Sau khi chạy chương trình DevC++, 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 u cầu bài tập để tiện cho việc tra cứu
15
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 DevC++ bạn vào File\chọn Exit hoặc Ctrl + F4
16
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:
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 tố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 tố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.
17
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 tốn học: +, , *, /, % , &, ||, !, >, <, = ...
Các ký hiệu đặc biệt khác: , ;: [ ], {}, #, dấu cách, ...
1.2. Từ khóa
Một từ khố 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ừ khố 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 tn 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 tn thủ theo đúng qui tắc trên. Trong
một chương trình nếu NSD đặt tên sai thì trong q 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:
18
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, luuluongnuoc
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 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++
19
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 ngun 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 ngun mẫu để
int main() // được sử dụng tố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 ngun 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.
20
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 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 ngồ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 tốn giảA.
iiA. Cụ thể hố 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. Q trình này được gọi là soạn thảo chương trình nguồn.
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. Q 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 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 AltF9) để 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 AltF8 để 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 AltF7.
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
21
vụ cho q 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ả. Để xem lại kết quả đã hiện ấn AltF5. 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 q 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.
22
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
Kí tự
Số ngun
Tên kiểu
Số ơ nhớ
char
1 byte
1 byte
unsigned char 2 byte
int
2 byte
unsigned int 2 byte
short
4 byte
long float double 4 byte
8 byte
Miền giá trị
− 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.
23
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 ngồ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)
// 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 tn 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 q 255 ta nên chuyển
sang kiểu ngun (int) chẳng hạn.
2.3. Kiểu số ngun
Các số ngun đượ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ố ngun ngắn (short) tương
đương với kiểu số ngun (int) sử dụng 2 byte và số ngun dài (long int) sử
dụng 4 byte. Kiểu số ngun 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 ngồ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ố ngun trong các bài tố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
24
Để 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
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 ngun
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ố ngun 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ố
ngun trong cơ số 8 ln ln đượ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
25
