Xem mẫu
- Đề cương môn: Lập trình Cơ bản
Mục lục
Chương 1. Thuật toán............................................................................................ 4
1. Ví dụ ............................................................................................................... 4
2. Khái niệm ........................................................................................................ 4
3. Các đặc trưng của thuật toán ......................................................................... 5
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++ ..................................................... 10
1. Lịch sử hình thành ........................................................................................ 10
2. Đặc điểm ....................................................................................................... 11
3. Cấu trúc của 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
7. Soạn thảo chương trình ................................................................................ 19
8. Thoát khỏi chương trình ............................................................................... 20
Chương 3. Các thành phần và các kiểu dữ liệu cơ bản ...................................... 21
1. Các thành phần ............................................................................................ 21
2. Các kiểu dữ liệu căn bản .............................................................................. 21
3. Hằng ............................................................................................................. 22
3.1. Khái niệm ............................................................................................... 22
3.2. Định nghĩa hằng ..................................................................................... 22
4. Các phép toán của C++ ................................................................................ 23
5. Xuất nhập dữ liệu ......................................................................................... 24
5.1. Xuất dữ liệu (cout) .................................................................................. 24
5.2. Nhập dữ liệu (cin) ................................................................................... 26
Chương 4. Các cấu trúc điều khiển ..................................................................... 27
1. Lệnh đơn và lệnh phức ................................................................................. 27
1.1. Lệnh đơn ................................................................................................ 27
1.2. Lệnh phức hay khối lệnh ........................................................................ 27
2. Cấu trúc điều kiện if..else ............................................................................. 27
2.1. Dạng khuyết ........................................................................................... 27
2.2. Dạng đầy đủ ........................................................................................... 28
3. Cấu trúc lựa chọn: switch..case.................................................................... 30
4. Các cấu trúc lặp ............................................................................................ 33
4.1. Cấu trúc lặp while ................................................................................... 33
4.2. Cấu trúc lặp do..while ............................................................................. 35
4.3. Cấu trúc lặp for ....................................................................................... 37
5. Câu lệnh break, continue, goto và hàm exit ................................................. 39
5.1. Câu lệnh break ....................................................................................... 39
5.2. Câu lệnh continue .................................................................................. 40
5.3. Câu lệnh goto ......................................................................................... 40
5.4. Hàm exit ................................................................................................. 41
Chương 5. Hàm ................................................................................................... 42
1. Khái niệm ...................................................................................................... 42
2. Khai báo hàm ................................................................................................ 42
1
- Đề cương môn: Lập trình Cơ bản
2.1. Cú pháp khai báo nguyên mẫu hàm ...................................................... 42
2.2. Định nghĩa hàm ...................................................................................... 42
3. Kết quả trả về của hàm – Lệnh return .......................................................... 43
4. Lời gọi hàm và Cách truyền tham số cho hàm ............................................. 44
5. Đệ qui ........................................................................................................... 45
5.1. Khái niệm ............................................................................................... 45
5.2. Ví dụ ....................................................................................................... 45
Bài tập luyện: ....................................................................................................... 45
Chương 6. Mảng .................................................................................................. 47
1. Khái niệm ...................................................................................................... 47
2. Khai báo mảng .............................................................................................. 47
2.1. Khai báo mảng ....................................................................................... 47
2.2. Truy xuất đến các phần tử của mảng..................................................... 47
3. Khởi tạo mảng .............................................................................................. 48
4. Dùng mảng làm tham số............................................................................... 50
5. Với mảng hai chiều ....................................................................................... 52
5.1. Định nghĩa .............................................................................................. 52
5.2. Truy xuất các phần tử mảng hai chiều ................................................... 52
5.3. Khởi tạo giá trị mảng hai chiều ............................................................... 53
5.4. Ví dụ ....................................................................................................... 54
Bài tập luyện ........................................................................................................ 55
Chương 7. Con trỏ ............................................................................................... 56
1. Khái niệm ...................................................................................................... 56
2. Toán tử lấy địa chỉ (&) .................................................................................. 56
3. Toán tử tham chiếu (*) .................................................................................. 57
4. Khai báo biến kiểu con trỏ. ........................................................................... 57
5. Các phép toán .............................................................................................. 58
5.1. Phép gán ............................................................................................... 58
5.2. Phép tăng giảm địa chỉ .......................................................................... 58
5.3. Phép truy nhập bộ nhớ .......................................................................... 58
5.4. Phép so sánh ........................................................................................ 59
6. Con trỏ hằng ................................................................................................. 59
7. Con trỏ mảng ................................................................................................ 59
8. Khởi tạo con trỏ ............................................................................................ 60
9. Con trỏ trỏ tới con trỏ .................................................................................... 62
10. Con trỏ không kiểu...................................................................................... 62
11. Con trỏ hàm ................................................................................................ 63
Chương 8. Cấu trúc ............................................................................................. 65
1. Khái niệm cấu trúc ........................................................................................ 65
2. Khai báo cấu trúc .......................................................................................... 65
2.1. Kiểu cấu trúc .......................................................................................... 65
2.2. Khai báo thành phần (biến, mảng) kiểu cấu trúc ................................... 67
3. Truy cập đến các thành phần của cấu trúc .................................................. 67
4. Ví dụ cấu trúc ................................................................................................ 68
Bài tập luyện: ....................................................................................................... 71
2
- Đề cương môn: Lập trình Cơ bản
Chương 9. File ..................................................................................................... 73
1. Khái niệm File ............................................................................................... 73
2. Tạo file đọc file .............................................................................................. 73
2.1. Khai báo con trỏ trỏ đến tập tin .............................................................. 74
2.2. Mở tập tin ............................................................................................... 74
2.3. Các kiểu xử lý tệp thông dụng................................................................ 75
2.4. Đóng tập tin ............................................................................................ 76
2.5. Kiểm tra đến cuối tập tin hay chưa......................................................... 76
2.6. Các xử lý trên tập tin .............................................................................. 76
2.7. Truy cập đến tập tin văn bản (text)......................................................... 77
3. Tạo file nhị phân ........................................................................................... 80
4. Đọc file nhị phân ........................................................................................... 81
4.1. Ghi dữ liệu lên tệp nhị phân ................................................................... 81
4.2. Đọc dữ liệu từ tập tin nhị phân - Hàm fread() ........................................ 81
4.3. Di chuyển con trỏ tập tin - Hàm fseek() .................................................. 81
Bài tập luyện ........................................................................................................ 83
Tài liệu tham khảo ................................................................................................ 87
3
- Đề cương môn: Lập trình Cơ bản
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.
…
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.
4
- Đề cương môn: Lập trình Cơ bả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ả.
+ 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.
5
- Đề cương môn: Lập trình Cơ bản
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ý)
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)
Điểm nối liên kết tiếp theo (sử dụng khi lưu đồ vượt
7
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.
Lưu đồ:
6
- Đề cương môn: Lập trình Cơ bản
Bắt đầu
Đọc tên, tuổi
Nếu tuổi > 50? Sai
Đúng
Thêm vào
danh sách
Là người cuối Sai
cùng?
Đúng
Kết thúc
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.
7
- Đề cương môn: Lập trình Cơ bản
Bắt đầu
Nhập a, b, c
a= a +1
b=b+1
c=c+1
Xuất a, b, c
Kết thúc
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).
8
- Đề cương môn: Lập trình Cơ bản
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
9
- Đề 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
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.
10
- Đề cương môn: Lập trình Cơ bả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.
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
11
- Đề cương môn: Lập trình Cơ bản
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].
(5): [Các định nghĩa biến, hằng].
(6): 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
Ví dụ: #include; #include;…
(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: ([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,
12
- Đề cương môn: Lập trình Cơ bản
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
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:
([Khai báo các đối])
{
}
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
13
- Đề cương môn: Lập trình Cơ bản
//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
coutdt;
coutdl;
coutdh;
dtb = (dt+dl+dh)/3;
cout
- Đề cương môn: Lập trình Cơ bản
{
//Khai báo 4 biến
float x,y,z,t;
//Nhập giá trị cho các biến
coutx;
couty;
coutz;
t = maxabc (x,y,z);
cout
- Đề cương môn: Lập trình Cơ bản
Bước 3: Tắt màn hình Install.txt. Màn hình sau hiện ra, bạn click Continue:
Bước 4: Click Continue:
16
- Đề cương môn: Lập trình Cơ bản
Bước 5: Màn hình sau hiện ra, bạn click vào Install:
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:
17
- Đề cương môn: Lập trình Cơ bản
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:
18
- Đề 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:
19
- Đề 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.
20
nguon tai.lieu . vn
