Giáo trình Lập trình căn 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
MỤC LỤC.......................................................................................................................................2
LỜI GIỚI THIỆU.............................................................................................................................4
Chương 1. THUẬT TOÁN ..............................................................................................................6
1. Ví dụ.............................................................................................................................................6
2. Khái niệm .....................................................................................................................................7
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
1. Lịch sử hình thành
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...................................................................................................................15
6. Khởi động chương trình .............................................................................................................15
7. Soạn thảo chương trình...............................................................................................................15
8. Thoát khỏi chương trình.............................................................................................................16
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 .......................................................................................................................35
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
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)....................................................................................................73
1. Khái niệm ...................................................................................................................................73
2. Khai báo mảng............................................................................................................................74
4. Dùng mảng làm tham số.............................................................................................................90
CHƯƠNG 7: CON TRỎ (POINTER)..........................................................................................100
1. Khái niệm .................................................................................................................................100
2. Toán tử (&)...............................................................................................................................100
3. Toán tử (*)................................................................................................................................101
4. Khai báo biến kiểu con trỏ........................................................................................................101
6. Con trỏ hằng .............................................................................................................................102
2
7. Con trỏ mảng............................................................................................................................102
8. Khởi tạo con trỏ........................................................................................................................102
9. Con trỏ tới con trỏ ....................................................................................................................103
10. Con trỏ không kiểu.................................................................................................................104
11. Con trỏ hàm............................................................................................................................105
CHƯƠNG 8: CẤU TRÚC (STRUCTURE).................................................................................107
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 ...........................................................................................................................114
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 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 hoà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 toán, soạn thảo văn
bản, trước các môn học/ mô đun đào tạo chuyên 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 toà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 TOÁ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 toán;
- Trình bày được thuật toá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 TOÁ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 toá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 toá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, hoá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 toán học thích hợp chỉ là một phần của quá trình giảA.
Để hoàn tất quá 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 toán tổng quát. 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 toá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 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.
Thuật ngữ “Algorithm” (thuật toán) là xuất phát từ tên nhà toán học Ả Rập Al-
KhowarizmA. 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 toá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 toá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 toá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 toán ngoà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 toán. Giả mã tạo ra bước trung gian giữa sự
mô tả một thuật toán bằng ngôn ngữ thông thường và sự thực hiện thuật toá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 toá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ố nguyên 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 <ai then max:= ai
{max là phần tử lớn nhất}
7
Thuật toán này trước hết gán số hạng đầu tiên a1 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 toán:
- Đầu vào (Input): Một thuật toá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 toán.
- Tính dừng: Sau một số hữu hạn bước thuật toá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 toán có thể giải bất kỳ một bài toán nào trong lớp các bài
toán. Cụ thể là thuật toá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 toá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 toá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.
Ngoài ra cài đặt thuật toá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 quá 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 toá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
8
xa1, so sánh x với a2. Nếu x=a2, nghiệm là vị trí của a2, tức là 2. Khi xa2, 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ố
hạng đó. Nếu toà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 toá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
B
END
Đúng
Một phép thử B. tuỳ thuộc vào
trạng thái của B là Đúng hay Sai
mà rẽ nhánh thích hợp.
Bắt đầu hay kết thúc 1 thuật giải
BÀI TẬP CHƯƠNG I
1. Lập một thuật toán tính tổng tất cả các số nguyên trong một bảng.
2. Lập thuật toán tính xn với x là một số thực và n là một số nguyên.
9
3. Mô tả thuật toán chèn một số nguyên 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 toá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.
5. Tìm thuật toá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ố nguyên, trong đó các số này không nhất thiết phải khác nhau.
6. Mô tả thuật toá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 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à
11
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 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.
12
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++
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 ()
13
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ó luôn được
thực hiện đầu tiên khi chương trình bắt đầu. Thêm vào đó, do nguyên 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à 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 quá 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 hoàn toà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.
14
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 hoàn toà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.
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
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:
- Biết sử dụng các kiểu dữ liệu căn bản.
- Sử dụng được các phép toá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 toà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 toá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 quá
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++.
17
- 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
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ừ khoá. 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ừ khoá luôn luôn đượ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ừ khoá, 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.
18
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 xoá 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 ngoà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
19
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.
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.
20
Tải về để xem bản đầy đủ
116 trang
22740
Free
Bạn đang xem 20 trang mẫu của tài liệu "Giáo trình Lập trình căn bản - Nghề: Lập trình máy tính", để tải tài liệu gốc về máy hãy click vào nút Download ở trên
File đính kèm:
- giao_trinh_lap_trinh_can_ban_nghe_lap_trinh_may_tinh.doc
