Lập trình căn bản (dựa trên ngôn ngữ C++)
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 (496.29 KB, 85 trang )
Đề cương môn: Lập trình Cơ bản
Mục lục
Chương 1. Thuật toán.......................................................................................................................3
1. Ví dụ.........................................................................................................................................3
2. Khái niệm.................................................................................................................................4
3. Các đặc trưng của thuật toán....................................................................................................4
4. Phương pháp biểu diễn.............................................................................................................5
Bài tập luyện.....................................................................................................................................8
Chương 2. Giới thiệu ngôn ngữ lập trình C++.................................................................................9
1. Lịch sử hình thành....................................................................................................................9
2. Đặc điểm.................................................................................................................................10
3. Cấu trúc của một chương trình C++.......................................................................................11
4. Một số ví dụ mẫu....................................................................................................................13
5. Cài đặt chương trình...............................................................................................................15
7. Soạn thảo chương trình...........................................................................................................18
8. Thoát khỏi chương trình.........................................................................................................19
Chương 3. Các thành phần và các kiểu dữ liệu cơ bản...................................................................20
1. Các thành phần.......................................................................................................................20
2. Các kiểu dữ liệu căn bản.........................................................................................................20
3. Hằng........................................................................................................................................21
3.1. Khái niệm........................................................................................................................21
3.2. Định nghĩa hằng...............................................................................................................21
4. Các phép toán của C++...........................................................................................................22
5. Xuất nhập dữ liệu....................................................................................................................23
5.1. Xuất dữ liệu (cout)...........................................................................................................23
5.2. Nhập dữ liệu (cin)............................................................................................................25
Chương 4. Các cấu trúc điều khiển.................................................................................................25
1. Lệnh đơn và lệnh phức...........................................................................................................25
1.1. Lệnh đơn..........................................................................................................................25
1.2. Lệnh phức hay khối lệnh.................................................................................................26
2. Cấu trúc điều kiện if..else.......................................................................................................26
2.1. Dạng khuyết.....................................................................................................................26
2.2. Dạng đầy đủ.....................................................................................................................27
3. Cấu trúc lựa chọn: switch..case..............................................................................................29
4. Các cấu trúc lặp......................................................................................................................32
4.1. Cấu trúc lặp while............................................................................................................32
4.2. Cấu trúc lặp do..while......................................................................................................34
4.3. Cấu trúc lặp for................................................................................................................36
5. Câu lệnh break, continue, goto và hàm exit............................................................................38
5.1. Câu lệnh break.................................................................................................................38
5.2. Câu lệnh continue............................................................................................................39
5.3. Câu lệnh goto...................................................................................................................39
5.4. Hàm exit..........................................................................................................................40
Chương 5. Hàm...............................................................................................................................40
1. Khái niệm...............................................................................................................................40
2. Khai báo hàm..........................................................................................................................40
2.1. Cú pháp khai báo nguyên mẫu hàm.................................................................................40
2.2. Định nghĩa hàm...............................................................................................................41
3. Kết quả trả về của hàm – Lệnh return.....................................................................................42
4. Lời gọi hàm và Cách truyền tham số cho hàm.......................................................................43
1
Đề cương môn: Lập trình Cơ bản
5. Đệ qui.....................................................................................................................................43
5.1. Khái niệm........................................................................................................................43
5.2. Ví dụ................................................................................................................................43
Bài tập luyện:..................................................................................................................................44
Chương 6. Mảng.............................................................................................................................45
1. Khái niệm...............................................................................................................................45
2. Khai báo mảng........................................................................................................................45
2.1. Khai báo mảng.................................................................................................................45
2.2. Truy xuất đến các phần tử của mảng...............................................................................46
3. Khởi tạo mảng........................................................................................................................46
4. Dùng mảng làm tham số.........................................................................................................48
5. Với mảng hai chiều.................................................................................................................51
5.1. Định nghĩa.......................................................................................................................51
5.2. Truy xuất các phần tử mảng hai chiều.............................................................................51
5.3. Khởi tạo giá trị mảng hai chiều.......................................................................................51
5.4. Ví dụ................................................................................................................................52
Bài tập luyện...................................................................................................................................53
Chương 7. Con trỏ..........................................................................................................................54
1. Khái niệm...............................................................................................................................54
2. Toán tử lấy địa chỉ (&)...........................................................................................................54
3. Toán tử tham chiếu (*)...........................................................................................................55
4. Khai báo biến kiểu con trỏ......................................................................................................55
5. Các phép toán.........................................................................................................................56
5.1. Phép gán..........................................................................................................................56
5.2. Phép tăng giảm địa chỉ.....................................................................................................56
5.3. Phép truy nhập bộ nhớ.....................................................................................................57
5.4. Phép so sánh....................................................................................................................57
6. Con trỏ hằng...........................................................................................................................57
7. Con trỏ mảng..........................................................................................................................58
8. Khởi tạo con trỏ......................................................................................................................59
9. Con trỏ trỏ tới con trỏ.............................................................................................................60
10. Con trỏ không kiểu...............................................................................................................61
11. Con trỏ hàm..........................................................................................................................62
Chương 8. Cấu trúc.........................................................................................................................63
1. Khái niệm cấu trúc..................................................................................................................63
2. Khai báo cấu trúc....................................................................................................................63
2.1. Kiểu cấu trúc....................................................................................................................63
2.2. Khai báo thành phần (biến, mảng) kiểu cấu trúc.............................................................65
3. Truy cập đến các thành phần của cấu trúc..............................................................................66
4. Ví dụ cấu trúc.........................................................................................................................66
Bài tập luyện:..................................................................................................................................69
Chương 9. File................................................................................................................................71
1. Khái niệm File........................................................................................................................71
2. Tạo file đọc file.......................................................................................................................72
2.1. Khai báo con trỏ trỏ đến tập tin.......................................................................................72
2.2. Mở tập tin........................................................................................................................72
2.3. Các kiểu xử lý tệp thông dụng.........................................................................................73
2.4. Đóng tập tin.....................................................................................................................74
2.5. Kiểm tra đến cuối tập tin hay chưa..................................................................................74
2
Đề cương môn: Lập trình Cơ bản
2.6. Các xử lý trên tập tin.......................................................................................................74
2.7. Truy cập đến tập tin văn bản (text)..................................................................................75
3. Tạo file nhị phân.....................................................................................................................78
4. Đọc file nhị phân....................................................................................................................79
4.1. Ghi dữ liệu lên tệp nhị phân............................................................................................79
4.2. Đọc dữ liệu từ tập tin nhị phân - Hàm fread().................................................................79
4.3. Di chuyển con trỏ tập tin - Hàm fseek()..........................................................................80
Bài tập luyện...................................................................................................................................81
Tài liệu tham khảo..........................................................................................................................85
Chương 1. Thuật toán
1. Ví dụ
+ Thuật toán giải phương trình bậc 1, giải phương trình bậc 2.
+ Thuật toán tìm số lớn nhất trong 3 số a, b, c.
+ Thuật toán tính trung bình cộng của 4 số a, b, c, d.
+ Thuật toán tìm đường đi ngắn nhất.
…
3
Đề cương môn: Lập trình Cơ bản
2. Khái niệm
Thuật ngữ thuật toán (Algorithm) là từ viết tắt của tên một nhà toán học ở
thế kỷ IX: Abu Ja’fa Mohammed ibn Musa al-Khowarizmi. Đầu tiên, thuật toán
được hiểu như là các quy tắc thực hiện các phép toán số học với các con số
được viết trong hệ thập phân. Cùng với sự phát triển của máy tính, khái niệm
thuật toán được hiểu theo nghĩa rộng hơn. Một định nghĩa hình thức về thuật
toán được nhà toán học người Anh là Alanh Turing đưa ra vào năm 1936 thông
quá máy Turing. Có thể nói lý thuyết thuật toán được hình thành từ đó.
Lý thuyết thuật toán liên quan đến vấn đề sau:
+ Giải được bằng thuật toán: Thay những thuật toán chưa tốt bằng những
thuật toán tốt hơn.
+ Triển khai thuật toán: Xây dựng những ngôn ngữ thực hiện trên máy tính
để mã hóa thuật toán.
Vậy, Thuật toán là một dãy hữu hạn các thao tác được bố trí theo một trình
tự xác định, được đề ra trước, nhằm giải quyết một bài toán nhất định.
Thao tác hay còn gọi là tác vụ, phép toán (Operation) hay lệnh
(Command), chỉ thị (Instruction)… là một hành động cần được thực hiện bởi cơ
chế thực hiện thuật toán.
Mỗi thao tác biến đổi bài toán từ một trạng thái trước (hay trạng thái nhập)
sang trạng thái sau (hay trạng thái xuất). Thực tế mỗi thao tác thường sử dụng
một số đối tượng trong trạng thái nhập (các đối tượng nhập) và sản sinh ra các
đối tượng mới trong trạng thái xuất (các đối tượng xuất). Quan hệ giữa 2 trạng
thái xuất và nhập cho thấy tác động của thao tác. Dãy các thao tác của thuật toán
nối tiếp nhau nhằm biến đổi bài toán từ trạng thái ban đầu đến trạng thái kết quả.
Mỗi thao tác có thể phân tích thành các thao tác đơn giản hơn.
Trình tự thực hiện các thao tác phải được xác định rõ ràng trong thuật
toán. Cùng một tập hợp thao tác nhưng xếp đặt theo trình tự khác nhau sẽ cho
kết quả khác nhau.
3. Các đặc trưng của thuật toán
+ Tính xác định: Các thao tác, các đối tượng, phương tiện trong thuật
toán phải có ý nghĩa rõ ràng, không được gây nhầm lẫn. Nói cách khác, hai cơ
chế hoạt động khác nhau cùng thực hiện một thuật toán, sử dụng các đối tượng,
phương tiện nhập phải cho cùng một kết quả.
4
Đề cương môn: Lập trình Cơ bản
+ Tính dừng: Đòi hỏi thuật toán phải dừng và cho kết quả sau một số hữu
hạn các bước.
+ Tính đúng của thuật toán: Thuật toán đúng là thuật toán cho kết quả
thỏa mãn đặc tả thuật toán với mọi trường hợp của các đối tượng, phương tiện
nhập.
+ Tính phổ dụng: Thuật toán để giải một lớp bài toán gồm nhiều bài cụ
thể, lớp đó được xác định bởi đặc tả. Dĩ nhiên là có lớp bài toán chỉ gồm 1 bài.
Thuật toán khi đó sẽ không cần sử dụng đối tượng, phương tiện nhập nào cả.
4. Phương pháp biểu diễn
Thuật toán có thể diễn đạt dưới nhiều hình thức, chẳng hạn dưới dạng lưu
đồ, dạng ngôn ngữ tự nhiên, dạng mã giả hoặc một ngôn ngữ lập trình nào khác.
a. Dạng ngôn ngữ tự nhiên: Thuật toán có thể trình bày dưới dạng ngôn
ngữ tự nhiên theo trình tự các bước thực hiện trong thuật toán.
b. Dạng ngôn ngữ lập trình: Dùng cấu trúc lệnh, dữ liệu của một ngôn
ngữ lập trình nào đó để mô tả.
c. Dạng mã giả: Thuật toán trình bày trong dạng văn bản bằng ngôn ngữ
tự nhiên tuy dễ hiểu nhưng khó cài đặt. Dùng một ngôn ngữ lập trình nào đó để
diễn tả thì phức tạp, khó hiểu. Thông thường thuật toán cũng được trao đổi dưới
dạng văn bản – tuy không ràng buộc nhiều vào cú pháp xác định như các ngôn
ngữ lập trình, nhưng cũng tuân theo một số quy ước ban đầu – ta gọi là dạng mã
giả. Tùy theo việc định hướng cài đặt thuật toán theo ngôn ngữ lập trình nào ta
diễn đạt thuật toán gần với ngôn ngữ ấy.
d. Dạng lưu đồ: Trong các phương pháp biểu diễn, chúng ta sẽ chủ yếu
nghiên cứu phương pháp biểu diễn theo dạng này.
Dạng lưu đồ dùng các hình vẽ (có quy ước) để diễn đạt thuật toán. Lưu đồ
cho hình ảnh trực quan và tổng thể của thuật toán, cho nên thường được sử
dụng nhiều nhất.
Các ký hiệu sử dụng trong phương pháp biểu diễn thuật toán bằng
lưu đồ:
STT
Ký hiệu
Giải thích
1
Bắt đầu và kết thúc chương trình
2
Điểm nối, đường đi (luồng xử lý)
5
Đề cương môn: Lập trình Cơ bản
3
Điều khiển lựa chọn
4
Thao tác nhập, xuất.
5
Thao tác xử lý hoặc tính toán.
6
Trả về giá trị (return)
7
Điểm nối liên kết tiếp theo (sử dụng khi lưu đồ vượt
quá trang)
Ví dụ 1: Đọc các thông tin như tên, tuối và lưu lại những người có tuổi trên
50.
Bắt đầu
Lưu đồ:
Đọc tên, tuổi
Sai
Nếu tuổi >
50?
Đúng
Thêm vào
danh sách
Sai
Là người cuối
cùng?
Đúng
Kết thúc
6
Đề cương môn: Lập trình Cơ bản
Ví dụ 2: dụ: Nhập vào 3 số nguyên a, b, c và xuất ra màn hình với giá trị
của mỗi số tăng lên 1.
Bắt đầu
Nhập a, b, c
a= a +1
b=b+1
c=c+1
Xuất a, b, c
7
Kết thúc
Đề cương môn: Lập trình Cơ bản
Chú ý khi vẽ lưu đồ:
+ Trước tiên hãy tập trung vẽ một số đường đi chính của lưu đồ.
+ Thêm vào tất cả các nhánh và vòng lặp.
+ Một lưu đồ chỉ có một điểm Bắt đầu và một điểm kết thúc.
+ Mỗi bước trong chương trình không cần thể hiện trong lưu đồ.
+ Lưu đồ cần phải đáp ứng được yêu cầu: những người lập trình khác có
thể hiểu lưu đồ một cách dễ dàng.
Bài tập luyện
Vẽ lưu đồ thuật toán cho các bài toán sau:
Bài 1: Tìm số lớn nhất trong 3 số a, b, c.
Bài 2: Giải phương trình bậc 1: ax + b = 0 (a ≠ 0).
Bài 3: Giải phương trình bậc 2: ax2 + bx + c = 0 (a ≠ 0).
Bài 4: Nhập vào hai số x, y. Xuất ra màn hình tổng, hiệu, tích, thương của
hai số trên.
Bài 5: Nhập vào số nguyên n, kiểm tra xem n chẵn hay lẻ và xuất ra màn
hình.
Bài 6: Nhập vào ba cạnh a, b, c của tam giác. Xuất ra màn hình tam giác
đó thuộc loại tam giác gì? (Thường, cân, vuông, đều hay vuông cân).
Bài 7: Tính n!, với n ≥ 0
8
Đề cương môn: Lập trình Cơ bản
Chương 2. Giới thiệu ngôn ngữ lập trình C++
1. Lịch sử hình thành
Ngôn ngữ lập trình C do Dennis Ritchie nghĩ ra khi ông làm việc tại AT&T
Bell Laboratories vào năm 1972. Không phải ngẫu nhiên mà Dennis Ritchie nghĩ
ra C. Vào thời gian đó ông cùng một vài đồng nghiệp có nhiệm vụ thiết kế một hệ
điều hành mới mà ngày nay chúng ta biết đến như là hệ điều hành UNIX. Trong
quá trình thiết kế, Dennis Ritchie nhận thấy trong tất cả các ngôn ngữ hiện có lúc
đó, không có ngôn ngữ nào thích hợp để họ có thể sử dụng vào đồ án của họ
được. Cuối cùng Dennis Ritchie quyết định làm ra một ngôn ngữ mới để giải
quyết những vấn đề mà họ gặp phải. Dennis Ritchie đẵ tham khảo rất nhiều các
ngôn ngữ có từ trước, và đặc biệt là ngôn ngữ B do Ken Thompson cũng làm
9
Đề cương môn: Lập trình Cơ bản
việc tại Bell Labs nghĩ ra. Rất nhiều phần của ngôn ngữ này được ông đưa vào
C. Chính vì vậy mà Dennis Ritchie đã chọn ngay chữ cái tiếp theo của B (tức là
C) để đặt tên cho ngôn ngữ mới này.
Vì C là một ngôn ngữ mạnh và có tính linh hoạt, nó đã nhanh chóng được
sử dụng một cách rộng rãi, vượt ra khỏi phạm vi của Bell Labs. Các lập trình viên
ở khắp mọi nơi bắt đầu sử dụng nó để viết tất cả các loại chương trình. Tuy
nhiên, nhiều tổ chức đã nhanh chóng đưa ra các versions C của riêng họ và
những sự khác biệt tinh tế của các phần được bổ sung bắt đầu khiến các lập
trình viên đau đầu. Vì vậy vào năm 1983, Viện tiêu chuẩn Quốc gia Hoa Kỳ (the
American National Standards Institute - ANSI) đã thành lập một ủy ban để đưa ra
một tiêu chuẩn cho C, được biết với cái tên ANSI C. Trừ một vài ngoại lệ, tất cả
các trình dịch C hiện đại đều cố gắng theo sát tiêu chuẩn này.
C++ được biết đến như là ngôn ngữ mới bao trùm lên C và do Bjarne
Stroustrup sáng tác năm 1980 cũng tại phòng thí nghiệm Bell tại bang New
Jersey, Mỹ. Ban đầu được ông đặt tên cho nó là “C with classes” (C với các lớp).
Tuy nhiên đến năm 1983 thì ông đổi tên thành C++, trong đó ++ là toán tử tăng
thêm 1 của C.
Mặc dù C là một ngôn ngữ được giới lập trình chuyên nghiệp yêu thích
song nó vẫn có những hạn chế của nó. Nếu một khi số dòng lệnh vượt hơn
25000 thì công việc sẽ trở nên rất phức tạp. C++ được tạo ra để xóa bỏ chướng
ngại này. Điều cơ bản của C++ là cho phép người lập trình hiểu và quản lý các
chương trình lớn, phức tạp hơn.
C++ được biết đến như là ngôn ngữ lập trình hướng sự vật hay hướng đối
tượng - OOP (Object Oriented Programming).
2. Đặc điểm
C là một ngôn ngữ mạnh và linh hoạt. “Những gì bạn có thể làm với C chỉ
thua có trí tưởng tượng của bạn mà thôi”. Ngôn ngữ không đưa ra các ràng buộc
đối với bạn. C được sử dụng trong nhiều dự án khác nhau, như viết hệ điều
hành, chương trình xử lý văn bản, đồ hoạ, bảng tính, và thậm chí cả chương
trình dịch cho các ngôn ngữ khác.
C là ngôn ngữ được các lập trình viên chuyên nghiệp ưa thích hơn cả.
Cũng vì vậy mà có sẵn rất nhiều các trình biên dịch (compiler) và các thư viện
được viết sẵn khác.
10
Đề cương môn: Lập trình Cơ bản
C là một ngôn ngữ khả chuyển (portable language). ghĩa là một chương
trình viết bằng C cho một hệ máy tính (ví dụ như IBM PC) có thể được dịch và
chạy trên hệ máy tính khác (chẳng hạn như DEC VAX) chỉ với rất ít các sử đổi.
Tính khả chuyển đã được bởi chuẩn ANSI cho C.
C chỉ gồm một số ít từ khoá (keywords) làm nền tảng để xây dựng các các
chức năng của ngôn ngữ. Có lẽ bạn nghĩ rằng một ngôn ngữ với nhiều từ khoá
(đôi khi còn được gọi là từ dành riêng - reserved words) sẽ mạnh hơn. Không
phải như vậy. Khi lập trình với C, bạn sẽ thấy rằng nó có thể dùng để lập trình
giải quyết bất kỳ bài toán nào.
C là ngôn ngữ lập trình theo modul. Mã chương trình C có thể (và nên)
được viết thành các thủ tục gọi là function. Những function này có thể được sử
dụng lại trong các ứng dụng (application) và chương trình khác nhau. Tuy nhiên
C không cho phép khai báo hàm trong hàm.
Đó là những đặc điểm nổi bật của C, vì C++ bao trùm lên C nên mọi đặc
điểm của C đều có trong C++. Ngoài ra, C++ còn có một số đặc điểm khác như:
+ C++ là ngôn ngữ hướng đối tượng.
+ C++ là ngôn ngữ định kiểu rất mạnh.
+ C++ cung cấp cách truyền tham số bằng tham chiếu cho hàm.
+ C++ cung cấp cơ cấu thư viện để người lập trình có thể tự tạo thêm hàm
thông dụng vào thư viện và có thể tái sử dụng sau này.
+ C++ cung cấp một cơ chế đa dạng hóa tên hàm và toán tử, cho phép sử
dụng cùng một tên hàm hoặc cùng một ký hiệu của toán tử để định nghĩa các
chương trình con thực hiện các nhiệm vụ tương tự nhau với tập kiểu dữ liệu
tham số khác nhau.
+ C++ cung cấp các class là loại cấu trúc mới đóng gói chung cho cả dữ
liệu lẫn các hàm trong một chủ thể được bảo vệ một cách chặt chẽ.
+ C++ Cung cấp các class con trong đó một class có thể kế thừa dữ liệu và
hàm của class khác là các class cha mẹ, tạo ra sự di truyền.
3. Cấu trúc của một chương trình C++
Một chương trình C++ nói chung có dạng như sau:
(1): Khai báo thư viện
(2): [Khai báo các nguyên mẫu hàm của người dùng].
(3): [Các định nghĩa kiểu].
(4): [Các định nghĩa Macro].
11
Đề cương môn: Lập trình Cơ bản
(5): [Các định nghĩa biến, hằng].
(6): <kiểu hàm> main ([khai báo tham số]).
(7): {
(8): Thân hàm main
(9): }
(10): Các định nghĩa hàm của người dùng.
Chú ý: Các thành phần trong cặp ngoặc vuông [] có thể có hoặc không
trong chương trình.
Giải thích cú pháp:
(1): Cú pháp để khai báo thư viện: #include<tên_thư_viên.h>
Ví dụ: #include<iostream.h>; #include<conio.h>;…
(2): Cung cấp tên hàm, kiểu hàm, số đối số và kiểu của từng đối số của
hàm.
Cú pháp khai báo nguyên mẫu hàm: <kiểu hàm> <tên hàm> ([Khai báo các
đối số]);
Ví dụ: int chanle (int x); Trong đó, kiểu hàm là int, tên hàm là chanle, đối
số là x và kiểu của đối số là int.
(3): Định nghĩa kiểu mới: Ngoài những kiểu chuẩn đã được cung cấp sẵn
của ngôn ngữ, người lập trình có thể định nghĩa ra các kiểu mới từ những kiểu
đã có bằng cách sử dụng từ khóa typedef.
(4): Định nghĩa Macro: Khái niệm macro là gì? Giả sử như bạn có một nội
dung (giá trị) nào đó và bạn muốn sử dụng nó nhiều lần trong chương trình,
nhưng bạn không muốn viết trực tiếp nó vào chương trình lúc bạn soạn thảo vì
một vài lý do nào đó (chẳng hạn như nó sẽ làm chương trình khó đọc, khó hiểu,
hoặc khi thay đổi sẽ khó,..). Lúc này bạn hãy gán cho nội dung đó một ‘tên’ và
bạn sử dụng ‘tên’ đó để viết trong chương trình nguồn. Khi biên dịch chương
trình, chương trình dịch sẽ tự động thay thế nội dung của ‘tên’ vào đúng vị trí của
‘tên’ đó. Thao tác này gọi là phép thế macro và chúng ta gọi ‘tên’ là tên của
macro và nội dung của nó được gọi là nội dung của macro.
Một macro được định nghĩa như sau:
#define tên_macro nội_dung
Trong đó tên macro là một tên hợp lệ, nội dung (giá trị) của macro được coi
thuần tuý là 1 xâu cần thay thế vào vị trí xuất hiện tên của macro tương ứng,
giữa tên và nội dung cách nhau 1 hay nhiều khoảng trống (dấu cách). Nội dung
12
Đề cương môn: Lập trình Cơ bản
của macro bắt đầu từ kí tự khác dấu trống đầu tiên sau tên macro cho tới hết
dòng.
(5): Các định nghĩa biến, hằng: Các biến và hằng được định nghĩa tại đây
sẽ trở thành biến và hằng toàn cục. Ý nghĩa về biến, hằng, cú pháp định nghĩa
đã được trình bày trong mục biến và hằng.
(6) – (9): Hàm main():Đây là thành phần bắt buộc trong một chương trình
C++, thân của hàm main bắt đầu từ sau dấu mở móc { (dòng 7) cho tới dấu đóng
móc } (dòng 9).
(10): Các định nghĩa hàm của người dùng: Một định nghĩa hàm bao gồm
tiêu đề của hàm, thân hàm với cú pháp như sau:
<Kiểu hàm> <Tên hàm> ([Khai báo các đối])
{
<Thân hàm>
}
Chú ý: Tiêu đề trong định nghĩa hàm phải tương ứng với nguyên mẫu hàm.
Nếu trong chương trình định nghĩa hàm xuất hiện trước khi gặp lời gọi hàm
đó thì có thể không nhất thiết phải có dòng khai báo nguyên mẫu hàm.
4. Một số ví dụ mẫu
Ví dụ 1: Chương trình nhập vào điểm 3 môn: Toán, Lý, Hóa và tính điểm
trung bình của 3 môn đó.
//Khai báo thư viện
#include<iostream.h>
//Bắt đầu hàm main
int main()
{
//Khai báo 3 biến
double dtb,dt,dl,dh;
//Nhập vào 3 điểm Toán, Lý, Hóa
cout<<"Diem toan la:";
cin>>dt;
cout<<"diem ly la:"; cin>>dl;
cout<<"Diem hoa la:"; cin>>dh;
dtb = (dt+dl+dh)/3;
cout<<"diem trung binh 3 mon la:"<<"="<
Đề cương môn: Lập trình Cơ bản
if (dtb<5)
cout<<"Hoc luc yeu";
if (dtb>=5&&dtb<7)
cout<<"Hoc luc trung binh";
if (dtb>=7 && dtb<8)
cout<<"Hoc luc kha";
else
cout<<"Hoc luc gioi";
return 0;
} //Kết thúc hàm main
Ví dụ 2: Viết chương trình có sử dụng hàm tìm số lớn nhất trong 3 số x, y,
z;
//Khai báo thư viện
#include<iostream.h>
//Khai báo hàm có tên là maxabc
float maxabc (float a, float b, float c)
{
float max;
max = a>b?a:b;
return (max>c?max:c);
}
//Bắt đầu hàm main
main()
{
//Khai báo 4 biến
float x,y,z,t;
//Nhập giá trị cho các biến
cout<<"x = "; cin>>x;
cout<<"y = "; cin>>y;
cout<<"z = "; cin>>z;
t = maxabc (x,y,z);
cout<<"So lon nhat trong 3 so la: "<
14
Đề cương môn: Lập trình Cơ bản
5. Cài đặt chương trình
Chúng ta sẽ sử dụng Turbo C++ 4.5 trong phần tài liệu này.
Để cài đặt Turbo C++ 4.5 bạn làm theo hướng dẫn sau:
Bước 1: Vào thư mục chứa bộ cài TurboC++ 4.5, chọn file Install.exe, click
đúp vào thư mục đó. Xuất hiện hình sau:
Bước 2: Click Continue. Màn hình sau hiện ra:
Bước 3: Tắt màn hình Install.txt. Màn hình sau hiện ra, bạn click Continue:
15
Đề cương môn: Lập trình Cơ bản
Bước 4: Click Continue:
Bước 5: Màn hình sau hiện ra, bạn click vào Install:
16
Đề cương môn: Lập trình Cơ bản
Bước 6: Quá trình cài đặt bắt đầu chạy. Sau khi quá kết thúc quá trình đó,
màn hình sau hiện ra, bạn click Continue:
Bước 7: Màn hình hiển thị Readme.txt. Bạn close cửa sổ đó lại. Click OK.
Bước 8: Màn hình hiển thị đăng ký:
Bước 9: Bạn điền đầy đủ thông tin vào các mục trong hình sau:
17
Đề cương môn: Lập trình Cơ bản
Bước 10: Click Continue/Ok.
Các bước cài đặt đã hoàn tất.
6. Khởi động chương trình
Để khởi động chương trình bạn sử dụng một số cách sau:
Cách 1: Start/Program/Turbo C++ 4.5/Turbo C++.
Cách 2: Click đúp vào biểu tượng Turbo C++ trên màn hình.
7. Soạn thảo chương trình
Màn hình soạn thảo của Turbo C++ 4.5 có dạng sau:
18
Đề cương môn: Lập trình Cơ bản
8. Thoát khỏi chương trình
Trước khi thoát khỏi chương trình Turbo C++, bạn hãy Save/Save as toàn
bộ chương trình.
Để thoát khỏi chương trình có thể sử dụng một số cách sau:
Cách 1: Click menu File/Exit.
Cách 2: Click vào biểu tượng
bên phải màn hình.
19
Đề cương môn: Lập trình Cơ bản
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
Các thành phần trong C++ bao gồm:
+ Từ khóa.
+ Các khai báo biến, hằng.
+ Các cấu trúc điều khiển.
+ Biểu thức và các phép toán.
+ Các định nghĩa, khai báo hàm, khai báo kiểu,…
2. Các kiểu dữ liệu căn bản
Một trong mục đích của các chương trình là xử lý, biến đổi thông tin, các
thông tin cần xử lý phải được biểu diễn theo một cấu trúc xác định nào đó ta gọi
là các kiểu dữ liệu. Các kiểu dữ liệu này được quy định bởi ngôn ngữ lập trình,
hay nói khác đi mỗi ngôn ngữ có tập các kiểu dữ liệu khác nhau. Không hoàn
toàn giống như khái niệm kiểu dữ liệu trong toán học, trong các ngôn ngữ lập
trình nói chung mỗi kiểu dữ liệu chỉ biểu diễn được một miền giá xác định nào đó.
Chẳng hạn như số nguyên chúng ta hiểu là các số nguyên từ - ∞ tới + ∞, nhưng
trong ngôn ngữ lập trình miền các giá trị này bị giới hạn, sự giới hạn này phụ
thuộc vào kích thước của vùng nhớ biểu diễn số đó. Vì vậy khi nói tới một kiểu
dữ liệu chúng ta phải đề cập tới 3 thông tin đặc trưng của nó đó là:
- Tên kiểu dữ liệu.
- Kích thước vùng nhớ biểu diễn nó,miền giá trị.
- Các phép toán có thể sử dụng.
Các kiểu dữ liệu đơn giản trong C++ chỉ là các kiểu số, thuộc hai nhóm
chính đó là số nguyên và số thực (số dấu phẩy động).
Nhóm các kiểu nguyên gồm có: char, unsigned char, int, unsigned int,
short, unsigned short, long, unsigned long được mô tả trong bảng sau:
Kiểu dữ liệu
Kí tự có dấu
Kí tự không dấu
Số nguyên có dấu
Số nguyên không dấu
Tên kiểu
(từ khoá)
Kích thước
char
1 byte
từ -128 tới 127
unsigned char
1 byte
từ 0 tới 255
int
2 byte
từ -32768 tới 32767
unsigned int
2 byte
từ 0 tới 65535
20
Miền giá trị
Đề cương môn: Lập trình Cơ bản
2 byte
Số nguyên ngắn có dấu
short
Số nguyên ngắn có dấu
unsigned short
2 byte
từ 0 tới 65535
long
4 byte
từ -2,147,483,648 tới
2,147,438,647
unsigned long
4 byte
từ 0 tới 4,294,967,295
Số nguyên dài có dấu
Số nguyên dài không dấu
từ -32768 tới 32767
Nhóm các kiểu số thực gồm: float, double, long double
Khuôn dạng biểu diễn của số thực không giống như số nguyên. Một số
thực nói chung được biểu diễn theo ký pháp khoa học gồm phần định trị và phần
mũ viết sau chữ E để biểu diễn số mũ cơ số 10.
Ví dụ: 3.14 = 314*10-2 sẽ được viết theo ký pháp khoa học là: 314E – 2.
Hoặc: 314 = 3.14 *102 sẽ được viết theo ký pháp khoa học là: 3.14E + 2.
Nhóm các kiểu số thực được mô tả trong bảng sau:
Kiểu dữ liệu
Tên kiểu
Kích thước
Miền giá trị
Số thực với độ chính xác đơn
float
4 byte
3.4e-38 -> 3.4e38
Số thực với độ chính xác kép
double
8 byte
1.7e-308 -> 1.7e308
Số thực dài với độ chính xác
kép
long
double
10 byte
3.4e-4832 -> 1.1e 4932
3. Hằng
3.1. Khái niệm
Hằng là đại lượng có giá trị thuộc một kiểu dữ liệu nhất định, nhưng giá trị
của hằng không thể thay đổi trong thời gian tồn tại của nó.
Có hai loại hằng một là các hằng không có tên (chúng ta sẽ gọi là hằng
thường) đó là các giá trị cụ thể tức thời như : 8, hay 9.5 hoặc ‘d’.
Loại thứ hai là các hằng có tên ( gọi là hằng ký hiệu). Các hằng ký hiệu
cũng phải định nghĩa trước khi sử dụng, tên của hằng được đặt theo quy tắc của
tên. Sau đây nếu không có điều gì đặc biệt thì chúng ta gọi chung là hằng.
3.2. Định nghĩa hằng
Các hằng được định nghĩa bằng từ khoá const với cú pháp như sau:
const <kiểu_dữ_liệu> <tên_hằng> = <giá_trị>;
hoặc const <tên_hằng> = <giá_trị>;
21
Đề cương môn: Lập trình Cơ bản
Trong dạng thứ hai, chương trình dịch tự động ấn định kiểu của hằng là
kiểu ngầm định, chương trình dịch sẽ tự động chuyển kiểu của <giá_trị> về kiểu
int.
Ví dụ:
const int a = 5; // định nghĩa hằng a kiểu nguyên, có giá trị là 5
const float x = 4; // hằng x kiểu thực, có giá trị là 4.0
const d = 7; // hằng d kiểu int, giá trị là 7
const c = ‘1’; // hằng c kiểu int giá trị = 49
const char * s = “Ngon ngu C++”;// s là hằng con trỏ, trỏ tới xâu “Ngo ngu
C++”
Các hằng số trong C++ được ngầm hiểu là hệ 10, nhưng bạn có thể viết
các hằng trong hệ 16 hoặc 8 bằng cú pháp, giá trị số hệ 16 được bắt đầu bằng
0x, ví dụ như 0x24, 0xA, các số hệ 8 bắt đầu bởi số 0, ví dụ 025, 057.
Các hằng kí tự được viết trong cặp dấu nháy đơn ‘’ : ví dụ ‘a’, ‘2’ các giá trị
này được C++ hiểu là số nguyên có giá trị bằng mã của kí tự; ‘a’ có giá trị là 97,
‘B’ có giá trị bằng 66.
Các xâu kí tự là dãy các kí tự được viết trong cặp dấu nháy kép “”, ví dụ
“Ngon ngu C”, “a” (là kiểu xâu kí tự ).
Chú ý: Các biến, hằng có thể được định nghĩa ngoài mọi hàm, trong hàm
hoặc trong một khối lệnh. Với C chuẩn thì khi định nghĩa biến, hằng trong một
khối thì dòng định nghĩa phải ở các dòng đầu tiên của khối, tức là trước tất cả
các lệnh khác của khối, nhưng trong C++ bạn có thể đặt dòng định nghĩa bất kỳ
vị trí nào.
4. Các phép toán của C++
STT
PHÉP
TOÁN
Ý NGHĨA
GHI CHÚ
PHÉP TOÁN SỐ HỌC
1
+
Cộng
2
-
Trừ
3
*
Nhân
4
/
Chia lấy phần nguyên
5
%
Chia lấy phần dư
PHÉP TOÁN QUAN HỆ
22
Đề cương môn: Lập trình Cơ bản
1
>
Lớn hơn
2
<
Nhỏ hơn
3
>=
Lớn hơn hoặc bằng
4
<=
Nhỏ hơn hoặc bằng
5
==
Bằng nhau
6
!=
Khác nhau
PHÉP TOÁN LOGIC
1
!
NOT
2
&&
AND
3
||
OR
TOÁN TỬ TĂNG GIẢM
1
++
Tăng 1
2
--
Giảm 1
Nếu toán tử tăng giảm đặt trước thì
tăng giảm trước rồi tính biểu thức
hoặc ngược lại.
PHÉP TOÁN THAO TÁC TRÊN BIT
1
&
AND
2
|
OR
3
^
XOR
4
<<
Dịch trái
5
>>
Dịch phải
6
~
Lấy phần bù theo bit
5. Xuất nhập dữ liệu
Trong thư viện iostream của C++, các thao tác vào ra cơ bản của một
chương trình được hỗ trợ bởi hai dòng dữ liệu: cin để nhập dữ liệu và cout để
xuất. Thông thường cout được gán với màn hình còn cin được gán với bàn phím.
5.1. Xuất dữ liệu (cout)
Dòng cout được sử dụng với toán tử đã quá tải << (overloaded - bạn sẽ
hiểu rõ hơn về thuật ngữ này trong phần lập trình hướng đối tượng).
cout << "Output sentence"; // Hiển thị Output sentence lên màn hình
cout << 120; // Hiển thị số 120 lên màn hình
cout << x; // Hiển thị nội dung biến x lên màn hình
23
Đề cương môn: Lập trình Cơ bản
Toán tử << được gọi là toán tử chèn vì nó chèn dữ liệu đi sau nó vào dòng
dữ liệu đứng trước. Trong ví dụ trên nó chèn chuỗi "Output sentence", hằng số
120 và biến x vào dòng dữ liệu ra cout. Chú ý rằng ở dòng đầu tiên chúng ta sử
dụng dấu ngoặc kép vì đó là một chuỗi ký tự. Khi chúng ta muốn sử dụng các
hằng xâu ký tự ta phải đặt chúng trong cặp dấu ngoặc kép để chúng có thể được
phân biệt với các biến. Ví dụ, hai lệnh sau đây là hoàn toàn khác nhau:
cout << "Hello"; // Hiển thị Hello lên màn hình
cout << Hello; // Hiển thị nội dung của biến Hello lên màn hình
Toán tử chèn (<<) có thể được sử dụng nhiều lần trong một câu lệnh:
cout << "Hello, " << "I am " << "a C++ sentence";
Câu lệnh trên sẽ in thông báo Hello, I am a C++ sentence lên màn hình.
Sự tiện lợi của việc sử dụng lặp lại toán tử chèn (<<) thể hiện rõ khi chúng ta
muốn hiển thị nhiều biến và hằng hơn là chỉ một biến:
cout << "Hello, I am " << age << " years old and my email address is " <<
email_add;
Cần phải nhấn mạnh rằng cout không nhảy xuống dòng sau khi xuất dữ
liệu, vì vậy hai câu lệnh sau:
cout << "This is a sentence.";
cout << "This is another sentence.";
sẽ được hiển thị trên màn hình:
This is a sentence.This is another sentence.
Bởi vậy khi muốn xuống dòng chúng ta phải sử dụng ký tự xuống dòng,
trong C++ là \n:
cout << "First sentence.\n ";
cout << "Second sentence.\nThird sentence.";
sẽ viết ra màn hình như sau:
First sentence.
Second sentence.
Third sentence.
Thêm vào đó, để xuống dòng bạn có thể sử dụng tham số endl. Ví dụ:
cout << "First sentence." << endl;
cout << "Second sentence." << endl;
sẽ in ra màn hình:
First sentence.
Second sentence.
24
Đề cương môn: Lập trình Cơ bản
Tham số endl có một tác dụng đặc biệt khi nó được dùng với các dòng dữ
liệu sử dụng bộ đệm: Các bộ đệm sẽ được flushed (chuyển toàn bộ thông tin từ
bộ đệm ra dòng dữ liệu). Tuy nhiên, theo mặc định cout không sử dụng bộ đệm.
Các ký tự điều khiển
Đây là các kí tự đặc biệt, bắt đầu bằng kí tự \ tiếp theo là 1 kí tự dùng để
điều khiển: chuyển con trỏ màn hình, vị trí in dữ liệu,..
- \n : chuyển con trỏ màn hình xuống dòng mới
- \t : dấu tab
- \b : (backspace) lùi một kí tự (xoá kí tự trước vị trí con trỏ hiện tại).
5.2. Nhập dữ liệu (cin)
Thao tác vào chuẩn trong C++ được thực hiện bằng cách sử dụng toán tử
đã quá tải >> với dòng cin. Theo sau toán tử này là biến sẽ lưu trữ dữ liệu được
đọc vào. Ví dụ:
int age;
cin >> age;
khai báo biến age có kiểu int và đợi nhập dữ liệu từ cin (bàn phím) để lưu
trữ nó trong biến kiểu nguyên này.
cin chỉ bắt đầu xử lý dữ liệu nhập từ bàn phím sau khi phím Enter được gõ.
Vì vậy dù bạn chỉ nhập một ký tự thì cin vẫn sẽ kiên nhẫn chờ cho đến khi bạn gõ
phím Enter.
Chương 4. Các cấu trúc điều khiển
1. Lệnh đơn và lệnh phức
1.1. Lệnh đơn
Một biểu thức kiểu như: a =5; a+ =6;… trở thành câu lệnh khi có đi kèm
theo dấu chấm phẩy (;) phía cuối câu.
25
