Giáo trình Lập trình hướng đối tượng và C++ - Trường Đại học Hàng Hải
BỘ GIAO THÔNG VẬN TẢI
TRƢỜNG ĐẠI HỌC HÀNG HẢI
́ ́
BỘ MÔN: KHOA HOC MAY TINH
̣
KHOA: CÔNG NGHỆ THÔNG TIN
BÀI GIẢNG
LẬP TRÌNH HƢỚNG ĐỐI TƢỢNG VÀ C++
TÊN HỌC PHẦN : Lập trình hƣớng đối tƣợng và C++
MÃ HỌC PHẦN : 17209
TRÌNH ĐỘ ĐÀO TẠO : ĐẠI HỌC CHÍNH QUY
DÙNG CHO SV NGÀNH : CÔNG NGHỆ THÔNG TIN
HẢI PHÒNG - 2008
Mô tả vắn tắt nội dung và khối lượng học phần
Tên học phần: Lập trình hướng đối tượng và C++.
Bộ môn phụ trách giảng dạy: Khoa học máy tính.
Mã học phần: 17209
Loại học phần : 2
Khoa phụ trách: CNTT
Tổng số TC: 4
TS tiết Lý thuyết Thực hành/ Xemina Tự học
Bài tập lớn Đồ án môn học
75
45
30
0
0
0
Điều kiện tiên quyết:
Sinh viên phải học và thi đạt các học phần sau mới được đăng ký học học phần này:
Kỹ thuật lập trình Pascal, Kỹ thuật lập trình C.
Mục tiêu của học phần:
Cung cấp kiến thức của phương pháp lập trình hướng đối tượng và rèn luyện kỹ
năng lập trình .
Nội dung chủ yếu:
-
-
-
-
Những mở rộng của lập trình hướng đối tượng.
Đối tượng và lớp.
Đóng gói, thừa kế, đa hình.
Bản mẫu, thư viện STL
Nội dung chi tiết:
PHÂN PHỐI SỐ TIẾT
TS LT Thực hành BT KT
TÊN CHƢƠNG MỤC
Chƣơng 1: Lâp trinh hương đôi tươn
ngôn ngư C++
3
3
̣
́
̣
g va
̀
́
̀
̃
1.1 Ưu điểm của lập trình hướng đối tượng
1.2 Giới thiệu ngôn ngữ C++
9
6
3
̣
Chƣơng 2: Nhưng khai niêm mơ đầu
̉
̃
́
2.1 Cài đặt ngôn ngữ C++
2.2 Cấu trúc một chương trình C++
2.3 Kiểu dữ liệu cơ sở
2.4 Quy tắc sử dụng từ khóa, tên chuẩn, tên từ
đặt.
2.5 Các chỉ thị gán, so sánh, điều kiện nếu thì ..
6
9
3
5
3
3
Chƣơng 3: Con tro, tham chiê
3.1 Khai báo hàm con, hàm chính.
3.2 Quy tắc đổi kiểu dữ liệu, kiểu trỏ.
3.3 Định nghĩa chồng hàm, tham số ngầm định..
3.5 Tham chiểu.
Chƣơng 4: Các dꢀng vào ra trong C++
4.1 Đối tượng vào ra cout, cin
4.2 Đẩy dòng dữ liệu lên màn hình
4.3 Nhập dòng dữ liệu từ bàn phím
4.4 Định dạng dòng dữ liệu hiển thị
4.5 Vào ra với tệp
́
u va ham
̉
̀
̀
1
1
18
8
9
Chƣơng 5: Đối tượng và Lớp
i
5.1 Định nghĩa đối tượng
5.2 Khai báo lớp
5.3 Hàm thiết lập, huỷ bỏ
5.4 Thành phần tĩnh, hàm bạn, lớp bạn
5.5 Định nghĩa chồng toán tử
Chƣơng 6: Thừa kế
9
6
3
6.1 Lớp cơ sở, lớp dẫn xuất
6.2 Quy tắc thừa kế
6.3 Tương thích lớp cơ sở và lớp dẫn xuất
6.4 Đơn thừa kế, đa thừa kế
Chƣơng 7: Ràng buộc động và Đa thể
7.1 Hàm ảo, ràng buộc tĩnh, động
7.2 Đa thể
8
5
6
3
6
13
1
Chƣơng 8: Bản mẫu
8.1 Hàm bản mẫu
8.2 Ưu khuyết điểm của hàm bản mẫu
8.3 Lớp bản mẫu
Nhiệm vụ của sinh viên: Lên lớp đầy đủ và chấp hành mọi quy định của Nhà trường.
Tài liệu học tập:
1. Tên tác giả. Tên sách. Nhà xuất bản. Năm xuất bản.
2. Phạm Văn Ất. Kỹ thuật lập trình hướng đối tượng. NXB KHKT. 1998
3. Một số website liên quan.
Hình thức và tiêu chuẩn đánh giá sinh viên:
- Thi viết hoặc thi thực hành.
- Sinh viên phải bảo đảm các điều kiện theo Quy chế của Nhà trường và của Bộ.
Thang điểm : Thang điểm chữ A,B,C,D,F.
Điểm đánh giá học phần: Z=0,3X+0,7Y.
Bài giảng này là tài liệu chính thức và thống nhất của Bộ môn Khoa học Máy tính,
Khoa Công nghệ Thông tin và được dùng để giảng dạy cho sinh viên.
Ngày phê duyệt:
/
/20
Trƣởng Bộ môn: ThS. Nguyễn Hữu Tuân (ký và ghi rõ họ tên)
ii
MỤC LỤC
1. Sự phát triển của các kỹ thuật lập trình..........................................................................1
1.1 Lâp trinh không co câu truc (hay lâp trinh tuyên tinh) ............................................1
2.2 Đối tượng (Objects) và lớp (Classes) ......................................................................5
2.3 Kê thừa (Inheritance)...............................................................................................6
3. Ngôn ngữ lâp trinh C++ và OOP...................................................................................7
3.2 Ngôn ngữ lâp trinh C++...........................................................................................8
4. Bài tập............................................................................................................................8
trinh module......................................................................................................3
1. Chương trinh đâu tiên ....................................................................................................9
1.1 Quá trình biên dịch một chương trinh C++ .............................................................9
u tiên. ...........................................................................................13
2.1 Cꢁ pháp khai báo biến (variable declaration) ........................................................15
2.2 Tâm hoat đông cua cac biên ..................................................................................16
2.4 Các kiểu biến .........................................................................................................17
2.5 Liên kêt biên khi biên dich ....................................................................................18
2.6 Các hꢂng ................................................................................................................18
3. Hàm trong C++............................................................................................................19
4. Các cấu trꢁc điều khiển................................................................................................20
4.1 Câu lênh if-else ......................................................................................................20
4.2 Vꢀng lặp không xác định while .............................................................................20
4.3 Vꢀng lặp không xác định do – while.....................................................................21
4.4 Vꢀng lặp xác định for ............................................................................................21
4.5 Các từ khóa break và continue...............................................................................22
h lựa chon switch.......................................................................................22
h goto.........................................................................................................23
4.8 Đệ qui.....................................................................................................................23
iii
5. Các kiểu dữ liêu cơ bản của C++.................................................................................23
6. Môt sô toan tử trong C++ ............................................................................................25
6.1 Toán tử gán (assignment operator) ........................................................................25
6.2 Các toán tử toán học ..............................................................................................25
6.3 Các toán tử quan hê................................................................................................25
6.4 Các toán tử logic....................................................................................................26
6.5 Các toán tử bitwise ................................................................................................26
6.6 Các toán tử dịch .....................................................................................................26
6.7 Các toán tử môt ngôi..............................................................................................26
6.8 Toán tử 3 ngôi ........................................................................................................26
u phây....................................................................................................27
6.11 Toán tử chuyên kiêu.............................................................................................27
6.12 Toán tử sizeof.......................................................................................................28
8. Bài tập..........................................................................................................................31
1. Hàm trong C++............................................................................................................34
1.2 Hàm và các biến.....................................................................................................34
1.3 Truyên tham sô ......................................................................................................34
1.5 Các vấn đề khác .....................................................................................................36
2. Con tro, hàm và mảng..................................................................................................37
3. Hàm và xử lý xâu.........................................................................................................38
4. Bài tập..........................................................................................................................38
2. Các luồng và các bộ đệm .............................................................................................41
3. Các đối tượng vao ra chuân .........................................................................................41
6. Các hàm thanh viên khac cua cin.................................................................................42
h hướng lai (Redirection).......................................................................................41
dữ liêu với cin ....................................................................................................42
8. Các dꢀng vào ra và hàm printf.....................................................................................46
9. Vào ra dữ liêu với cac file............................................................................................46
́t xuất dữ liêu với cout .............................................................................................45
iv
11. Tìm kiếm trong các dꢀng vào ra ................................................................................48
12. stringstream................................................................................................................49
13. Bài tập........................................................................................................................52
CHƢƠNG V: ĐỐI TƢỢNG VA LỚP..............................................................................54
1. Trừu tượng dữ liêu.......................................................................................................54
2. Thê nao la môt đôi tượng?...........................................................................................54
3. Các lớp va cac đôi tượng .............................................................................................55
4. Con tro va mang cac đôi tượng....................................................................................58
5. Khai bao cac lớp với cac file header............................................................................59
8. Con tro this...................................................................................................................66
10. Hủy tử ........................................................................................................................72
11. Câu tử copy................................................................................................................76
12. Đối tượng hăng va cac ham thanh viên hăng.............................................................78
13. Các thành viên tĩnh của lớp .......................................................................................79
14. Sử dụng các đối tượng trong vai trꢀ là tham số của hàm...........................................80
16. Chông toan tử.............................................................................................................84
17. Bài tập........................................................................................................................91
1. Sử dụng lại mꢄ chương trinh........................................................................................94
2. Sử dụng lại mꢄ chương trinh trong OOP .....................................................................94
3. Cꢁ pháp kế thừa ...........................................................................................................94
4. Đinh nghĩa lại các thành viên của lớp cơ sở................................................................96
.......................................................................................................98
6. Các kiểu kế thừa.........................................................................................................101
thừa public......................................................................................................101
thừa private....................................................................................................101
6.3 Kế thừa protected.................................................................................................102
7. Đinh nghia lai cac đăc ta truy câp..............................................................................102
8. Các hàm không thể kế thừa........................................................................................103
9. Các hàm cấu tử và kế thừa.........................................................................................103
10. Composition va Inheritance.....................................................................................105
11. Đa kế thừa................................................................................................................107
v
i tượng..........................................................................................109
́ thừa....................................................................................................116
15. Bài tập......................................................................................................................117
1. Môt số đăc điêm cua rang buôc đông và đa thể.........................................................118
1.1 Ràng buộc động ...................................................................................................118
1.2 Đa thể - Polymorphism.......................................................................................118
3. Các hàm thành viên ảo được truy câp qua cac con trỏ ..............................................120
4. Ràng buộc động .........................................................................................................122
4.1 Ràng buộc động làm việc như thê nao.................................................................122
4.2 Không sử dụng con trỏ this..................................................................................124
5. Danh sach liên kết cac đối tượng va đa thê ...............................................................124
6. Các lớp trừu tượng – abstract class............................................................................128
7. Các hàm ảo thực sự....................................................................................................129
7.1 Ví dụ 1 .................................................................................................................129
7.2 Ví dụ 2 .................................................................................................................131
8. Cấu tử ảo và hủy tử ảo ...............................................................................................135
9. Hàm toán tử ảo...........................................................................................................136
10. Bài tập......................................................................................................................139
CHƢƠNG VIII: BẢN MꢄU (TEMPLATE) .................................................................140
1. Các lớp bản mẫu ........................................................................................................140
1.1 Các bản mẫu và thể nghiệm.................................................................................141
1.2 Các thành phần tĩnh .............................................................................................146
1.4 Các tham số bản mẫu...........................................................................................149
1.5 Các lớp thuôc tinh................................................................................................151
va lớp trợ giꢁp..................................................................................147
1.6 Các lớp chứa (bản mẫu) chuân ............................................................................154
2. Các hàm bản mẫu.......................................................................................................154
2.1 Các định nghĩa và thể nghiệm..............................................................................154
2.2 Các hàm chuẩn chung – thư viên thuât toan........................................................157
3. Bài tập........................................................................................................................157
TÀI LIỆU THAM KHẢO...............................................................................................158
ĐỀ THI THAM KHẢO...................................................................................................159
vi
́
̀ ́ ̀ ̃
̣ ̣
CHƢƠNG I: LÂP TRINH HƢƠNG ĐÔI TƢƠNG VA NGÔN NGƢ C++
̉
1. Sƣ
Phân nay trinh bay vê
giải quyết các vấn đề trong Tin học kể từ khi máy tính ra đời. Sư
̣
phat triên cua cac ky thuât
̣
lâp
̉ ̉
̣ ̣
ky thuât hay p hương phap lâp trinh đươc phat triên đê
́
̀
̣
trinh
́
̉
́
̃
̀
̀
̀
môt
̣
số
̣
̀
̀
̃
́
̀
̉
phat triên cua cac ky thuât
̣
̉
̃
́ ́
̣
̉
̣ ̣ ̣ ̣
lâp trinh liên quan chăt che tơi sư phat triên phần cưng cua may vi tinh cung như v iêc ưng
́ ́ ́ ́ ́
̃ ̃
̉
̀ ́
dụng máy tính vào giải quyết các vấn đề trong thực tế . Chꢁng ta có thể chia các phương
pháp lập trình thành các kiểu sau:
+ Lâp
+ Lâp
+ Lâp
+ Lâp
Chꢁng ta sꢅ lần lượt xem xꢆt các kỹ thuật lập trình này.
̣
trinh không co cấu truc
́ ́
̀
̣
trinh hương thu tuc
̣
̉
́
̀
̉
trinh theo kiêu module hoa
́
̀
̣
̣
̣
trinh hương đối tương
́
̀
́ ́
̣ ̣
trinh không co câu truc (hay lâp trinh tuyên tinh)
́ ́
̀ ̀ ́
1.1 Lâp
Thông thương moi
̣
ngươi bă
́
t đâ
và đơn giản chỉ chứa một “chương trình chính” . ꢇ đây một chương trình chính có nghĩa là
môt tâp cac lênh hoăc câu lênh lam viêc vơi cac dư liêu toan cuc trong ca chương trinh (các
biên dung trong chương trinh là các biến toàn cục). Chꢁng ta có thể minh hoạ bꢂng hình vꢅ
sau đây:
̣ ̣
̀u hoc lâp trinh bằng cach viết cac chương trình nhỏ
́ ́
̀
̀
̀
̣
̣
̣
̣
̣
̣
̣
̣
̃
̀
̉
́
̀
́
́
̀
́
̀
̀
́
̣
trinh không co câu truc. Chƣơng trinh chinh
́ ́
̀ ̀ ́
Lâp
́
thao tac trƣc
̣
tiêp trên cac dƣ liêu
̣
toan cuc
̣
́
́
̃
̀
̉
Môt
+ Lâp
. Mọi dữ liệu trong chương trình đều là biến toàn cục do đó có thể bị thay đổi bởi bất
kꢈ phần nào đó của chương trình.
̣
sô
́
nhươc
̣
điêm cua lâp
̣
trinh không co câ
́
u truc:
̉
́
́
̀
̉
̣
́u truc không co kha năng kiêm soat tinh thấy đươc cua dư
̉ ̉
̃
́ ́ ́
́
̣
trinh không co câ
́
̀
liêu
̣
̉
+ Viêc y đươc
̣ ̣
gơ lôi chương trinh, đăc biêt la cac chương trinh lơn.
̀
̣
không kiêm soat đươc
̣
tinh thâ
́
̣ ̣
cua dư liêu dân đến cac kho khăn trong
̃
̉
̃
́ ́
́
́
viêc
̣
̃
̃
́
́
̀
̀
+ Kỹ thuật lập trình không có cấu trꢁc có rất nhiều bất lợi lớn khi chương trình đủ
lơn. Ví dụ nếu chꢁng ta cần thực hiện lại một đoạn câu lệnh trên một tập dữ liệu khác thì
́
buôc
Điê
tên cho chung va đưa ra môt
̣
phai copy đoan
̣
lên
̣
h đo tơi vi
̣
́
n thưc
̣
hiên
̣
.
̣
̉
́
́
̀
́
́
̀
̀
u nay lam nay sinh y tương trich ra cac đo ạn lệnh thường xuyên cần thực hiện đó , đăt
̉
̉
̀
̀
́
́
̣
ky thuât cho phep goi va tra về cac gia tri tư cac thu tuc nay.
́
̀
̃
́
̣
trinh co câu truc
́ ́
̀
1.2 Lâp
̣
trinh thu tuc
̣
hay lâp
̣
trinh thu tuc hay hương thủ tục chꢁng ta có thể nhóm các câu lệnh thường
̉
̀
̉
̀
Vơi lâp
̣
́
́
̣ ̣ ̣ ̣ ̣ ̣ ̣
xuyên thưc hiên trong chương trinh chinh lai môt chô va đăt tên đoan câu lênh đo thanh
̃
̀ ́ ̀
̀ ́
1
̉
̣ ̣ ̣ ̣ ̣ ̣ ̣ ̣ ̣ ̣ ̣
thu tuc. Môt lơi goi tơi thu tuc se đươc sư dung đê thưc hiên đoan câu lênh đo. Sau khi
̀ ́ ́
̃
̉ ̉ ̉
môt
thủ tục thực hiện xong điều khiển trong chương trình được trả về ngay sau vị trí lời gọi tới
thủ tục trong chương trình chính . Vơi cac cơ chê truyên tham sô cho thu tuc chung ta co
chương trinh chinh bao gôm nhiêu chương trinh con va cac
u truc cao hơn , đông thơi cung it lô ́u môt
̣
́
̀
́
̣
̉
́
́
́
́
các chương trình con . Môt
chương trinh đươc viêt mang tinh câ
chương trinh con la đung đă
̣
̀
̀
̀
́
̀
́
̀
̣
́
́
̀
̃
i hơn . Nê
́
̀
̃
̀
̀
́
́
́
n thi kê
́
t qua thưc
̣
hiên
phải quan tâm tới các chi tiết bên trong của thủ tục . Cꢀn nếu có lꢃi chꢁng ta có thể thu hꢉp
phạm vi gꢊ lꢃi trong các chương trình con chưa được chứng minh là đꢁng đắn , đây đươc
xem như trưu tương ham va la nên tang cho lâp trinh thu tuc
̣
tra vê
̀
luôn đung va chung ta khôn g cần
̉
̉
̀
́
́
̀
́
̀
̣
̣
̀
̣
̣
.
̉
̉
̀
̀
̀
̀
̀
̉
̣ ̣ ̣ ̣ ̣ ̣ ̣
chương trinh chinh vơi lâp trinh thu tuc co thê đươc xem la tâp hơp cac lơi goi
̉
́ ́ ̀ ́ ̀
̀ ́ ̀
Môt
thủ tục.
̀
̣
xong điêu
Lâp
̣
trinh thu tuc
̉
̣
. Sau khi chƣơng trinh con thƣc
̣
hiên
̀
̣ ̣ ̣
khiên đƣơc tra vê ngay sau vi tri lơi goi tơi chƣơng trinh con
̉
̀ ́
́
̉
̀
̀
̀
̉
Chương trinh chinh co nhiêm
̣
vu
̣
truyê
̀
n cac dư liêu
̣
cho cac lơi goi
̣
cu
̣
thê
, dư liêu
̣
̃
́
́
̃
́
̀
̀
́
đươc
̣
xư ly cuc
̣
bô
̣
trong chương trinh con sau đo cac kê
́
t qua thưc
̣
hiên
̣
nay đươc
̣
tra vê
̀
cho
̉
̉
̉
́
́
́
̀
̀
̉
chương trinh chính. Như vây
̣
luô
̀
ng dư liêu
̣
co thê đươc
̣
minh hoa
̣
như la môt
̣
đô
̀
thi
̣
̃
́
̀
̀
câ
́
p, môt
̣
cây:
́
̣ ̣ ̣
trinh hƣơng thu tuc. Chƣơng trinh chinh phôi hơp cac lơi
́ ́ ̀
̉
̀ ̀ ́
Lâp
gọi tới các thủ tục với các dữ liệu thích hợp là các tham số
̉
Lâp
̣
trinh hương thu tuc
̣
la môt
̣
ky thuât
̣
lâp
y tương rất hay , nó cho phꢆp một chương trình lớn có thể được
̉
́
̣
trinh co nhiê
̀
u ưu điêm
. Khái niệm
̉
̃
́
̀
́
̀
̀
chương trinh con la môt
̣
̀
̀
chia thanh nhiê
̀
u chương trinh con nho hơn , đo đo dê
̃
viê
́ t hơn va it lôi hơn . Đê co thê sư
̃
̉ ̉
̉
̀ ́
́
̉
̀
́
̀
dụng được các thủ tục chung hoặc một nhóm các thủ tục trong các chương trình khác
,
̉
̣ ̣
, đo la ky thuât lâp trinh theo kiêu
́ ̀
̃
̀
ngươi ta đa phat minh ra môt
module.
̣
ky thuât
̣
lâp
̣
trinh mơi
̀
̃
́
̃
́
̀
2
1.3 Lâp
Trong lâp
vơi nhau tao thanh môt
̣
trinh module
̀
̣
̣ ̣ ̣ ̣
trinh module cac thu tuc co cung môt chưc năng chung se đươc nhom lai
̉
̃
́ ́ ̀ ́ ́
̀
̣
̣
module riêng biêt
̣
. Môt
̣ ̣
chương trinh se không chi bao gồm môt
̃
̉
̀
́
̀
phâ
̀
n đơn le. Nó được chia thành một vài phâ
̀
n nho hơn tương tac vơi nhau qua cac lơi goi
̣
̉
̉
́
́
́
̀
thủ tục và tạo thành toàn bộ chương trình.
́
Lâp
̣
trinh module. Chƣơng trinh chinh la sƣ
̣
kêt hơp
̣ ̣
giƣa cac lơi goi tơi cac
̃ ́ ̀ ́ ́
̀
̀
̀
́
thủ tục trong các module riêng biệt với các dữ liệu thich hơp
̣
́
Mô
các dữ liệu riêng của nó bꢂng các lời gọi tới các thủ tục trong module đó . Tuy nhiên mô
module chi xuât hiên nhiêu nhât môt lân trong ca chương trinh.
̃
i module co dư liêu riêng cua no. Điều nay cho phep cac module co thê kiêm soat
̉ ̉
̣
́ ́ ̀ ́ ́ ́ ́
̃
̉
̃
i
́
̣
̀
́
̣
̀
̉
̉
̀
̉
Yê
+ Khi đô
cơ ban ma no xư ly cung tăng theo . Vâ
́
̣
̣
̣
u điêm cua lâp trinh thu tuc va lâp trinh module hoa:
́
̀
̉
̉
̀
̀
̉
̣ ̣
thuôc cua no vao cac kiêu dư
̉
̃
́ ̀ ́
̣
phưc tap
̣
cua chương trinh tăng lên sư
̣
phu
̣
trơ nên ro rang rằng cấu truc dư liêu sư
́
̃
̉
̉
́
̀
liêu
dụng trong chương trình cꢋng quan trọng không kꢆm các phꢆp toán thực hiện trên chꢁng .
Điêu nay cang lô ro khi kich thươc chương trinh tăng . Các kiểu dữ liệu được xử lý nhiều
trong cac thu tuc
̣
́
n đê
̀
̉
̉
̃
̉
̃
̀
́
́
̀
̀
̣
̃
̀
̀
́
́
̀
̉ ̉
̣ ̣ ̣
cua môt chương trinh co cấu truc. Do đo khi thay đôi cai đăt cua môt kiêu
̉ ̉
́ ́ ́ ̀
̀
̣
̉
́
̉
̣ ̣
́n nhiều thay đôi trong cac thu tuc sư dung no.
̉ ̉
́ ́
dư liêu
̣
se dân
̃
đê
nhươc
chương trinh chung. Trong lâp
̃
̃
̉
̉
+ Môt
̣
̣
điêm nưa la khi câ
̀
n dung nhiê
̀
u nhom lam viêc
̣
đê xây
giao xây dưn
khac nhau nhưng lai
dưn
g môt
co liên
̣
g môt
̣
̃
̀
̀
́
̀
̣
trinh co câ
́
u truc mô
̃
i ngươi se đươc
̣
̣
̣
số
́
́
̀
̃
̀
̀
thủ tục và kiểu dữ liệu . Nhưng lâp
̣
trinh viên xư ly cac thu tuc
̣
̣
̃
̉
́
́
̉
́
́
̀
̉
̉ ̉
̣ ̣
ngươi thay đôi kiêu dư liêu thi se lam
̀ ̀
̃ ̃
̀
quan tơi cac kiêu dư liêu
̣
dung chung nên nê
́
u môt
ảnh hưởng tới công việc của nhiều người khác , đăc
giưa cac thanh viên cua nhom.
́
́
̃
̀
̣
biêt la khi co sai sot trong viêc liên lac
̣
̣
̣
̀
́
́
̃
́
̀
̉
́
̉
+ Viêc
trꢁc dữ liệu cơ bản . Khi xây dưn
trình viên thường phải xây dựng lại các cấu trꢁc dữ liệu cơ bản cho phù hợp với bài toán và
điêu nay đôi khi rât mât thơi gian.
̣
phat triên cac phâ
̀
m mê
̀
m mâ
́
t nhi ều thời gian tập trung xây dựng lại các cấu
́
́
̣
g môt
̣
chương trinh mơi trong lâp
̣
trinh co câu truc lâp
́
̣
́
́
́
̀
̀
̀
́
́
̀
̀
3
́
̣ ̣
trinh hƣơng đôi tƣơng
́
̀
1.4 Lâp
Trong lâp
g (object) có thể tương tác với nhau , thuôc
quan ly lây cac dư liêu cua riêng chung.
̃
i chương trinh chung ta co môt
sô
̃
́ cac đối
́
̣
trinh hương đô
́
i tươn
̣
g trong mô
̣
́
́
́
̀
̀
tươn
̣
̣
cac lơp (class) khác nhau, môi đối tương
̣
́
́
tư
̣
́
̣
̉
̃
̉
́
́
́
Lâp
̣
trinh hương đô
́
i tươn
̣
g. Các đối tượng tương tác với nhau bꢂng
́
̀
cách gửi các thông điệp.
̉
̣ ̣ ̣
số đối tương la thê hiên (instance) của các lớp,
̀
Chương trinh chinh se bao gô
̀
m môt
̃
̀
́
các đối tượng này tương tác với nhau thực hiện các chức năng của chương trình . Các lớp
̉
trong lâp
̣
trinh hương đô
́
i tươn
̣
g co thê xem như la môt
̣
sư
̣
do ngươi dung đinh nghia trong cac ngôn
́
̃
̣ ̣
trưu tương ơ mưc cao hơn cua
̉ ̉
̀ ́
́
́
̀
̀
̉
các cấu trꢁc (struct hay record) hay kiêu dư liêu
̣
̃
̀
̀
̉
̣ ̣ ̣ ̣
ngư lâp trinh co cấu truc vơi sư tich hơp ca cac toan tư va dư liêu trên cac kiêu đo.
̉ ̉
̃
́ ́ ́ ́ ́ ̀ ́ ́
̀ ́
̃
Các ưu điểm của lập trình hướng đối tượng:
+ Lâp trinh hương đôi tương ra đơi đa giai quyê
trong lâp trinh co câu truc . Trong lâp
hơn, đông thơi lâp
̉
̣ ̣
điêm tồn tai
̣
́
̣
́
t đươc
̃
̣
nhiê
̀
u nhươc
́
̀
̃
̉
̀
̃
i cung đơn gian
̣
́
̣
trinh OOP co it lôi hơn va viêc
̣
gơ lô
̃
̃
̉
́
́
́
́
râ
̀
̀
̀
̉
̃
̀
̣
trinh theo nhom co thê thưc
̣
hiên
̣
́
t hiêu
̣
qua . ꢌt lôi la môt
̣
trong cac ưu
̉
̀
́
́
̀
́
̀
̉
điêm chinh cua OOP vi theo thô
́
ng kê thi viêc
̣
bao tri hê
̣
thông phần mềm sau khi giao cho
́
̉
̉
́
̀
̀
̀
ngươi dung chiếm tơi 70% giá thành phần mềm.
̀
̀
́
̉
+ Viêc
̣
thay đôi cac cai đăt
̣
chi tiê
́
t bên dươi trong lâp
̣
trinh
OOP không lam anh
̉
́
̀
́
̀
̀
hương tơi cac phâ
̀
n khac cua chương trinh do đo viêc
̣
mơ rôn
̣
g qui mô cua môt
̣
chương
̉
̉
̉
́
́
́
́
̀
̉
̉
trình dꢍ dàng hơn, đô
̀
ng thơi lam giam thơi gian câ
̀
n thiê
́
t đê phat triên phâ
̀
n mê
̉
̣ ̣
kế thưa cac lâp trinh viên co thê xây dưng cac chương trinh tư cac
̀ ́ ́
̀
̀m.
̉
̀
̀
̀
́
+ Vơi khai niêm
̣
́
́
́
̀
́
̀
phâ
̀
n mê
̀m săn co.
̃
́
̉
̉
thống nền (chăng
+ OOP co tinh kha chuyên cao . Môt
̣
chương trinh viê
́
t trên môt
̣
hê
̣
̉
́
́
̀
̉
hạn Windows) có thể chạy trên nhiều hệ thống nền khác nhau (chăng han
̣
Linux, Unix…).
+ OOP co hiêu qua cao. Thưc tê cho thây cac hê thông đươc xây dưn
̣
̣
́
́
̣
́
̣
̣
g băng OOP co
̀
̉
́
́
́
̣
hiêu năng cao.
4
́ ́
̣ ̣ ̣ ̣
2. Môt sô khai niêm cơ ban cua lâp trinh hƣơng đôi tƣơng
́ ́
̉ ̉
̀
̉
2.1 Kiêu dƣ liêu trƣu tƣơng ADT(Astract Data Type)
̣
̣
̃
̀
̉
Môt
quan hê giưa chung . Trong phâ
là một khái niệm cơ bản của OOP và sử dụng một số ví dụ để minh họa.
̣
sô
́
ngươi đin
̣
h nghia OOP la lâp
̣
trinh vơi cac kiêu dư liêu
̣
trưu tươn
̣
g va cac mô
́
i
̀
̀
́
́
̃
̀
̀
́
̃
̀
̉
̣
̀
n nay chung ta se xem xet cac kiêu dư liêu
̣
trưu tươn
̣
g như
̃
́
̀
́
̃
́
́
̃
̀
̉
̉
Đin
toán học của các đối tượng dữ liệu tạo thành một kiểu dữ liệu và các toán tử
thao tac trên cac đôi tươn
găn liên vơi cac đô
kiêu dư liêu trưu tươn
̀
̣
h nghia vê
̀
kiêu dư liêu
̣
trưu tươn
̣
g : Môt
̣
kiêu dư liêu
̣
trưu tươn
̣
g la môt
̣
mô hinh
̃
̀
̃
̀
̀
̃
̀
(phꢆp toán)
́
̣
g đo. Chꢁ ý là trong định nghĩa này các toán tử thao tác trên các
́
́
́
̉
đô
vê
của kiểu dữ liệu. Viêc
tư đăc ta cua no sang môt
́
i tươn
môt
̣
g dư liêu
̣
́
̀
́
i tươn
̣
g tao
̣
thanh môt
chi tiê
trưu tươn
̣
kiêu dư liêu
̣
trưu tươn
̣
g . Đặc tả
̃
́
́
̀
̃
̀
̉
̉
̀
̣
̣
̣
g không co bâ
́
t ky môt
̣
́
t cu
̣
thê nao vê
̀
cai đăt
̣
bên trong
̃
̀
́
̀
̀
̉
̉
̉
̣
cai đăt
̣
môt
̣
kiêu dư liêu
̣
̣
g đoi hoi môt
̣
qua trinh chuyên đôi
̃
̀
̀
̉
́
̀
̀
̉
̉
̣
̣
cai đăt cu
̣
̣
thê trên môt
̣
ngôn ngư lâp
̣
trinh cu
̣
thê . Điê
̀
u nay cho
̉
̉
̃
̀
́
̀
̀
̀
phꢆp chꢁng ta phân biệt các ADT với các thuật ngữ kiểu dữ liệu (data type) và cấu trꢁc dữ
̉
̉
̣ ̣ ̣ ̣
̀ câp tơi môt cai đăt cu thê (có thể là kiểu
́ ̀
liêu
built in hoăc
ADT. Câu truc dư liêu
môt cach thưc xac đin
̣
(data structure). Thuât
̣
ngư kiêu dư liêu
̣
đê
̃
̃
̣
do ngươi dung đin
̣
h nghĩa) của một mô hình toán học được đặc tả bởi một
tơi môt
̀
̀
̉
́
̣
đê
̀
câp
̣
̣
tâp
̣
cac biê
́
n co cung kiêu đươc
̣
gă
́
n kê
́
t vơi nhau theo
́
̃
́
́
́
̀
́
̣
̣
h nao đo.
́
́
́
̀
́
Ví dụ về kiểu dữ liệu trừu tượng: Sô
́
nguyên.
̉
Kiêu dư liêu
̣
trưu tươn
̣
g sô
́
nguyên: ADT Integer:
̣
va môt dâu tiên tô la + hoăc -. Chꢁng ta ký hiệu cả số là
̃
̀
Dƣ liêu
̣
: môt
̣
tâp
̣
cac chư sô
́
́
̣
́
̀
́
̀
̃
̃
̀
N.
Các toán tꢅ:
constructor: khơi tao
̣
̣
môt số nguyên
̉
sub(k): trả về hiệu N – k.
add(k): trả về tổng N + k.
……
End
2.2 Đối tƣợng (Objects) và lớp (Classes)
Trong môt chương trinh hương đôi tương chung ta co cac đô
này là đại diện cho các đối tượng thực trong thực tế . Có thể coi khái niêm
̣
́
̣
́
i tươn
̣
g . Các đối tượng
đôi tương trong
đôi tươn
có các dữ liệu riêng của nó và được gọi là các member variable hoặc là các data member .
Các toán tử thao tác trên các dữ liệu này được gọi là các member function . Môi môt đô
i tương co cac
ng nhau va cac data member cung kiêu . Lơp là một sự trừu tượng hóa
́
́
́
́
̀
̣
́
̣
̉
̃
OOP chinh la cac kiêu dư liêu
̣
trong cac ngôn ngư lâp
̣
trinh co câ
́
u truc . Môi môt
̣
́
̣
g
̀
́
̃
́
̃
́
́
́
̀
̃
́i
̣
̉
tươn
member function giô
của khái niệm đối tượng. Tuy nhiên lơp không phai la môt
̣
g la thê hiên
̣
(instance) của một lớp. Như vây
̣
lơp la đai
̣
diên
̣
cho cac đô
́
̣
̀
́
̀
́
́
́
̉
́
̀
́
̀
́
̣
ADT , nó là một cài đặt của một
̉
́
̀
đăc
̣
ta ADT. Các đối tượng của cùng một lớp có thể chia sꢎ các dữ liệu dùng chung , dư liêu
̣
̉
̃
̉
kiêu nay được gọi là class variable.
̀
5
́
2.3 Kê thƣa (Inheritance)
̀
Khái niệm kế thừa này sinh từ nhu cầu sử dụng lại các thành phần phần mềm để phát
̉
triên cac phâ
̀
n mê
̀
m mơi hoăc
̣
mơ rôn
̣
g chưc năng cua phâ
̀
̣ ̣ ̣
n mềm hiên tai . Kế thưa la mô t
̀ ̀
̉
̉
́
́
́
̉
cơ chê
́
cho phep cac đô
́
i tươn
̣
g cua môt
̣
lơp co thê truy câp
̣
tơi cac member variable va
̉
́
́
́
́
́
́
̀
function cua môt
̣
lơp đa đươc
̣
xây dưn
̣
g trươc đo ma không câ
̀
n xây dưn
̣
g lai
̣
cac thanh
̉
̃
́
́
́
̀
́
̀
̉
phâ
̀
n đo. Điê
̀
u nay cho phep chung ta co thê tao
̣
ra cac lơp mơi la môt
̣
mơ rôn
̣
̣ ̣
g hoăc ca biêt
́
̉
́
̀
́
́
́
́
́
́
̀
hóa của một lớp sꢏn có . Lơp mơi (gọi là derived class ) kê
́
thưa tư lơp cu (gọi là lớp cơ sở
́
́
̀
̀
́
̃
base class). Các ngôn ngữ lập trình hướng đối tượng có thể hꢃ trợ khái niệm đa kế thưa cho
̀
̉
phꢆp một lớp có thể kế thừa từ nhiều lớp cơ sở . Lơp kế thưa derived class co thê co thêm
̀ ́ ́
́
̉
các data member mới hoặc các member function mới . Thêm vao đo lơp kế thưa co thê tiến
̀ ́
̀
́
́
hành định nghĩa lại một hàm của lơp cơ sơ va trong trương hơp nay ngươi ta noi rằng lơp
̣
̉
́
̀
̀
̀
̀
́
́
kế thưa đa overload ham thanh viên cua lơp cơ sơ.
̀
̃
̀
̀
̉
́
̉
̉
̣ ̣
hoăc đa thê)
2.4 Dynamic Binding (ràng buộc động) và Porlymorphism (đa xa
Chꢁng ta lấy một ví dụ để minh hoạ cho hai k hái niệm này. Giả sử chꢁng ta có một
lơp cơ sơ la Shape , hai lơp kê thưa tư lơp Shape la Circle va Rectange . Lơp Shape la môt
́
̣
̉
́
̀
́
̀
̀
́
̀
̀
́
̀
lơp trưu tương co môt member function trưu tương la draw (). Hai lơp Circle va Rectange
̣
̣
̣
́
̀
́
̀
̀
́
̀
̉
̣ ̣ ̣ ̣ ̣
hiên overload lai ham draw cua lơp Shape vơi cac chi tiết cai đăt khac nhau chăng han
̉
̀ ́ ́ ́ ̀ ́
thưc
vơi lơp Circle ham draw se ve môt
̣
̣
vong tron con vơi lơp Rectange thi se ve môt hinh chư
̀ ̀ ̀ ́ ́
̃ ̃ ̃
̀ ̀
́
́
̀
̃
̃
nhât
̣
. Và chꢁng ta có một đoạn chương trình chính hợp lệ như sau:
int main()
{
Shape shape_list[4];
int choose;
int i;
for(i=0;i<4;i++)
{
cout << “Ngay muon ve hinh tron(0) hay hinh chu nhat(1)”;
cin >> choose;
if(choose==0)
{
shape_list[i] = new Circle();
}else{
shape_list[i] = new Rectange();
}
}
for(i=0;i<4;i++)
{
6
shape_list[i]->draw();
}
}
Khi biên dic
thê xac đinh đươc
và do đó không thể xác định được phiên bản nào của hàm draw sꢅ được gọi thực hiện . Viêc
gọi tới phiên bản nào của hàm draw để thực hiện sꢅ được quyết định tại thời điểm thực
hiên chương trinh, sau khi đa biên dich và điều này được gọi là dynamic binding hoặc late
binding. Ngươc
dư liêu găn vơi no đươc
binding. Ví dụ này cꢋng cung cấp cho chꢁng ta một minh họa về khả năng đa thể
(polymorphism). Khái niệm đa thể được dùng để chỉ khả năng của một thông điệp có thể
̣
h chương trinh nay thanh ma thưc
̣
hiên
̣
(file .exe) trình biên dịch không
̀
̀
̃
̀
̉
̣
̣
trong mang shape _list thi phâ
̀
n tư nao la Circle phâ
̀
n tư nao la Rec tange
̉
̉
̉
́
̀
̀
̀
̀
̀
̣
̣
̣
̃
̀
̣
lai
̣
nê
́
u viêc
̣
xac đin
̣
h phiên ban nao se đươc
̣
goi
̣
thưc
̣
hiên
̣
tương ưng vơi
̉
̃
́
̀
́
́
̣
́
̣
quyê
́
t đin
̣
h ngay trong khi biên dic
̣
h thi ngươi ta goi
̣
đo la
static
̃
́
́
̀
́
̀
̀
̉
̣ ̣ ̣ ̣ ̣
gưi tơi cho cac đối tương cua nhiều lơp khac n hau tai thơi điêm thưc hiên chương
̉ ̉
́ ́ ́ ́ ̀
đươc
trình. Chꢁng ta thấy rꢐ lời gọi tới hàm draw sꢅ được gửi tới cho các đối tượng của hai lớp
̉
Circle va Rectange tai
̣
thơi điêm chương trinh đươc
̣
thưc
̣
hiên
̉
̣ ̣
́ khai niêm khac chăng han như name space va exception
́ ́
̣
. Ngoài các khái niệm cơ bản
̀
̀
̀
trên OOP con co thêm môt
̣
sô
̀
́
̀
handling nhưng không phai la cac khai niêm
̣
ban chất.
̉
̉
̀
́
́
̣
3. Ngôn ngƣ lâp trinh C++ và OOP.
̀
̃
Giô
phương tiên
mêm la qua trinh mô hinh hoa cac tran
chương trinh dưa
́
ng như bâ
́
t ky môt
̣
ngôn ngư nao cua con ngươi
̣
, môt ngôn ngư l ập trình là
̃
̀
̃
̀
̉
̀
̉
̃
̉
̣
phat triên cac chương trinh hay phần
́ ́
̀
̣
đê diên ta cac khai niêm
̣
, ý tưởng. Viêc
̣ ̣
g thai tư nhiên cua thế giơi thưc va xây dưng cac
́ ̀ ́
̉
́
́
̀
̣
̣
̉
̀
́
́
́
́
̀
̀
̣
trên cac mô hình đó.
́
̀
Các chương trình thực hiện chức năng mô tả phương pháp cài đặt của mô hình.
Các thế hệ ngôn ngữ lập trình : Có thể phân chia các thế hệ ngôn ngữ lập trình thành
hê:
4 thê
́
̣
̉
̉
1: vào năm 1954 – 1958 (Fortran I) vơi đăc
̣
điêm la cac biêu thưc toan hoc
̣
́
̀
́
́
́
2: vào năm 1959 – 1961 (Fortran II, Cobol) vơi cac thu tuc
̣
̉
́
́
3: vào những năm 1962 – 1970 (Pascal, Simula) vơi đăc
̣
trưng la cac khô
́
i, các lớp…
́
̀
́
̉
̃
4: đang phat triên chưa co dân chưng thưc ́.
̣
tê
Các ngôn ngữ này ngày càng cách xa ngôn ngữ máy và các trình biên dịch của chꢁng
ngày càng phải làm việc nhiều hơn.
́
́
́
̉
́
̣ ̣ ̣
phat triên cua cac ngôn ngƣ lâp trinh hƣơng đôi tƣơng
́ ́ ̃ ́
̉
̀
3.1 Sƣ
1967 Simula
1970 to 1983 Smalltalk
7
1979 Common LISP Object System
1980 Stroustrup starts on C++
1981 Byte Smalltalk issue
1983 Objective C
1986 C++
1987 Actor, Eiffel
1991 C++ release 3.0
1995 Java
1983 to 1989 Language books with OO concepts
1989 to 1992 Object-oriented design books
1992 to present Object-oriented methodology books
Các ngôn ngữ lập trình khác
Java
Self
Python
Perl
Prograph
Modula 3
Oberon
Smalltalk Venders
ParcPlace, Digitalk, Quasar
Prolog++
Ada 9X
Object Pascal (Delphi)
Object X, X = fortran, cobal, etc.
C#.
Như vây
̣
la co râ
́
t nhiê m ưu
̃
chung la C ++ và Java. Môi ngôn ngư đều co đăc điêm riêng cua no va thich
̣
̃
́
̀
u ngôn ngư lâp
̣
trinh hương đô
́
i tươn
̣
g đa ra đơi va chiê
́
̀
́
̃
́
̃
̀
̀
̀
̉
thê
hơp
OOP nhâ
́
trong sô
́
̉
́
̀
́
̀
́
̉
̣
vơi cac linh vưc
̣
khac nhau nhưng co le C ++ là ngôn ngư cai đăt
̣
nhiê
̀
u đăc
̣
điêm cua
̃
̃
̀
̉
́
́
́
́
̃
́
t.
̣
3.2 Ngôn ngƣ lâp trinh C++.
̀
̃
C++ là một ngôn ngữ lập trình hướng đối tượng được Bjarne Stroustrup
(AT & T
Bell Lab) (giải thưởng ACM Grace Murray Hopper năm 1994) phát triển từ ngôn ngữ C.
̉
̣ ̣ ̣ ̣
́ thưa cu phap va môt số đăc điêm ưu viêt cua C : ví dụ như xử lý con trỏ , thư viên
̉
̀ ́ ́ ̀
C++ kê
các hàm phong phꢁ đa dạng , tính khả chuyển cao , chương trinh chay
̣
nhanh … . Tuy nhiên
̀ ban chất thi C++ khác hoàn toàn so với C, điều nay la do C++ là một ngôn ngữ lập trình
̉
̀
̀
vê
hương đô
̀
̀
́
i tươn
4. Bài tập
Bài tập 1: Download bộ công cụ DevCpp từ Internet và cài đặt trên máy tính của
̣
g.
́
mình, viết chương trình đầu tiên, thực hiện biên dịch và chạy thử.
Bài tập 2: Download bộ công cụ Visual Studio từ website của Microsoft và cài đặt
trên máy tính của mình, viết chương trình, thực hiện biên dịch và chạy thử.
8
̀
̉
CHƢƠNG II: NHƢNG KHAI NIÊM MƠ ĐÂU
̃
́
̣
̀
1. Chƣơng trinh đâu tiên
̀
1.1 Quá trình biên dic
Tât ca cac ngôn ngư trên may tinh đê
có thể hiểu được một cách dꢍ dàng (các file mꢄ nguồn được viết bꢂng một ngôn ngữ bậc
cao) sang dang co th ể thực hiện được trên máy tính (các lệnh dưới dạng ngôn ngữ máy ).
Các chương trình thực hiện quá trình này chia thành hai dạng được gọi tên là các trình
thông dich (interpreter) và các trình biên dịch (compiler).
Trình thông dꢆch: Môt trinh thông dich se dich ma nguô
(activity), các hành động này có thể bao gồm một nhóm các lệnh máy và tiến hành thực
hiên ngay lâp tưc cac hanh đông nay. Ví dụ như BASIC là một ngôn ngữ điển hình cho các
ngôn ngư thông dic
̣
h môt chƣơng trinh C++
̣
̀
́
̣ ̣ ̣ ̣
̀u đươc dich tư môt dang nao đo ma con ngươi
̀ ̀ ́ ̀ ̀
̉
̃
́
́
́
̣
́
̣
̣
̣
̣
̣
̀n thanh cac hanh đông
̀ ́ ̀
̃
̃
̀
̣
̣
̣
́
́
̀
̀
̉
̉
̣
h . BASIC cô điên thông dic
̣
h tưng dong lên
̣
̣ ̣
h thưc hiên va sau đo quên
̀ ́
̃
̀
̀
ngay lâp
̣
tưc dong lên
̣
h vưa thông dic
̣
h
. Điê
̀
u nay lam cho qua trinh thưc
̣
hiên
̣
ca môt
̣
̉
́
̀
̀
̀
̀
́
̀
chương trinh châm
̣
vi bô
̀
̣
thông di c
̣
h phai tiên hanh dic
́
̣
h lai
̣
cac đoan
̣
ma trung lăp
̣
. BASIC
̉
̃
̀
́
̀
̀
ngày nay đꢄ thêm vào qꢁa trình biên dịch để cải thiện tốc độ của chương trình
. Các bộ
̉
thông dic
̣
h hiên
̣
đai
̣
chăng han
̣
như Python , tiê
hiên băng môt
theo kiêu thông dich thương co môt
các dự án lớn (Có lꢅ chỉ duy nhất Python là một ngoại lệ ). Bô
̣ ̣ ̣
́n hanh dich toan bô chương trinh qua môt
̀ ̀
̀
ngôn ngư trung gian sau đo thưc
̣
̣
̀
̣
bô
̣
thông dic
sô han
́
̣
h nhanh hơn râ
chê nhât đinh khi xây dưn
thông dich cân phai luôn
̉
̣ ̣ ̣ ̣
lưu trong bô nhơ đê thưc hiên cac ma chương trinh , và thậm chí ngay cả bộ thông
́
́
t nhiê
̀
u
. Các
̣
g
̃
́
̉
ngôn ngư lam viêc
̣
̣
̣
́
̣
́
́
̣
̃
̀
̀
̣
̣
̀
̉
đươc
dịch có tốc độ nhanh nhất cꢋng không thể cải thiện được hoàn toàn các hạn chế tốc độ .Hầu
hêt cac bô thông dich đêu yêu câu toan bô ma nguôn cân phai đươc thông dich môt lân duy
nhâ u nay không nhưng dân vê kich thươc cua chương trinh ma con
tạo ra các lꢃi rất khó gꢊ rối nếu như n gôn ngư không cung câ
́
̃
̀
́
̣
̣
̀
̀
̣
̀
̀
̣
̣
̣
̀
̃
̉
́
̀
́
t. Điê
̀
̃
đê
́
n cac han
̣
chê
́
̀
̃
́
́
̉
̀
̀
̀
́
̀
̉
̣ ̣
p cac công cu hiêu qua đê xac
̉
́ ́
́
̃
đin
̣
h hiêu
̣ ̣
ưng cua cac đoan ma khac nhau.
̉
̃
́ ́ ́
Trình biên dꢆch : Môt
assembly hoăc cac lênh may. Kê
mꢄ máy. Đây la môt
̣
trinh biên dic
̣
h dic
̣
h ma nguô
̀
n trưc
file duy nhâ
̣ ̣
qua trinh phưc tap va đoi hoi môt vai bươc . Quá trình chuyển đổi từ
̉
́ ́ ̀ ̀
̀
̣
tiê
̣
t hoăc cac file chưa cac
́ ́ ́
́p thanh ngôn ngư
̃
̀
̃
̀
̣
̣
́
t qua cuô
́
i cung la môt
̣
́
̉
́
́
̀
̀
̣
̀
̀
́
mꢄ chương trình ban đầu thành mꢄ thực hiện là tương đối dài đối với một trình biên dịch .
Tùy thuộc vào sự nhạy cảm của người viết trình biên dịch , các chương trình sinh ra bởi
môt
hơn râ
môt trinh biên dic
nhât. Môt
chương trinh co thê đươc
̣
trinh biên dic
̣
h co xu hương đoi hoi it bô
̣
nhơ hơn khi thưc
̣
hiên
̣
, và chꢁng chạy nhanh
u cho viêc sư dun
đây không phai la cac ly do quan tron
̉
́
́
̀
́
̀
́
́
t nhiê
̀
u. Măc
̣
du kich thươc va tô
́
c đô
̣
thương la cac ly do hang đâ
̀
̣
̣
g
̉
̀
́
̀
̀
̀
́
́
̀
́
̣
̣
h , trong râ
́
t nhiê
̀
u trương hơp
̣
̣
g
̉
̀
̀
́
́
̀
̉
̉
̣ ̣ ̣
thiết kế đê cac phần tach biêt cua môt
̉
́ ́
́
̣
vai ngôn ngư (chăng han
̣
như C ) đươc
h đôc lâp hoan toan vơi nhau . Các phần này sau đó thậm
chí có thể kết hợp thành một chương trình thực hiện cuối cùng duy nhất bởi một công cụ
có tên là trình liên kết . Quá trình này gọi là separate compilation (biên dich đôc lâp). Biên
dịch độc lập có rất nhiều điểm lợi . Môt chương trinh nêu dich ngay lâp tưc toan bô se vươt
quá các giới hạn của trình biên dịch hay môi trường biên dịch có thể được biên d ịch theo
tưng phân. Các chương trình có thể được xây dựng và kiểm thử từng phần một . Nêu mot
i đa hoan thanh .
̀
̃
̉
̣
biên dic
̣
̣
̣
́
̀
̀
́
̀
̣
̣
̣
̣
́
̣
̣
̣
̃
̣
́
̀
̀
̀
́
̣
̀
̉
phâ
Tâp
viên
chương trinh lơn. Các đặc điểm gꢊ lꢃi của trình biên dịch đꢄ cải t iê
̀
n nao đo đa lam viêc
̣
đung đă
́
n no co thê đươc
̣
lưu lai
̣
như la môt
̣
khô
̣
vơi nhau tao thanh cac thư
̀ ́
́
̀
́
̃
̀
́
́
́
̀
̃
̀
̀
̉
̉
̣
cac phâ
̀
n đa lam viêc
̣
va đươc
̣
kiêm thư co thê kê
́
t hơp
̉ ̉
̣ ̣
đê cac lâp trinh viên khac co thê sư dung . Các đặc điểm này hꢃ trợ cho việc tạo ra các
̉
́ ́ ́
̀
̣
lai
̣
̃
̀
̀
̉
́
́
́
̣
̉
̣
n môt cach đang kê qua
́ ́
́
́
̀
9
thơi gian. Các trình biên dịch đầu tiên chỉ sinh ra mꢄ máy , và lập trình viên phải chèn các
̀
̉
̣ ̣ ̣
h in vao đê xem thưc sư chương trinh đang lam gi . Điều nay không phai luc nao
̉
̀ ̀ ̀ ́ ̀
̀ ̀
câu lên
cꢋng hiệu quả. Các trình biên dịch hiện đại có thể chèn các thông tin về mꢄ nguồn vào mꢄ
thưc hiên cua chương trinh. Thông tin nay se đươc sư dung bơi cac bô gơ lôi câp đô nguô
đây năng lưc chương trinh băng cach
theo dâu (tracing) quá trình thực hiện của nó qua toàn bộ mꢄ nguồn . Môt
dịch giải quyết vấn đề tốc độ biên dịch bꢂng cách thực hiện quá trình biên dịch trong bộ
nhơ (in-memory compilation). Các trình biên dịch theo kiểu này lưu trình biên dịch trong
̃
́
̀n
̣
̣
̣
̣
̣
̣
̉
̃
̉
̉
̃
̀
́
̀
̉
̃
̀
̣
đê chi ra chinh xac điê
̀
u gi đang diên ra tro ng môt
̣
̀
̉
́
́
́
̀
̀
́
̣
vai trinh biên
̀
̀
́
bô
̣
nhơ RAM . Đối với các chương trình nhỏ , quá trình này có thể xem như là một trình
́
thông dic
̣
h.
Quá trình biên dꢆch
̉
̉
Đê lâp
quá trình biên dịch . Môt
biên dich băng cach chay
trình đơn giản thay thế các mẫu trong mꢄ nguồn bꢂng các mẫu khác mà các lập trình viên
đa đinh nghia (sư dung cac chi thi tiên xư ly : preprocessor directives). Các chỉ thị tiền xử
go cac đoan
̣
trinh bă
̀
ng C va C ++ chꢁng ta câ
̀
n phai hiêu cac bươc va cac công cu
̣
trong
̉
̀
́
́
̀
́
̀
̣
vai ngôn ngư (đăc
̣
biêt
̣
la C va C ++) bă
i vơi ma nguô
́
t đâ
̀u thưc hiên qua trinh
̣
̣
̀
̃
̀
̀
́
̀
̣
̀
̣
môt
̣
bô
̣
tiê
̀
n xư ly đô
́
̀
n . Bô
̣
tiên xư ly la một chương
̀
̉
̃
̉
́
́
́
́
̀
̣
̣
̣
̀
̃
̉
́
̉
́
̃
̉
lý được sử dụng để tiết kiệ m viêc
̣
̣ ̣
chương trinh thương xuyên sư dung va tăng
̉
̀ ̀
̀
̃
́
khả năng dꢍ đọc cho mꢄ nguồn . Tuy nhiên cac chi thi
̣
̀n xư ly nay đôi khi cung gây ra
̉
̃
́ ̀
́
̉
nhưng lô
̃
i râ
file tam
là phân tích mꢄ tiền xử lý. Bô
chꢁng thành một câu truc goi
“+”, “B” se đươc lưu trên nut cua cây phân tich
́
t tinh vi va kho phat hiên
. Các trình biên dịch thường thực hiện công việc của nó theo hai pha . Đầu tiên
̣
̣
ghi lên
̃
̀
́
́
̀
môt
̣
̣
̉
̣ ̣
h chia ma tiền xư ly thanh cac đơn vi nho va tô chưc
̃
́ ̀ ́ ̀ ́
̉ ̉
̣
biên dic
́
̣
la cây . Ví dụ như trong biểu thức : “A+B” cac phâ
̀
̀
n tư “A” ,
̉
́
́
̣
. Môt
̣
bô
̣
tơi ưu hoa toan cuc
̣
(global
̃
́
̉
́
́
̀
́
̉
optimizer) đôi khi cung đươc
̣
sư dun
̣
g đê tao
̣ ̣
sinh ma duyêt qua cây phân tich va sinh ra hoăc la ma
̀ ̀
̃
́
̣
ra ma chương trinh nho hơn, nhanh hơn.
̃
̉
̀
̃
̉
Trong pha thư hai , bô
̣
́
̃
assemble hoăc
̣
ma may cho cac nut cua cây . Nê
́
u như bô
hiên côn g viêc
module object (môt file thương co đuôi la .o hoăc
̣ ̣
bô tối ưu hoa nho (peep-hole) sꢅ được sử dụng để loại bỏ các đoạn chứa các câu lệnh
̣
sinh ma tao ra ma assembly , thì
̣
̃
́
́
́
̉
̃
̃
sau đo chương trinh dic
̣
h ma assembler se thưc
̣
̣
̣
tiếp theo . Kết qua cua hai
̉ ̉
́
̃
̃
̀
trương hơp
̣
trên đê
̀
u la môt
̣
̣
̣
.obj). Sau đo
̀
̀
̀
́
̀
́
môt
̉
́
̉
assembly thưa. Viêc
̣
sư dun
̣
g tư “object” đê mô ta cac đoan
̣
ma may la môt
̣
̣
thưc tế không
̉
̉
̃
̀
̀
́
́
̀
đung lă
́
m. Tư nay đa đươc
̣
dung trươc ca khi lâp
̣
trinh hương đô
́
i tươn
biên dich, trong khi đo trong lâp
trình hướng đối tượng nó lại có nghĩa là “a thing with boundaries” . Trình liên kết kết hợp
̣
g ra đơi . Tư “object”
́
̀
̀
̃
̀
́
̉
́
̀
̀
̀
đươc
̣
sư dun
̣
g co y nghia như la tư “goal” khi noi vê
̀
viêc
̣
̣
̣
̉
́
́
̀
̀
́
́
̃
̉
̣ ̣ ̣
co thê nap vao bô nhơ
́ ̀ ́
môt
và thực hiện bởi hệ điều hành . Khi môt
chiêu tơi môt ham hoăc môt biên trong môt
lại các tham chiếu này ; điêu nay đam bao ră
dụng trong quá trình biên dịch là đều tồn tại . Trình liên kết cꢋng thêm vào các module
̣
danh sach cac module object thanh môt
̣
chương trinh thưc
̣
hiên
module object tao
̣
module object khac , trình liên kết sꢅ sắp xếp
́
́
̀
̀
̣
ham trong môt
̣
̣ ̣
ra môt tham
̀
́
̣
̣
̣
́
́
̀
́
̀
̀
ng tâ
́t ca c ác hàm và dữ liệu external được sử
̉
̉
̉
̀
̉
object đăc
các file đăc
viên chưa môt
môt
̣
biêt
biêt
tâp
̣
lâp trinh viên co tên la librarian.
̣
đê thưc
̣
hiên
̣
cac hanh đôn
̣
g khơi đông . Trình liên kết có thể tìm kiếm trên
̣
̉
́
̀
̉
̣
̣
goi la cac thư viên
̣
̣
đê să
́
p xê
́
p lai
̣
tất ca cac tham chiếu tơi chung . Môi thư
̃
̉
́ ́ ́
̀
́
̣
̣
̣
cac module object trong môt
́
̣
file. Môt
̣
thư viên
̣
đươc
̣
tao
̣
ra va bao tri bơi
̉
̉
́
̀
̀
̣
́
̀
̀
̉
̉
Kiêm tra kiêu tinh
̃
10
Trình biên dịch thực hiện kiểm tra kiểu trong pha đầu tiên của quá trình biên dịch
Quá trình kiểm tra này thực hiện kiểm thử việc sử dụng các tham số của các hàm và ngăn
.
̣ ̣
chăn rất nhiều lôi lâp trinh k hác nhau. Vì quá trình kiểm tra kiểu được thực hiện trong qꢁa
̃
̀
trình biên dịch chứ không phải trong quá trình chương trình thực hiện nên nó được gọi là
̉
̉
̉
kiêm tra kiêu tinh. Môt
̣
vai ngôn ngư lâp
̣
trinh hương đô
́
i tươn
̣
g (Java chꢑng hạn) thưc
u kêt hơp
g cung lam cho
̣
hiên
ca
̉
̣
̀
̃
́
̃
̀
̉
̉
kiêm tra kiêu tai
̣
thơi điêm chương trinh chay
̣
(dynamic type checking). Nê
́
́
̣
̀
̀
̉
̉
̉
̉
viêc
̣
kiêm tra kiêu tinh va đôn
̣
g thi se hiêu
̣
qua hơn nhưng kiêm tra kiêu đôn
̣
̃
̉
̃
̀
̀
̃
̀
̉ ̉ ̉
̣ ̣
a nh hương đôi chut . C++ sư dung kiêm tra kiêu tinh . Kiêm tra
̉ ̉ ̉
́
̃
chương trinh thưc
̣
hiên
̣
̣
bi
̀
̉
kiêu tinh bao cho lâp
̣ ̣
trinh viên về cac lôi về sư dung sai kiêu dư liêu trong qua trinh biên
̃
̉
̉
̃
́ ́
̀ ̀
́
̃
dịch, và do đó tối ưu hóa tốc độ thực hiện chương trình . Khi hoc
hêt cac quyêt đinh thiêt kê cua ngôn ngư đêu tâp trung vao cung cô
nhanh, hương đôi tương, các đặc điểm mà đꢄ làm cho ngôn ngữ C trở nên nổi tiếng . Chꢁng
ta co thê không dun g tuy chon
̣
C++ chꢁng ta sꢅ thấy hầu
̉
́
́
̣
́
́
̀
̣
́
cac đăc
̣
điêm : tô
́
c đô
̣
̉
̃
̉
́
̀
́
́
̣
́
̉
̉
̉
̉
̣
kiêm tra kiêu tinh cua C ++ hoăc
̣
cung co thê thưc
̣
hiên
̣
viêc
̣
̉
̃
́
̀
̀
́
̃
̉
̉
kiêm tra kiêu đôn
Các công cụ cho việc biên dꢆch độc lập
Viêc biên dich đôc lâp rât cân thiêt nhât la đô
và C++, môt lâp ra cac đoan
lâp
̣
g - chỉ cần viết thêm mꢄ.
̣
̣
̣
̣
́
̀
́
́
̣
́i vơi cac dư an lơn. Trong ngôn ngư C
́ ́ ́ ́
̃
̃
chương trinh nho dê quan ly va đươc
̣ ̣
̉ ̉
́ ̀
̀
̀
̉
̣
̣
̣
trinh viên co thê tao
̣
́
́
̀
̉
̉
kiêm thư đôc
̣
. Công cu
̣
cơ ban đê chia môt
̣
chương trinh thanh cac phâ
̀
n nho la kha
̉
̉
̉
̀
̉
̀
́
̀
năng tao
̣
ra cac thay thê
́
đươ
̣
c đăt
̣ ̣
tên hay la cac chương trinh con . Trong C va C ++ môt
̀ ́ ̀
̀
́
chương trinh con đươc
̣
goi la môt
̣
̣
ham , và các hàm là các đoạn mꢄ có thể được thay thế
̀
̀
̀
trong cac file khac nhau , cho phep thưc
̣
hiên
̣
qua trinh biên dic
̣
h đôc
̣
lâp
̣
̣
. Nói môt cach
́
́
́
́
́
̀
khác các hàm là các đơn vị nguyên tử của mꢄ nguồn , vì chꢁng ta không thể đặt các phần
khác nhau của hàm trong các file khác nhau nên nội dung của một hàm cần phải được đặt
̉
̣
du cac file co thê chưa nhiều hơn 1 hàm).
̀ ́ ́ ́
hoàn toàn trong một file (măc
Khi chung ta goi đên môt
các giá trị mà chꢁng ta muốn hàm làm việc với khi nó thực hiện . Khi ham thưc
̣
́
̣
ham, chꢁng ta thường truyền cho nó một vài tham số , đo la
́
̀
́
̀
̣
hiên
như la môt kê
Cꢋng có thể viết các hàm không nhận các tham số và không trả về bất kꢈ giá trị nào . Đê
tạo ra một chương trình với nhiều file , các hàm trong môt file phai truy câp tơi cac ham va
dư liêu trong cac file khac . Khi biên dich môt file, trình biên dịch C hoặc C++ phải biết về
các hàm và dữ liệu trong các file khác đặc biệt là tên và cách dùng chꢁng . Trình biên dịch
đam bao cac ham va dư liêu đươc sư dung đung đăn . Qꢁa trình báo cho trình biên dịch tên
và nguyên mẫu của các hàm và dữ liệu bên ngoài được gọi là khai báo (declaration). Khi
̣
xong
̀
chꢁng ta thường nhân
̣
đươc
̣
môt
̣
gia tri
tra vê
̀
, môt
̣
gia tri
́
ma ham tra lai
̣
̣
́t qua.
̉
̉
̉
́
̀
̀
̀
̉
̣
̣
̉
́
́
̀
̀
̣
̣
̣
̃
́
́
̣
̣
̣
́
̉
̉
̃
̉
́
̀
̀
́
̉
̉
chꢁng ta đꢄ khai báo một hàm hoặc biế n trinh biên dic
̣
h se biê
́
t cach thưc kiêm tra đê đam
̃
́
́
̉
̀
bảo các hàm và dữ liệu này được sử dụng đꢁng đắn.
Including cac file Header
́
̉
̉
Hâ
̀
u hê
́
t cac thư viên
̣
đê
nhât quan khi khai bao ngoai cac phâ
dụng một loại file được gọi là file header . Mô
ngoài cho 1 thư viên; theo qui ươc cac file nay co phâ
có thể dùng các đuôi file khác cho chꢁng chꢑng hạn như .hpp hoăc
̀
u chưa môt
̣
sô
́
lươn
̣
g đang kê cac ham va biê
́
n . Đê tiê
́t kiêm
̣
́
́
́
́
̀
̀
công sưc va đam bao sư
̣
́
̀n tư nay , C va C ++ đa sư
̉
̉
̉
̃
̉
́
̀
́
́
̀
́
̀
̀
̃
i file header la môt file chưa cac khai bao
̣
̀
́
́
́
̣
̣
̀ n mơ rông la .h, nhưng chung ta cung
̉
̃
̀ ́
́
́
̀
́
̣
.hxx. Lâp
p cac header file . Đê khai bao cac ham va cac biến bên ngoai
̀
trinh viên tao
̣ ̣
̀
̉
ra cac file thư viên
̣
se cung câ
́
́
̃
́
́
́
̀
̀
́
̉
̣ ̣ ̣
hiên include file header đo . Đê include môt file
́
thư viên
̣
ngươi dung đơn gian chi câ
̀
n thưc
̉
̀
̀
̉
header chung ta sư dun
̣
g chi thi
tiê
̀
n xư ly #include. Chỉ thị này sꢅ báo cho bộ xử lý mở file
̉
̉
́
̉
́
11
header co tên tương ưng va chen nôi
̣
dung cua file đo vao chô
̃
ma chi thi
̣
̣
#include đươc sư
̉
̉
́
́
̀
̀
́
̀
̀
̉
̉
dụng. Tên file sư dun
̣
g sau chi thi
̣
#include co thê nă
̀
m giưa hai dâ
́
u < và > hoăc giưa hai
̣
̉
̃
̃
̉
́
dâ
́
u “.
Ví dụ: #include <header.h>
Nêu chung ta sư dung chi thi
header theo cach đăc
́
̣
̣
ộ tiền xử lý sꢅ tìm file
̉
́
̉
́
̀
̣
thu đô
́
̣
vai
̀
́
̀
́
̀
̀
̃
́
̀
đương dân
̃
ma chung ta chi đin
̣
h cu
dꢀng lệnh để sử dụng cho việc tìm các file header . Cơ chê
̣
thuôc vao trinh biên dich va môi trương ma chung ta lam viêc.
̣
thê trong biê
̉
́
n môi trương cua trinh biên dic
̣
h hoăc
cac đương dân nay phu
̃
̣
̀
̣
trên
̉
̀
̀
́
̉
̀
̀
́
thiê
́
t lâp
̣
́
̀
̣
̣
̀
̀
̀
̀
́
̀
̀
Ví dụ: #include “header.h”
Chỉ thị tiền xử lý như trên thường có ý nghĩa là báo cho bô
ứng trong thư mục hiện tại trước nếu không thấy thì sꢅ tìm giống như trong trường hợp tên
file include đươc đăt giưa hai dâu < và >. Nói chung thì đối với các file include chuẩn hoặc
đươc sư dung nhiêu chung ta nên đăc no trong thư muc măc đinh la include dươi thư muc
cài đặt trình biên dịch và dùng chỉ thị theo kiểu <>, cꢀn đối với các file đặc thù với ứng
̣
tiền xư ly tim file tương
̉
́
̀
̣
̣
́
̃
̣
̣
̀
̣
̣
̣
̣
̣
̉
́
́
̀
́
̉
dụng cụ thể thì dùng kiểu tên file đặt giữa hai dấu “” . Trong qua trinh phat triên cua C ++
̉
́
́
̀
các nhà cung cấp các trình biên dịch có các qui ước đặt tên khác nhau và các hệ điều hành
lại có các hạn chế tên khác nhau đặc biệt là độ dài của tên file . Các vấn đề này gây ra các
̉
̉
vâ
môt
mơ rôn
́
n đê
đin
g. Đê phân biêt
ky tư “c” vao trươc tên cua cac file header , chi tiê
̀
vê
̣ ̣
̀
tinh kha chuyên cua chương trinh . Đê khă
́
c phuc
̣
vâ
̣
́n đề nay ngươi ta đa sư dung
̀ ̀
̃
̉
̉
̉
́
̀
̉
̉
̣
h dang chuân cho phep cac tên file header co thê dai hơn 8 ký tự và bỏ đi phần tên
́
́
́
̀
̉
̣
̣ ̣
môt chương trinh C va C ++ đôi khi ngươi ta con dung cach thêm
̀ ̀ ̀ ̀ ́
̀
̉
môt
̣
̣
́
t nay cung đươc
̣
châ
́
p nhân
̣
đô
́
i vơi C
̉
̃
́
̀
́
́
̀
́
và C++.
Quá trình liên kết
Trình liên kết tập hợp các module object (thương la cac file có phần mở rộng là .o
̀
̀
́
hoăc
̣ ̣ ̣
.obj), đươc sinh ra bơi trinh biên dich , thành một chương trình có thể thực hiện được
̉
̀
và hệ điều hành có thể nạp vào bộ nhớ và chạy . Đây la pha cuô
́
i cung trong qua trinh biên
̀
̀
́
̀
̉
̉
dịch. Các đặc điêm cua cac trinh liên kê
́
t thay đôi phu
̣
thuôc
̣
vao cac hê thống khac nhau .
̣
̉
́
̀
́
́
̀
Nói chung chꢁng ta chỉ cần chỉ rꢐ cho trình liên kết biết tên của các module object và các
thư viên cuô
hê thông đoi hoi chung ta câ t . Tuy nhiên hâ
̣ ̣ ̣ ̣
biên dic hiên hô chung ta công viêc nay.
́
̣
ma chung ta muô
́
n liên kê
́
t , và tên của chương trì nh kha chay
̣
́
i cung . Môt
̣
vai
̀
̀
̉
̀
́
̀
̣
́
̀
n phai tư
̣
goi
̣
tơi cac trinh liên kê
́
̀
u hê
́
t cac trinh
̉
̉
̀
́
́
́
́
̀
̣
h hoan chinh đê
̀
u thưc
̀
̉
̀
Sƣ dun
̣
g cac thƣ viên
̣
̉
́
Giơ đây ch ꢁng ta đꢄ biết các thuật ngữ cơ bản , chꢁng ta có thể hiểu cách thức sử
̀
̉
dụng một thư viện. Đê sư dun
̣
̣ ̣
g môt thư viên cần phai:
̉
̉
+ Include file header cua thư viên
̣
̉
+ Sư dun
̣
g cac ham va cac biê
́
n trong thư viên
t thư viện vào chương trình khả chạy cuối cùng
Các bước này cꢋng đꢁng với các module object không có trong các thư viện
̣
̉
́
̀
̀
́
+ Liên kê
́
.
̉
̣ ̣ ̣
file header va liên kết cac module object la cac bươc cơ ban đê thưc hiên
̉
̀ ́ ̀ ́ ́
Including môt
̣ ̣
viêc biên dich đôc lâp trong C va C++.
̀
̣
̣
12
Trình liên kết làm thế nào để tìm một file thƣ viện
Khi chung ta tao ra môt tham chiêu ngoai tơi môt ham sô
C++, trình liên kết , khi băt găp tham chiê
sau: nêu no chưa thây phân đinh nghia cua ham hay biê
danh sach cac tham chiêu chưa đươc
h nghia cua tham chiêu đo , tham chiê
̣
̣
́
̣
́
hoăc
̣ ̣
môt biến số trong C
́
̀
́
̀
hoăc
̣
́
̣
́
u nay , có thể thực hiện mộ t trong hai viêc
̣
̀
́
́
̀
̣
́n nay , nó sꢅ thêm định danh vào
̉
́
̀
̀
̃
́
̣
đin
̣
h nghia cua no . Nê
́
u như trinh liên kê
p lai
́
t đa bă
́
t găp
̣
̉
̃
́
́
́
̃
̀
đin
̣
́
́
u se đươc
̣
să
́
p xê
́
̣
. Nê
́
u như trinh liên kê
́t
̉
̃
́
̃
̀
không tim thâ
́
y đin
hành tìm kiếm trong các thư viện . Các thư viện có một vài loại chỉ số nên trình li ên kê
không cân thiêt phai tim kiêm hêt trong cac module objetc cua thư viên – nó chỉ cần xem
xꢆt các phần chỉ mục . Khi trinh liên kê h nghia trong môt thư viên , toàn
nh nghia cua ham , sꢅ được liên kết vào chương
̣
h nghia cua tham chiê
́
u trong danh sach cac module object no se tiến
̉
̃
́
́
́
̀
̃
́
t
̀
́
́
́
̣
̉
̉
́
̀
́
t tim thâ
́
y môt
̣
đin
̣
̣
̣
̀
̀
̃
bô
trình thực hiện. Chꢁ ý rꢂng toàn bộ thư viện sꢅ không được liên kết, chỉ có phần định nghĩa
mà chương trình tham chiếu tới . Như vây nêu chung ta muôn tôi ưu vê kich thươc cu
chương trinh chung ta co thê cho môi ham vao môt file khi xây dưng cac thư viên
̣
module object chư không chi phần đi
̣
̉
́
̉
̀
̃
̣
́
́
́
̀
a
̉
́
́
́
̉
̃
̣
̣
̣
riêng cua
̉
́
́
̀
̀
́
̀
̉
mình. Điều nay đoi hoi công sưc edit nhiều hơn nhưng cung co thê co ich . Vì trình liên kết
̉
̃
̀ ̀ ́ ́ ́
́
tìm kiếm các file theo thứ tự chꢁng ta c ó thể che đi sự tồn tại của một hàm thư viện bꢂng
cách dùng hàm của chꢁng ta với phần định nghĩa và prototype y hệt như hàm thư viện . Tuy
̃
̉
̉
nhiên điê
Khi môt
thành phần nhất định sꢅ được liên kết với nó một cách bí mật . Môt
này chính là module khởi động (startup), module nay chư a cac thu tuc
̀u nay cung co thế gây ra cac lôi ma chung ta không thê kiêm soat đươc.
̣
̀
̃
́
́
̀
́
́
̣
chương trinh kha chay
̣
đươc
̣
viê
́
t bă
̀
ng C hoăc
̣
C ++ đươc
̣ ̣ ̣
tao ra, môt số cac
́
̉
̀
̣
trong cac thanh phần
́
̀
̣
khơi tao
̣
câ
̀n phai
̉
̉
̉
̀
́
́
đươc
̣
thưc
̣
hiên
̣
bâ
́
t cư khi nao môt
̣
chương trinh C hay C ++ bă
́
t đâ
̀u chay. Các thủ tục này
̣
́
̀
̀
thiêt lâp
́
̣
stack va cac biê
́
n khơi tao
̣
nhâ
́t đinh trong chương trinh.
̣
̉
̀
́
̀
Trình biên dịch luôn thực hiện vi ệc tìm kiếm trong các thư viện chuẩn để thực hiện
̉ ̉
́t cac ham chuân ma chung ta dung trong chương trinh nên đê dung cac ham trong
́ ̀ ̀ ́ ̀ ̀ ́ ̀
̀
liên kê
các thư viện chuẩn chꢁng ta đơn giản chỉ cần include file header của thư viện đó . Cꢀn đối
vơi cac thư viên riêng do chung ta tao ra chung ta cân chi ro tên thư viên cho trinh liên kê
̣
̣
̀
̣
́t
́
́
́
́
̉
̃
̀
̉
̉
̣ ̣ ̣ ̣
thư viên graphics không phai la môt thư viên chuân).
̉
̀
(chăng han
̀
1.2 Chƣơng trinh đâu tiên.
̀
Cách tốt nhất để học lập trình là xem các chương trình của người khác viết và học tập
các kỹ thuật lập trình của họ . Sau đây la chương trinh HelloWorld đươc
̣
viê
́
t bă
̀
ng C ++,
̀
̀
môt
̣
chương trinh ma hâ
̀
u hê
́
t cac sach lâp
̣
trinh đê
̀
u lâ
́
y lam vi du
̣
mơ đâ
̀
u.
̉
̀
́
́
̀
̀
̀
́
// Chương trình HelloWorld
// File hello.cpp
// In ra man hinh xâu “Hello, World!”
̀
̀
̉
#include <iostream.h> // Khai bao luô
̀
ng cout đê sư dun
̣
g
̉
́
int main() {
cout << "Hello, World! I am "
13
Tải về để xem bản đầy đủ
Bạn đang xem 20 trang mẫu của tài liệu "Giáo trình Lập trình hướng đối tượng và C++ - Trường Đại học Hàng Hải", để tải tài liệu gốc về máy hãy click vào nút Download ở trên
File đính kèm:
- giao_trinh_lap_trinh_huong_doi_tuong_va_c_truong_dai_hoc_han.pdf