Lập Trình Cấu Trúc Với Ngôn Ngữ C++.Docx
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (1.83 MB, 188 trang )
LỜI NĨI ĐẦU
Đối với sinh viên chun ngành Cơng nghệ thơng tin thì một trong những u
cầu cơ bản nhất là phải có kiến thức lập trình vững vàng. Để sử dụng thành thạo một
Ngơn ngữ lập trình địi hỏi thời gian, sự kiên trì và sự đam mê. Chính vì thế mà Tài
liệu giảng dạy mơn Lập trình cấu trúc với ngơn ngữ C++ ra đời với mục đích giúp sinh
viên chuyên ngành Công nghệ thông tin làm quen dần với các kỹ thuật lập trình cơ
bản. Bên cạnh đó, tài liệu này giúp các bạn bước đầu phát triển kỹ năng, tư duy lập
trình thơng qua các cấu trúc lệnh, cách chọn lựa cấu trúc dữ liệu.
Với mục đích đem lại sự đơn giản và thân thiện, tác giả đã cố gắng trình bày một
cách ngắn gọn, xúc tích, dễ hiểu kèm theo là các ví dụ và kết quả thực nghiệm. Vì là
mơn học cơ sở ngành nên việc nêu các ví dụ, các bài tốn mang tính thực tế vào tài
liệu là khá khó khăn. Nhưng tác giả cũng cố gắng tìm kiếm để trình bày các ví dụ mơ
phỏng mang thực tế như: Chương trình cấp bản số xe tự động, chương trình tính tiền
tiết kiệm, chương trình quản lý, …
Ngồi ra mơn học Lập trình cấu trúc với ngơn ngữ C++ là nền tảng cơ sở để
người học tiếp cận với kỹ thuật lập trình hiện đại hơn đó là lập trình hướng đối tượng.
Kỹ thuật lập trình này được sử dụng rộng rãi trong việc phát triển các ứng dụng hiện
đại, đặc biệt là lập trình trên các thiết bị di động.
Với mong muốn đem lại chất lượng cho người học. Tuy nhiên, chắc tài liệu cũng
cịn một số thiếu xót nào đó. Vì thế tác giả mong muốn sự góp ý của người đọc.
Trân trọng
Tác giả
ThS. Nguyễn Lê Tín
MỤC LỤC
Chương 1: GIỚI THIỆU NGÔN NGỮ C++............................................................8
1.1. Các khái niệm cơ bản..............................................................................................8
1.1.1.
Bảng kí tự của C++............................................................................................8
1.1.2.
Từ khóa...............................................................................................................9
1.1.3.
Tên gọi................................................................................................................9
1.1.4.
Chú thích trong chương trình...........................................................................10
1.2. Mơi trường làm việc của C++...............................................................................10
1.2.1.
Khởi động và thốt...........................................................................................10
1.2.2.
Giao diện chương trình.....................................................................................11
1.2.3.
Cấu trúc một chương trình...............................................................................11
1.3. Các bước xây dựng chương trình..........................................................................13
1.3.1.
Xây dựng chương trình.....................................................................................13
1.3.2.
Soạn thảo chương trình nguồn.........................................................................14
1.3.3.
Biên dịch chương trình.....................................................................................14
1.3.4.
Thực thi chương trình.......................................................................................15
1.4. Xuất nhập trong C++............................................................................................15
1.4.1.
Nhập dữ liệu từ bàn phìm.................................................................................15
1.4.2.
Xuất dữ liệu ra màn hình..................................................................................16
1.4.3.
Định dạng dữ liệu cần in ra màn hình..............................................................18
BÀI TẬP CHƯƠNG 1..................................................................................................21
Chương 2: KIỂU DỮ LIỆU, BIỂU THỨC VÀ CÂU LỆNH................................22
2.1. Kiểu dữ liệu cơ bản...............................................................................................22
2.1.1.
Khái niệm.........................................................................................................22
2.1.2.
Kiểu kí tự..........................................................................................................23
2.1.3.
Kiểu số nguyên.................................................................................................25
2.1.4.
Kiểu số thực......................................................................................................25
2.2. Hằng......................................................................................................................26
2.2.1.
Hằng nguyên.....................................................................................................26
2.2.2.
Hằng thực.........................................................................................................26
2.2.3.
Hằng kí tự.........................................................................................................27
2
2.2.3.1. Cách viết hằng..................................................................................................27
2.2.3.2. Một số hằng kí tự..............................................................................................27
2.2.4.
Hằng chuỗi kí tự...............................................................................................28
2.2.5.
Khai báo hằng...................................................................................................28
2.3. Biến.......................................................................................................................30
2.3.1.
Khai báo biến....................................................................................................30
2.3.2.
Phạm vi của biến..............................................................................................31
2.3.3.
Gán giá trị cho biến..........................................................................................31
2.3.4.
Một số lưu ý về phép gán.................................................................................32
2.4. Phép toán, biểu thức và câu lệnh..........................................................................32
2.4.1.
Phép toán..........................................................................................................32
2.4.1.1. Toán tử số học..................................................................................................32
2.4.1.2. Phép toán tự tăng, giảm....................................................................................33
2.4.1.3. Phép toán so sánh và logic...............................................................................33
2.4.2.
Các phép gán....................................................................................................36
2.4.3.
Biểu thức..........................................................................................................36
2.4.3.1. Thứ tự ưu tiên của phép toán............................................................................37
2.4.3.2. Phép chuyển đổi kiểu.......................................................................................38
2.4.4.
Câu lệnh và khối lệnh.......................................................................................39
2.5. Thư viện các hàm toán học...................................................................................40
BÀI TẬP CHƯƠNG 2..................................................................................................41
Chương 3: CẤU TRÚC ĐIỀU KHIỂN VÀ DỮ LIỆU KIỂU MẢNG.................43
3.1. Cấu trúc rẽ nhánh..................................................................................................43
3.1.1.
Câu lệnh điều khiển if......................................................................................43
3.1.1.1. Cú pháp............................................................................................................43
3.1.1.2. Lưu đồ hoạt động............................................................................................43
3.1.1.3. Đặc điểm...........................................................................................................44
3.1.1.4. Ví dụ minh họa.................................................................................................44
3.1.2.
Câu lệnh switch................................................................................................46
3.1.2.1. Cú pháp............................................................................................................46
3.1.2.2. Lưu đồ hoạt động.............................................................................................47
3.1.2.3. Đặc điểm...........................................................................................................47
3
3.1.2.4. Ví dụ minh họa.................................................................................................47
3.1.3.
Lệnh goto..........................................................................................................50
3.1.3.1. Cú pháp............................................................................................................50
3.1.3.2. Ví dụ minh họa.................................................................................................50
3.2. Cấu trúc lặp...........................................................................................................51
3.2.1.
Lệnh lặp for......................................................................................................52
3.2.1.1. Cú pháp............................................................................................................52
3.2.1.2. Lưu đồ hoạt động.............................................................................................52
3.2.1.3. Ví dụ minh họa.................................................................................................53
3.2.2.
Lệnh for lồng nhau...........................................................................................56
3.2.2.1. Cú pháp............................................................................................................56
3.2.2.2. Ví dụ minh họa.................................................................................................56
3.2.3.
Lệnh lặp while..................................................................................................57
3.2.3.1. Cú pháp............................................................................................................57
3.2.3.2. Lưu đồ hoạt động.............................................................................................57
3.2.3.3. Ví dụ minh họa.................................................................................................58
3.2.4.
Lệnh lặp do … while........................................................................................63
3.2.4.1. Cú pháp............................................................................................................63
3.2.4.2. Lưu đồ hoạt động.............................................................................................63
3.2.4.3. Ví dụ minh họa.................................................................................................64
3.2.5.
Ngắt vòng lặp...................................................................................................66
3.2.5.1. break ...............................................................................................................66
3.2.5.2. continue............................................................................................................66
3.2.6.
So sánh cách dùng các vòng lặp.......................................................................67
3.3. Mảng dữ liệu.........................................................................................................68
3.3.1.
Mảng một chiều................................................................................................68
3.3.1.1. Khái niệm.........................................................................................................68
................................................................................................................
3.3.1.2. Khai báo...........................................................................................................68
3.3.1.3. Cách sử dụng....................................................................................................69
3.3.1.4. Ví dụ minh họa.................................................................................................69
3.3.2.
Chuỗi kí tự........................................................................................................73
4
3.3.2.1. Giới thiệu..........................................................................................................73
................................................................................................................
3.3.2.2. Khai báo...........................................................................................................73
3.3.2.3. Cách sử dụng....................................................................................................74
3.3.2.4. Một số hàm xử lý chuỗi....................................................................................76
3.3.2.5. Một số ví dụ tổng hợp......................................................................................82
3.4. Mảng hai chiều.....................................................................................................88
3.4.1.
Giới thiệu..........................................................................................................88
3.4.2.
Khai báo...........................................................................................................88
3.4.3.
Sử dụng.............................................................................................................89
3.4.4.
Các ví dụ minh họa...........................................................................................89
BÀI TẬP CHƯƠNG 3..................................................................................................94
Chương 4: HÀM VÀ CHƯƠNG TRÌNH...............................................................99
4.1. Con trỏ và địa chỉ..................................................................................................99
4.1.1.
Địa chỉ và phép toán &.....................................................................................99
4.1.2.
Con trỏ (pointer).............................................................................................101
4.1.2.1. Ý nghĩa ..........................................................................................................101
4.1.2.2. Khai báo.........................................................................................................101
4.1.2.3. Sử dụng con trỏ, phép toán *..........................................................................101
4.1.3.
Các phép toán với con trỏ...............................................................................102
4.1.3.1. Phép toán gán.................................................................................................102
................................................................................................................
4.1.3.2. Phép toán tăng giảm địa chỉ...........................................................................102
4.1.3.3. Phép toán tự tăng giảm...................................................................................103
4.1.3.4. Hiệu của hai con trỏ........................................................................................104
4.1.3.5. Phép toán so sánh...........................................................................................104
4.1.4.
Cấp phát động.................................................................................................105
4.1.5.
Con trỏ, mảng, chuỗi kí tự..............................................................................108
4.1.5.1. Con trỏ và mảng một chiều............................................................................108
................................................................................................................
4.1.5.2. Con trỏ và chuỗi kí tự.....................................................................................109
4.1.5.3. Con trỏ và mảng hai chiều..............................................................................109
5
4.1.6.
Mảng con trỏ..................................................................................................112
4.1.6.1. Giới thiệu........................................................................................................112
4.1.6.2. Mảng chuỗi kí tự............................................................................................112
4.2. Hàm (function)....................................................................................................113
4.2.1.
Khai báo.........................................................................................................114
4.2.2.
Định nghĩa hàm..............................................................................................115
4.2.3.
Sử dụng hàm...................................................................................................117
4.2.4.
Hàm với tham số mặc định.............................................................................119
4.2.5.
Khai báo hàm trùng tên..................................................................................120
4.2.6.
Biến, biến tham chiếu.....................................................................................121
4.2.7.
Các cách truyền tham số.................................................................................122
4.2.7.1. Truyền tham trị...............................................................................................123
4.2.7.2. Truyền theo con trỏ........................................................................................124
4.2.7.3. Truyền tham biến............................................................................................126
4.2.8.
Hàm và mảng dữ liệu.....................................................................................127
4.2.8.1. Truyền mảng một chiều cho hàm...................................................................127
4.2.8.2. Truyền mảng hai chiều cho hàm....................................................................129
4.2.8.3. Giá trị trả về của hàm là mảng.......................................................................132
4.2.8.4. Tham số và giá trị trả về là chuỗi kí tự...........................................................135
4.2.8.5. Tham số là hằng con trỏ.................................................................................137
4.2.9.
Con trỏ hàm....................................................................................................138
4.2.9.1. Khai báo.........................................................................................................138
4.2.9.2. Khởi tạo..........................................................................................................139
4.2.9.3. Sử dụng con trỏ hàm......................................................................................139
4.2.9.4. Mảng con trỏ hàm...........................................................................................140
4.3. Đệ quy.................................................................................................................141
4.3.1.
Khái niệm.......................................................................................................141
4.3.2.
Lớp các bài toán đệ quy..................................................................................143
4.3.3.
Cấu trúc chung của hàm đệ quy.....................................................................143
4.3.4.
Các ví dụ minh họa.........................................................................................144
4.4.
Tổ chức chương trình......................................................................................146
4.4.1.
Các loại biến và phạm vi................................................................................146
6
4.4.1.1. Biến cục bộ.....................................................................................................146
4.4.1.2. Biến ngồi.......................................................................................................147
4.4.2.
Biến với mục đích đặc biệt.............................................................................147
4.4.2.1. Biến hằng và từ khóa const............................................................................147
4.4.2.2. Biến tĩnh và từ khóa static..............................................................................148
4.4.3.
Các chỉ thị tiền xử lý......................................................................................149
BÀI TẬP CHƯƠNG 4................................................................................................151
Chương 5: DỮ LIỆU KIỂU CẤU TRÚC VÀ HỢP..................................................155
5.1. Kiểu cấu trúc.......................................................................................................155
5.1.1.
Khai báo và khởi tạo.......................................................................................155
5.1.2.
Truy xuất các thành phần...............................................................................157
5.1.3.
Phép toán gán.................................................................................................159
5.1.4.
Hàm với cấu trúc............................................................................................162
5.1.4.1. Con trỏ và địa chỉ cấu trúc..............................................................................163
5.1.4.2. Địa chỉ của các thành phần kiểu cấu trúc.......................................................164
5.1.5.
Định nghĩa kiểu dữ liệu..................................................................................165
5.1.6.
Hàm sizeof()...................................................................................................166
5.2. Kiểu hợp.............................................................................................................166
5.2.1.
Khai báo.........................................................................................................166
5.2.2.
Truy xuất........................................................................................................166
5.3. Kiểu liệt kê..........................................................................................................167
BÀI TẬP CHƯƠNG 5................................................................................................169
TÀI LIỆU THAM KHẢO.........................................................................................172
7
Chương 1:
GIỚI THIỆU NGÔN NGỮ C++
Mục tiêu:
- Nắm vững các khái niệm cơ bản trong Ngơn ngữ lập trình C++ như: Bảng kí tự,
từ khóa, tên gọi, cách đặt tên, chú thích.
- Cấu trúc đơn giản của một chương trình C++, các thao tác cơ bản trong lập
trình, cách viết và thực thi chương trình.
- Các thao tác, định dạng nhập/xuất dữ liệu ra màn hình.
- Có kỹ năng viết một vài chương trình đơn giản.
1.1. Các khái niệm cơ bản
Một ngơn ngữ lập trình (NNLT) bậc cao cho phép người lập trình thể hiện ý
tưởng của mình trong việc giải quyết một vấn đề, một 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 (ngôn ngữ cấp
thấp). Hiển nhiên, muốn trình bày các ý tưởng thì chương trình phải được viết theo
đúng cấu trúc và qui tắc của ngơn ngữ đó qui định (cú pháp).
Lập trình cấu trúc là một kỹ thuật lập trình cơ bản, dễ hiểu và hiệu quả. Lập trình
cấu trúc có nghĩa là khi cần giải quyết một bài tốn ta có thể chia nhỏ thành nhiều bài
toán nhỏ hơn, mỗi bài toán nhỏ được giải quyết bằng một module hoặc một hàm riêng
biệt.
Trong tài liệu 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 chương trình với ngơn ngữ C++.
Trước hết, tài liệu sẽ trình bày về các qui định bắt buộc đơn giản và cơ bản nhất.
Thông thường các qui định này sẽ được nhớ dần trong q trình làm việc với ngơn
ngữ. Tuy nhiên, để có một vài khái niệm tương đối hệ thống về ngôn ngữ lập trình C+
+ chúng ta trình bày sơ lược các khái niệm cơ bản đó.
1.1.1. Bảng kí tự 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. Dưới đây là bảng kí tự được phép dùng để tạo nên những
câu lệnh của ngôn ngữ C++.
- Các chữ cái: a .. z và A .. Z. Cùng một chữ cái nhưng chữ thường phân biệt với
8
chữ hoa. Ví dụ chữ cái 'a' là khác với 'A'.
- Dấu gạch dưới (gạch nố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.1.2. Từ khóa
Từ khố (keyword) là từ được qui định trước trong ngơn ngữ lập trình với một ý
nghĩa cố định, thường dùng để chỉ các kiểu dữ liệu hoặc kết hợp thành câu lệnh. Người
lập trình có thể tạo ra những từ mới để chỉ các đối tượng muốn sử dụng nhưng khơng
được phép trùng với từ khố. Bên dưới là một vài từ khoá thường gặp.
int, char, long, auto, break, case, char, continue, default, do, double, else,
externe, float, for, goto, if, int, long, register, return, short, sizeof, static, struct,
switch, typedef, union, unsigned, while ...
Một đặc trưng của C++ là các từ khố ln ln được viết bằng chữ thường. Ý
nghĩa của các từ này, sẽ được lần lượt trình bày trong các đề mục liên quan.
1.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ọi. Hầu hết một đối
tượng được viết ra trong chương trình thuộc 2 loại:Loại thứ nhất có sẵn trong ngơn
ngữ (ví dụ các từ khố hoặc tên các hàm chuẩn, …), loại thứ hai do người lập trình tạo
ra dùng để đặt tên cho hằng, biến, kiểu dữ liệu, chương trình con, … Các tên gọi do
người lập trình tự đặt nhưng phải tuân theo một số qui tắc sau:
- Là dãy kí tự liên tiếp (khơng có khoảng trắng) và phải bắt đầu bằng chữ cái hoặc
gạch nối.
- Phân biệt kí tự in hoa và thường.
- Khơng được trùng với từ khóa.
- 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 người lập trình đặt tên sai thì trong quá trình xử lý
sơ bộ (biên dịch chương trình - compile) máy sẽ báo lỗi (gọi là lỗi văn phạm).
Ví dụ: Một số cách đặt tên sau
- Các tên gọi sau đây là đúng: i, j, n, giaithua, giai_thua, ketqua, ket_qua, …
- Các tên gọi sau đây là khơng hợp lệ: giai thua (có khoảng trắng), giai-thua
(không dùng dấu -), 1_ket_qua (không bắt đầu với số), …
9
- Các tên gọi sau đây là khác nhau: phu_yen, Phu_Yen, PHU_YEN, …
1.1.4. Chú thích trong chương trình
Một chương trình được viết bằng các câu lệnh và các khai báo. Ngồi ra, người
lập trình 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 nào đó,… Các chú thích sẽ làm cho chương trình sáng sủa hơn, dễ đọc
hơn, dễ hiểu hơn và vì vậy dễ bảo trì, sửa chữa, nâng cấp về sau.
Có 2 cách chú thích:
- 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.
- 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).
Như đã đề cập ở trên, vai trị của đoạn chú thích là làm cho chương trình dễ hiểu
hơn đối với người đọc.Vì vậy, đối với ngơn ngữ lập trình các đoạn chú thích sẽ được
bỏ qua. Lợi dụng đặc điểm này, đơi khi chú thích được dùng để 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.
1.2. Mơi trường làm việc của C++
1.2.1. Khởi động và thoát
Khởi động C++ cũng như mọi chương trình khác bằng cách nhấp đúp chuột lên
biểu tượng của chương trình(tập tin TC.EXE trong đường dẫn ổ đĩa:\TC\BIN). Khi
chương trình được khởi động sẽ hiện ra giao diện gồm có menu lệnh (File, Edit,
Search, Run, Compile, …) và một khung cửa sổ bên dưới phục vụ cho soạn thảo.
(Hình 1.1 bên dưới).
Với các phím chức năng cơ bản sau:
- F2 - Save: Lưu tập tin
- F3 - Open: Mở một tập tin đang có trên đĩa.
- Alt + F9 - Compile:Biên dịch chương trình (Kiểm tra chương trình).
- Ctrl + F9: Thực thi chương trình.
10
- Hoặc sử dụng các menu lệnh trên.
Để thoát khỏi cửa sổ chương trình ta thực hiện theo một trong hai cách sau:
Cách 1: menu File – Exit
Cách 2: Nhấn Alt + X
1.2.2. Giao diện chương trình
Giao diện chương trình từ trên xuống gồm: (Hình 1.1 bên dưới)
- Thanh tiêu đề (Title bar): Cho biết chương trình phần mềm (Turbo C++ IDE)
- Menu lệnh: gồm có các nhóm chức năng: File, Edit, Search, Run, Compile,
Debug, Project, Options, Window, Help.
- Tên tập tin đang soạn thảo: tên.CPP (Tên tập tin mặc định là NONAMEXX.CPP)
Hình 1.1: Giao diện làm việc của Turbo C++ IDE (version 3.0)
Để kích hoạt các nhóm chức năng, có thể ấn Alt+chữ cái đầu hoặc có màu đỏ. Ví
dụ để mở nhóm chức năng File ấn Alt+F, sau đó dịch chuyển hộp sáng đến mục cần
chọn rồi ấn Enter. Để thuận tiện cho người lập trình, một số các chức năng hay dùng
còn được gắn với một tổ hợp các phím cho phép người dùng có thể chọn nhanh chức
năng này mà không cần thông qua việc mở menu như đã mô tả ở trên. Một số tổ hợp
phím cụ thể đó sẽ được trình bày vào cuối phần này. Các bộ chương trình dịch hỗ trợ
người lập trình một mơi trường tích hợp nghĩa là ngồi chức năng soạn thảo, nó cịn
cung cấp nhiều chức năng, tiện ích khác giúp người lập trình vừa có thể soạn thảo văn
bản chương trình vừa gọi chạy chương trình (run) vừa gỡ lỗi (debug) …
11
1.2.3. Cấu trúc một chương trình
Một chương trình C++ có thể được đặt trong một hoặc nhiều tập tin (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 trong 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 được thực hiện lại có thể gọi đến các hàm khác (đã được viết trong
chương trình nhưng khơng được gọ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 thư viện hàm: Khai báo tên các file 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à người lập trình 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, các chương trình con, … do
người lập trình định nghĩa và được dùng chung trong tồn bộ chương trình.
- Danh sách các hàm của chương trình (do người lập trình viết, bao gồm cả hàm
main()).
Ví dụ 1.1: Viết chương trình xuất ra màn hình các dịng chữ như hình 1.1 bên
dưới:
#include <iostream.h> // thư viện với các thủ tục nhập xuất dữ liệu cout<<, cin>>.
#include <conio.h>
// để sử dụng hàm getch() để dừng màn hình kết quả.
void main()
{
cout<<”*** CHUONG TRINH DAU TIEN CUA TOI ***”<
// in ra nội dung ra màn
hình
cout<< ”I am studying at Mien Trung Univesity of Civil Engineering.”<
//Dừng màn hình để xem kết quả
}
12
Hình 1.1: Kết quả chương trình của ví dụ 1.1
Dịng đầu tiên của chương trình là khai báo thư viện hàm <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 <<”
(xuất dữ liệu ra màn hình), phương thức này được khai báo và định nghĩa sẵn trong thư
viện <iostream.h>.
Tương tự, thư viện hàm <conio.h> vì trong chương trình có sử dụng hàm getch(),
với chức năng dừng màn hình để xem kết quả của chương trình.
Khơng riêng hàm main(), mọi hàm khác đều phải bắt đầu bởi dấu { và kết thúc
bởi dấu }. Bên trong là các lệnh để chương trình thực thi. Chi tiết các lệnh sẽ được đề
cập trong các chương kế tiếp.
1.3. Các bước xây dựng chương trình
1.3.1. Xây dựng chương trình
Năm bước để hồn thành một chương trình.
Bước 1: 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) của chương trình và tập các dữ liệu cần đạt được nghĩa đầ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
tương ứng. Ví dụ để giải một phương trình bậc 2: ax 2 + bx + c = 0, chúng ta
cần khai báo cho chương trình để biểu diễn dữ liệu đầu vào là giá trị 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 có thể
là số thực.
Bước 2: Xác định thuật tốn hoặc thuật giải: Là cách thức hoặc trình tự các bước để
giải quyết mộtvấn đề, một bài tốn nào đó.
Bước 3: Cụ thể hoá các khai báo kiểu và thuật toán bằng các câu lệnh: Nghĩa là
viết chương trình bằng các câu lệnh và cú pháp của ngơn ngữ lập trình đã qui
định. Thơng thường là viết trên giấy.Sau đó, soạn thảo vào trong máy. Quá
trình này được gọi là soạn thảo chương trình nguồn.
Bước 4: Biên dịch chương trình nguồn để tìm và sửa các lỗi thường là lỗi cú pháp
13
(syntax) hoặc ngữ nghĩa (semantic).
Bước 5: Thực thi (chạy - run)chương trình, kiểm tra kết quả in ra trên màn hình:
Nếu sai, sửa lại chương trình, chạy lại để kiểm tra. Quá trình này được thực
hiện lặp đi lặp lại cho đến khi chương trình chạy tốt đạt yêu cầu đề ra của đề
tài.
1.3.2. Soạn thảo tập tin chương trình nguồn
Soạn thảo chương trình nguồn là một cơng việc đơn giản: Gõ nội dung của
chương trình (đã viết ra giấy) vào trong máy và lưu lại trong đĩa. Thông thường khi đã
lưu lại trong đĩa thì lần sau sẽ khơng cần phải gõ lại. Có thể soạn chương trình nguồn
trên các bộ soạn thảo (editor) khác nhau nhưng chương trình phải được thực thi trong
mơi trường tích hợp C++ (một số bộ soạn thảo: Turbo C++ IDE, Borland C++, DevC++, …). Mục đích của soạn thảo là tạo ra một văn bản chương trình và đưa vào bộ
nhớ của máy. Văn bản chương trình cần được trình bày sáng sủa, rõ ràng. Các câu lệnh
cần gióng thẳng lề trái theo cấu trúc của lệnh (các lệnh chứa trong một lệnh cấu trúc
được trình bày thụt vào trong so với điểm bắt đầu của lệnh). Các chú thích nên ghi
ngắn gọn, rõ nghĩa và phù hợp.
1.3.3. Biên dịch chương trình
Sau khi đã soạn thảo xong chương trình nguồn, bước tiếp theo thường là biên
dịch (compile) bằng cách nhấn tổ hợp phím Alt + F9, để tìm và sửa các lỗi thường
được gọi là lỗi cú pháp và ngữ nghĩa. Trong khi biên dịch, C++ sẽ đặt con trỏ vào nơi
bị lỗi trong văn bản. Sau khi sửa xong một lỗi người lập trình có thể dùng Alt + F8 để
chuyển con trỏ đến lỗi tiếp theo hoặc dịch lại. Để chuyển con trỏ về ngược lại lỗi trước
đó có thể dùng Alt + F7. Quá trình sửa lỗi − dịch được lặp lại cho đến khi văn bản đã
được sửa hết lỗi cú pháp.
Sản phẩm sau khi biên dịch là một file .exe (thường gọi là tập tin chương trình vì
đã được dịch ra mã máy). File này có thể lưu tạm thời trong bộ nhớ phục vụ cho quá
trình chạy chương trình hoặc lưu lại trên đĩa tùy theo tuỳ chọn khi biên dịch của người
lập trình. Trong và sau khi dịch, C++ sẽ hiện một cửa sổ chứa thông báo về các lỗi
(nếu có), hoặc thơng báo chương trình đã được dịch thành cơng (khơng cịn lỗi). Các
lỗi này được gọi là lỗi cú pháp.
Để dịch chương trình ta chọn menu \Compile\Compile hoặc \Compile\Make hoặc
nhanh chóng hơn bằng cách ấn tổ hợp phím Alt + F9.
14
1.3.4. Thực thi chương trình
NhấnCtrl + F9 để thực thi (chạy) chương trình, nếu chương trình chưa dịch sang
mã máy, máy sẽ tự động dịch lại trước khi chạy. Kết quả của chương trình sẽ hiện ra
trong một cửa sổ kết quả để người lập trình kiểm tra. Nếu kết quả chưa đạt yêu cầu,
chúng ta sửa và chạy lại chương trình. Quá trình này được lặp lại cho đến khi chương
trình chạy đúng như yêu cầu đã đề ra. Khi chương trình chạy, cửa sổ kết quả sẽ hiện ra
tạm thời che khuất cửa sổ soạn thảo. Sau khi kết thúc việc thực thi chương trình cửa sổ
soạn thảo sẽ tự động hiện ra trở lại và che khuất cửa sổ kết quả. Để xem lại kết quả đã
hiện thị, tanhấn Alt + F5. Sau khi xem xong để quay lại cửa sổ soạn thảo ấn phím bất
kỳ.
1.4. Xuất nhập trong C++
Trong phần này chúng ta sẽ làm quen một số lệnh đơn giản cho phép người lập
trình nhập dữ liệu vào từ bàn phím hoặc in thơng tin ra màn hình. Trong phần sau của
giáo trình chúng ta sẽ khảo sát các câu lệnh xuất/nhập phức tạp hơn.
1.4.1. Nhập dữ liệu từ bàn phím
Để nhập dữ liệu vào cho các biến có tên biến_1, biến_2, biến_3 chúng ta sử
dụng câu lệnh:
cin >> biến_1;
cin >> biến_2;
cin >> biến_3;
hoặc
cin >> biến_1 >> biến_2 >> biến_3;
Biến_1, biến_2, biến_3 là các biến được sử dụng để lưu trữ các giá trị do người
sử dụng nhập vào từ bàn phím. Khái niệm biến sẽ được mô tả cụ thể hơn trong chương
2, ở đây biến_1, biến_2, biến_3 được hiểu là các tên gọi khác nhau. Hiển nhiên có thể
nhập dữ liệu nhiều hơn 3 biến bằng cách tiếp tục viết tên biến vào bên phải sau dấu >>
của câu lệnh.
Khi chạy chương trình nếu gặp các câu lệnh trên chương trình sẽ "tạm dừng" để
chờ người sử dụng nhập dữ liệu vào cho các biến. Sau khi nhập xong dữ liệu, chương
trình sẽ tiếp tục chạy từ câu lệnh tiếp theo sau của các câu lệnh trên.
Cách thức nhập dữ liệu của người sử dụng phụ thuộc vào loại giá trị của biến cần
nhập mà ta gọi là kiểu dữ liệu, ví dụ nhập một số có cách thức khác với nhập một
15
chuỗi kí tự. Giả sử cần nhập 3 số cho 3 biến a, b, c. Câu lệnh nhập sẽ như sau:
cin >> a >> b >> c;
Khi máy dừng chờ để người sử dụng sẽ nhập giá trị cụ thể của các biến a, b, c
theo đúng thứ tự trong câu lệnh. Các giá trị này cần cách nhau bởi ít nhất một dấu
trắng (ta qui ước gọi dấu trắng là một trong 3 loại dấu được nhập bởi các phím sau:
phím spacebar (dấu cách), phím tab (dấu tab) hoặc phím Enter (dấu xuống dịng)). Các
giá trị nhập vào cũng được hiển thị trên màn hình để dễ theo dõi.
1.4.2. Xuất dữ liệu ra màn hình
Để xuất dữ liệu ra màn hình với cú pháp sau:
cout<
cout<
là chuỗi kí tự thì phải đặt trong dấu nhấy đơi “ ”
Ví dụ: Xét một số lệnh cơ bản dưới đây:
int a =10;
//Khai báo biến a kiểu số nguyên và khởi tạo giá trị a=10
cout<
// Biến a = 10 thì trên màn hình kết quả sẽ hiện ra giá trị 10.
cout<<100;
// Màn hình kết quả sẽ hiện ra giá trị 100.
cout<<4*a*a; // Màn hình kết quả sẽ hiện ra giá trị của biểu thức là 400.
cout<
//Màn hình kết quả hiện ra dịng chữ Hello World.
cout<<”Kết quả căn bậc 2 của”<<100<<”=”<
nhập từ bàn phím khi chạy chương trình).
#include <iostream.h>
#include <conio.h>
void main(){
cout<<"*** TINH CHU VI, DIEN TICH HINH TRON ***\n";
int R;
16
cout<<"Ban kinh R= "; cin>>R; //endl đưa con nháy xuống dịng mới
cout<<"Chu vi = "<<3.14*R<<'\n'; // ‘\n’ có chức năng như endl
cout<<"Dien tich = "<<3.14*R*R<<'\n';
getch();
}
Hình 1.2: Kết quả chương trình của ví dụ 1.2
Trong ví dụ trên, ta thấy kí tự‘\n’ là ký hiệu yêu cầu con nháy xuống dòng, khi
gặp kí tự này chương trình sẽ in các phần tiếp theo ở đầu dịng kế tiếp. Do đó kết quả
của các câu lệnh trên có hai lần xuống dịng.
Ví dụ 1.3: Viết chương trình tính và xuất ra kết quả ra màn hình thể tích và diện
tích bề mặt của quả đất biết rằng bán kính của nó là 6378 km (Theo ước tính của
NASA – Cơ quan Vũ trụ hàng không Mỹ).
#include <iostream.h>
#include <conio.h>
void main(){
int R = 6378;
double V, S;
cout<<"*** TINH THE TICH VA DIEN TICH BE MAT CUA TRAI DAT
***”<<’\n’;
V = 4*3.1416*R*R*R/3;
S = 4*3.1416*R*R;
cout<<”The tich qua dat: “<
}
17
Hình 1.3: Kết quả chương trình của ví dụ 1.3
Chú ý: giá trị 5.11187e+008 = 5.11187*108 (nghĩa là e+8=108, tương tự e-4=10-4)
1.4.3. Định dạng dữ liệu cần in ra màn hình
Trong phần này sẽ trình bày một số định dạng xuất dữ liệu đơn giản. Các định
dạng chi tiết và phức tạp hơn sẽ được trình bày trong các phần sau của tài liệu. Để sử
dụng các định dạng này cần khai báo thư viện hàm <iomanip.h> ở đầu chương trình
bằng chỉ thị #include <iomanip.h>;
endl: (end line) Tương đương với kí tự xuống dịng '\n'.
setw(n): Bình thường các giá trị được in ra bởi lệnh cout << sẽ thẳng theo lề trái
với độ rộng phụ thuộc vào độ rộng của giá trị đó. Setw(n) qui định độ rộng dành
để in ra các giá trị là n cột màn hình. Nếu n lớn hơn độ dài thực của giá trị, giá trị
sẽ in ra bắt đầu từ lề phải của n cột tương ứng.
setprecision(n): Chỉ định số chữ số của phần lẻ in ra là n số. Phần lẻ phía sau n
số sẽ được là trịn trước khi in ra.
setiosflags(ios::showpoint): Phương thức setprecision(n) ở trên chỉ có tác dụng
trên một dòng in. Để cố định các giá trị đã thiết lập cho mọi dòng in (cho đến khi
thiết lập lại giá trị mới) ta sử dụng phương thức setiosflags(ios::showpoint).
Ví dụ 1.4: Minh hoạ các cách sử dụng các phương thức trên.
#include <iostream.h>
#include <conio.h>
#include <iomanip.h> // để sử dụng các định dạng xuất ra màn hình
void main()
{
cout << "DU TOAN CONG TRINH" << endl << "=============" << endl ;
cout << setiosflags(ios::showpoint) << setprecision(2);//giữ lại 2 số lẽ
cout << setw(10)<<"Xi mang:" << setw(15) << 123.456 << endl;
18
cout << setw(10)<<"Sat thep:"<< setw(15) << 2453.6 << endl;
cout << setw(10)<<"Gach:" << setw(15) << 32000.0 << endl;
getch();
}
Hình 1.4: Kết quả chương trình của ví dụ 1.4
Chú ý: Tốn tử nhập >> chủ yếu làm việc với dữ liệu kiểu số. Để nhập kí tự hoặc
chuỗi kí tự, C++ cung cấp các phương thức (hàm) sau:
- cin.get(c): cho phép nhập một kí tự vào biến kí tự c,
- cin.getline(s,n): cho phép nhập tối đa n-1 kí tự vào biến chuỗi kí tự s. (Chi tiết sẽ
được đề cập trong các chương sau).
Ví dụ 1.5: Viết chương trình cấp bản số xe ngẫu nhiên cho Cơng An TP. Tuy
Hịa. (Sử dụng hàm random(n) máy sẽ sinh ngẫu nhiên 1 số có giá trị từ 0 đến n-1)
#include <iostream.h>
#include <conio.h>
#include <stdlib.h> //nguyên mẫu file sử dụng cho hàm random(n)
void main()
{
cout<<"*** CAP SO XE CUA CONG AN TP. TUY HOA ***"<
cout<<"SO XE CUA BAN LA:"<
getch();
19
}
Hình 1.5: Kết quả của 3 lần chạy chương trình của ví dụ 1.5
20
