Cẩm nang lập trình C+++
ĐẠI HỌC ĐÀ NẴNG
TRƯỜNG ĐẠI HỌC KỸ THUẬT
KHOA CÔNG NGHỆ THÔNG TIN - ĐIỆN TỬ VIỄN THÔNG
GIÁO TRÌNH MÔN HỌC
LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG
BIÊN SOẠN: LÊ THỊ MỸ HẠNH
ĐÀ NẴNG, 09/2002
Giáo trình môn Lập trình hướng đối tượng Trang
Biên soạn: Lê Thị Mỹ Hạnh
2
MỤC LỤC
CHƯƠNG 1: GIỚI THIỆU VỀ LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG.......................... 5
I. LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG (OOP) LÀ GÌ ? .............................................. 5
I.1. Lập trình tuyến tính ............................................................................................ 5
I.2. Lập trình cấu trúc................................................................................................ 5
I.3. Sự trừu tượng hóa dữ liệu................................................................................... 6
I.4. Lập trình hướng đối tượng ................................................................................. 6
II. MỘT SỐ KHÁI NIỆM MỚI TRONG LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG........... 8
II.1. Sự đóng gói (Encapsulation) .............................................................................. 8
II.2. Tính kế thừa (Inheritance).................................................................................. 9
II.3. Tính đa hình (Polymorphism) .......................................................................... 10
III. CÁC NGÔN NGỮ VÀ VÀI ỨNG DỤNG CỦA OOP............................................ 11
CHƯƠNG 2: CÁC MỞ RỘNG CỦA C++...................................................................... 12
I. LỊCH SỬ CỦA C++ ................................................................................................. 12
II. CÁC MỞ RỘNG CỦA C++..................................................................................... 12
II.1. Các từ khóa mới của C++................................................................................. 12
II.2. Cách ghi chú thích............................................................................................ 12
II.3. Dòng nhập/xuất chuẩn...................................................................................... 13
II.4. Cách chuyển đổi kiểu dữ liệu ........................................................................... 14
II.5. Vị trí khai báo biến........................................................................................... 14
II.6. Các biến const................................................................................................... 15
II.7. Về struct, union và enum.................................................................................. 16
II.8. Toán tử định phạm vi ....................................................................................... 16
II.9. Toán tử new và delete....................................................................................... 17
II.10. Hàm inline ........................................................................................................ 23
II.11. Các giá trị tham số mặc định............................................................................ 24
II.12. Phép tham chiếu ............................................................................................... 25
II.13. Phép đa năng hóa (Overloading)...................................................................... 29
CHƯƠNG 3: LỚP VÀ ĐỐI TƯỢNG .............................................................................. 39
I. DẪN NHẬP.............................................................................................................. 39
II. CÀI ĐẶT MỘT KIỂU DO NGƯỜI DÙNG ĐỊNH NGHĨA VỚI MỘT STRUCT. 39
III. CÀI ĐẶT MỘT KIỂU DỮ LIỆU TRỪU TƯỢNG VỚI MỘT LỚP...................... 41
IV. PHẠM VI LỚP VÀ TRUY CẬP CÁC THÀNH VIÊN LỚP .................................. 45
V. ĐIỀU KHIỂN TRUY CẬP TỚI CÁC THÀNH VIÊN............................................ 47
VI. CÁC HÀM TRUY CẬP VÀ CÁC HÀM TIỆN ÍCH............................................... 48
VII. KHỞI ĐỘNG CÁC ĐỐI TƯỢNG CỦA LỚP : CONSTRUCTOR......................... 49
VIII.SỬ DỤNG DESTRUCTOR..................................................................................... 51
IX. KHI NÀO CÁC CONSTRUTOR VÀ DESTRUCTOR ĐƯỢC GỌI ?.................. 53
X. SỬ DỤNG CÁC THÀNH VIÊN DỮ LIỆU VÀ CÁC HÀM THÀNH VIÊN ........ 54
XI. TRẢ VỀ MỘT THAM CHIẾU TỚI MỘT THÀNH VIÊN DỮ LIỆU PRIVATE.. 57
XII. PHÉP GÁN BỞI TOÁN TỬ SAO CHÉP THÀNH VIÊN MẶC ĐỊNH ................. 59
XIII.CÁC ĐỐI TƯỢNG HẰNG VÀ CÁC HÀMTHÀNH VIÊN CONST..................... 60
XIV.LỚP NHƯ LÀ CÁC THÀNH VIÊN CỦA CÁC LỚP KHÁC ............................... 64
XV. CÁC HÀM VÀ CÁC LỚP FRIEND........................................................................ 67
Giáo trình môn Lập trình hướng đối tượng Trang
Biên soạn: Lê Thị Mỹ Hạnh
3
XVI.CON TRỎ THIS ...................................................................................................... 68
XVII.CÁC ĐỐI TƯỢNG ĐƯỢC CẤP PHÁT ĐỘNG ................................................... 71
XVIII.CÁC THÀNH VIÊN TĨNH CỦA LỚP................................................................. 72
CHƯƠNG 4: ĐA NĂNG HÓA TOÁN TỬ...................................................................... 76
I. DẪN NHẬP.............................................................................................................. 76
II. CÁC NGUYÊN TẮC CƠ BẢN CỦA ĐA NĂNG HÓA TOÁN TỬ...................... 76
III. CÁC GIỚI HẠN CỦA ĐA NĂNG HÓA TOÁN TỬ.............................................. 76
IV. CÁC HÀM TOÁN TỬ CÓ THỂ LÀ CÁC THÀNH VIÊN CỦA LỚP HOẶC
KHÔNG LÀ CÁC THÀNH VIÊN........................................................................... 77
V. ĐA NĂNG HOÁ CÁC TOÁN TỬ HAI NGÔI ....................................................... 80
VI. ĐA NĂNG HÓA CÁC TOÁN TỬ MỘT NGÔI ..................................................... 87
VII. ĐA NĂNG HÓA MỘT SỐ TOÁN TỬ ĐẶC BIỆT ................................................ 90
VII.1.Toán tử [] ............................................................................................................ 91
VII.2.Toán tử () ............................................................................................................ 92
VIII.TOÁN TỬ CHUYỂN ĐỔI KIỂU............................................................................ 94
IX. TOÁN TỬ NEW VÀ DELETE................................................................................ 95
IX.1.Đa năng hóa toán tử new và delete toàn cục........................................................ 96
IX.2.Đa năng hóa toán tử new và delete cho một lớp .................................................. 97
X. ĐA NĂNG HÓA CÁC TOÁN TỬ CHÈN DÒNG << VÀ TRÍCH DÒNG >> ...... 98
XI. MỘT SỐ VÍ DỤ....................................................................................................... 99
XI.1.Lớp String............................................................................................................. 99
XI.2.Lớp Date............................................................................................................. 103
CHƯƠNG 5: TÍNH KẾ THỪA...................................................................................... 107
I. DẪN NHẬP............................................................................................................ 107
II. KẾ THỪA ĐƠN ..................................................................................................... 107
II.1.Các lớp cơ sở và các lớp dẫn xuất ....................................................................... 107
II.2.Các thành viên protected...................................................................................... 109
II.3.Ép kiểu các con trỏ lớp cơ sở tới các con trỏ lớp dẫn xuất.................................. 109
II.4.Định nghĩa lại các thành viên lớp cơ sở trong một lớp dẫn xuất:........................ 113
II.5.Các lớp cơ sở public, protected và private........................................................... 113
II.6.Các contructor và destructor lớp dẫn xuất........................................................... 113
II.7.Chuyển đổi ngầm định đối tượng lớp dẫn xuất sang đối tượng lớp cơ sở........... 116
III. ĐA KẾ THỪA (MULTIPLE INHERITANCE)..................................................... 116
IV. CÁC LỚP CƠ SỞ ẢO (VIRTUAL BASE CLASSES) ......................................... 119
CHƯƠNG 6: TÍNH ĐA HÌNH ....................................................................................... 122
I. DẪN NHẬP............................................................................................................ 122
II. PHƯƠNG THỨC ẢO (VIRTUAL FUNCTION).................................................. 122
III. LỚP TRỪU TƯỢNG (ABSTRACT CLASS) ....................................................... 125
IV. CÁC THÀNH VIÊN ẢO CỦA MỘT LỚP............................................................ 127
IV.1.Toán tử ảo........................................................................................................... 127
IV.2.Có constructor và destructor ảo hay không?...................................................... 129
CHƯƠNG 7: THIẾT KẾ CHƯƠNG TRÌNH THEO HƯỚNG ĐỐI TƯỢNG ......... 132
I. DẪN NHẬP............................................................................................................ 132
II. CÁC GIAI ĐOẠN PHÁT TRIỂN HỆ THỐNG..................................................... 132
III. CÁCH TÌM LỚP .................................................................................................... 133
IV. CÁC BƯỚC CẦN THIẾT ĐỂ THIẾT KẾ CHƯƠNG TRÌNH............................. 133
V. CÁC VÍ DỤ............................................................................................................ 134
Giáo trình môn Lập trình hướng đối tượng Trang
Biên soạn: Lê Thị Mỹ Hạnh
4
CHƯƠNG 8: CÁC DẠNG NHẬP/XUẤT...................................................................... 143
I. DẪN NHẬP............................................................................................................ 143
II. CÁC DÒNG(STREAMS) ...................................................................................... 143
II.1.Các file header của thư viện iostream.................................................................. 143
II.2.Các lớp và các đối tượng của dòng nhập/xuất..................................................... 144
III. DÒNG XUẤT......................................................................................................... 145
III.1.Toán tử chèn dòng.............................................................................................. 145
III.2.Nối các toán tử chèn dòng và trích dòng............................................................ 146
III.3.Xuất ký tự với hàm thành viên put(); Nối với nhau hàm put() .......................... 147
IV. DÒNG NHẬP......................................................................................................... 148
IV.1.Toán tử trích dòng:............................................................................................. 148
IV.2.Các hàm thành viên get() và getline()................................................................ 149
IV.3.Các hàm thành viên khác của istream................................................................ 151
IV.4.Nhập/xuất kiểu an toàn....................................................................................... 151
V. NHẬP/XUẤT KHÔNG ĐỊNH DẠNG VỚI READ(),GCOUNT() VÀ WRITE() 151
VI. DÒNG NHẬP/ XUẤT FILE .................................................................................. 152
VI.1.Nhập/xuất file văn bản ....................................................................................... 154
CHƯƠNG 9: HÀM VÀ LỚP TEMPLATE................................................................... 159
I. CÁC HÀM TEMPLATE........................................................................................ 159
II. CÁC LớP TEMPLATE........................................................................................... 161
Giáo trình môn Lập trình hướng đối tượng Trang
Biên soạn: Lê Thị Mỹ Hạnh
5
CHƯƠNG 1
GIỚI THIỆU VỀ LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG
I. LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG (OOP) LÀ GÌ ?
Lập trình hướng đối tượng (Object-Oriented Programming, viết tắt là OOP) là một phương pháp mới
trên bước đường tiến hóa của việc lập trình máy tính, nhằm làm cho chương trình trở nên linh hoạt, tin cậy
và dễ phát triển. Tuy nhiên để hiểu được OOP là gì, chúng ta hãy bắt đầu từ lịch sử của quá trình lập trình –
xem xét OOP đã tiến hóa như thế nào.
I.1. Lập trình tuyến tính
Máy tính đầu tiên được lập trình bằng mã nhị phân, sử dụng các công tắt cơ khí để nạp chương trình.
Cùng với sự xuất hiện của các thiết bị lưu trữ lớn và bộ nhớ máy tính có dung lượng lớn nên các ngôn ngữ
lập trình cấp cao đầu tiên được đưa vào sử dụng . Thay vì phải suy nghĩ trên một dãy các bit và byte, lập
trình viên có thể viết một loạt lệnh gần với tiếng Anh và sau đó chương trình dịch thành ngôn ngữ máy.
Các ngôn ngữ lập trình cấp cao đầu tiên được thiết kế để lập các chương trình làm các công việc tương
đối đơn giản như tính toán. Các chương trình ban đầu chủ yếu liên quan đến tính toán và không đòi hỏi gì
nhiều ở ngôn ngữ lập trình. Hơn nữa phần lớn các chương trình này tương đối ngắn, thường ít hơn 100 dòng.
Khi khả năng của máy tính tăng lên thì khả năng để triển khai các chương trình phức tạp hơn cũng tăng
lên. Các ngôn ngữ lập trình ngày trước không còn thích hợp đối với việc lập trình đòi hỏi cao hơn. Các
phương tiện cần thiết để sử dụng lại các phần mã chương trình đã viết hầu như không có trong ngôn ngữ lập
trình tuyến tính. Thật ra, một đoạn lệnh thường phải được chép lặp lại mỗi khi chúng ta dùng trong nhiều
chương trình do đó chương trình dài dòng, logic của chương trình khó hiểu. Chương trình được điều khiển
để nhảy đến nhiều chỗ mà thường không có sự giải thích rõ ràng, làm thế nào để chương trình đến chỗ cần
thiết hoặc tại sao như vậy.
Ngôn ngữ lập trình tuyến tính không có khả năng kiểm soát phạm vi nhìn thấy của các dữ liệu. Mọi dữ
liệu trong chương trình đều là dữ liệu toàn cục nghĩa là chúng có thể bị sửa đổi ở bất kỳ phần nào của
chương trình. Việc dò tìm các thay đổi không mong muốn đó của các phần tử dữ liệu trong một dãy mã lệnh
dài và vòng vèo đã từng làm cho các lập trình viên rất mất thời gian.
I.2. Lập trình cấu trúc
Rõ ràng là các ngôn ngữ mới với các tính năng mới cần phải được phát triển để có thể tạo ra các ứng
dụng tinh vi hơn. Vào cuối các năm trong 1960 và 1970, ngôn ngữ lập trình có cấu trúc ra đời. Các chương
trình có cấu trúc được tổ chức theo các công việc mà chúng thực hiện.
Về bản chất, chương trình chia nhỏ thành các chương trình con riêng rẽ (còn gọi là hàm hay thủ tục)
thực hiện các công việc rời rạc trong quá trình lớn hơn, phức tạp hơn. Các hàm này được giữ càng độc lập
với nhau càng nhiều càng tốt, mỗi hàm có dữ liệu và logic riêng.Thông tin được chuyển giao giữa các hàm
thông qua các tham số, các hàm có thể có các biến cục bộ mà không một ai nằm bên ngoài phạm vi của hàm
lại có thể truy xuất được chúng. Như vậy, các hàm có thể được xem là các chương trình con được đặt chung
với nhau để xây dựng nên một ứng dụng.
Mục tiêu là làm sao cho việc triển khai các phần mềm dễ dàng hơn đối với các lập trình viên mà vẫn cải
thiện được tính tin cậy và dễ bảo quản chương trình. Một chương trình có cấu trúc được hình thành bằng
cách bẻ gãy các chức năng cơ bản của chương trình thành các mảnh nhỏ mà sau đó trở thành các hàm. Bằng
cách cô lập các công việc vào trong các hàm, chương trình có cấu trúc có thể làm giảm khả năng của một
hàm này ảnh hưởng đến một hàm khác. Việc này cũng làm cho việc tách các vấn đề trở nên dễ dàng hơn. Sự
gói gọn này cho phép chúng ta có thể viết các chương trình sáng sủa hơn và giữ được điều khiển trên từng
hàm. Các biến toàn cục không còn nữa và được thay thế bằng các tham số và biến cục bộ có phạm vi nhỏ
hơn và dễ kiểm soát hơn. Cách tổ chức tốt hơn này nói lên rằng chúng ta có khả năng quản lý logic của cấu
trúc chương trình, làm cho việc triển khai và bảo dưỡng chương trình nhanh hơn và hữu hiện hơn và hiệu quả
hơn.
Giáo trình môn Lập trình hướng đối tượng Trang
Biên soạn: Lê Thị Mỹ Hạnh
6
Một khái niệm lớn đã được đưa ra trong lập trình có cấu trúc là sự trừu tượng hóa (Abstraction). Sự
trừu tượng hóa có thể xem như khả năng quan sát một sự việc mà không cần xem xét đến các chi tiết bên
trong của nó. Trong một chương trình có cấu trúc, chúng ta chỉ cần biết một hàm đã cho có thể làm được một
công việc cụ thể gì là đủ. Còn làm thế nào mà công việc đó lại thực hiện được là không quan trọng, chừng
nào hàm còn tin cậy được thì còn có thể dùng nó mà không cần phải biết nó thực hiện đúng đắn chức năng
của mình như thế nào. Điều này gọi là sự trừu tượng hóa theo chức năng (Functional abstraction) và là
nền tảng của lập trình có cấu trúc.
Ngày nay, các kỹ thuật thiết kế và lập trình có cấu trúc được sử rộng rãi. Gần như mọi ngôn ngữ lập
trình đều có các phương tiện cần thiết để cho phép lập trình có cấu trúc. Chương trình có cấu trúc dễ viết, dễ
bảo dưỡng hơn các chương trình không cấu trúc.
Sự nâng cấp như vậy cho các kiểu dữ liệu trong các ứng dụng mà các lập trình viên đang viết cũng đang
tiếp tục diễn ra. Khi độ phức tạp của một chương trình tăng lên, sự phụ thuộc của nó vào các kiểu dữ liệu cơ
bản mà nó xử lý cũng tăng theo. Vấn đề trở rõ ràng là cấu trúc dữ liệu trong chương trình quan trọng chẳng
kém gì các phép toán thực hiện trên chúng. Điều này càng trở rõ ràng hơn khi kích thước của chương trình
càng tăng. Các kiểu dữ liệu được xử lý trong nhiều hàm khác nhau bên trong một chương trình có cấu trúc.
Khi có sự thay đổi trong các dữ liệu này thì cũng cần phải thực hiện cả các thay đổi ở mọi nơi có các thao tác
tác động trên chúng. Đây có thể là một công việc tốn thời gian và kém hiệu quả đối với các chương trình có
hàng ngàn dòng lệnh và hàng trăm hàm trở lên.
Một yếu điểm nữa của việc lập trình có cấu trúc là khi có nhiều lập trình viên làm việc theo nhóm cùng
một ứng dụng nào đó. Trong một chương trình có cấu trúc, các lập trình viên được phân công viết một tập
hợp các hàm và các kiểu dữ liệu. Vì có nhiều lập trình viên khác nhau quản lý các hàm riêng, có liên quan
đến các kiểu dữ liệu dùng chung nên các thay đổi mà lập trình viên tạo ra trên một phần tử dữ liệu sẽ làm ảnh
hưởng đến công việc của tất cả các người còn lại trong nhóm. Mặc dù trong bối cảnh làm việc theo nhóm,
việc viết các chương trình có cấu trúc thì dễ dàng hơn nhưng sai sót trong việc trao đổi thông tin giữa các
thành viên trong nhóm có thể dẫn tới hậu quả là mất rất nhiều thời gian để sửa chữa chương trình.
I.3. Sự trừu tượng hóa dữ liệu
Sự trừu tượng hóa dữ liệu (Data abstraction) tác động trên các dữ liệu cũng tương tự như sự trừu
tượng hóa theo chức năng. Khi có trừu tượng hóa dữ liệu, các cấu trúc dữ liệu và các phần tử có thể được sử
dụng mà không cần bận tâm đến các chi tiết cụ thể. Chẳng hạn như các số dấu chấm động đã được trừu
tượng hóa trong tất cả các ngôn ngữ lập trình, Chúng ta không cần quan tâm cách biểu diễn nhị phân chính
xác nào cho số dấu chấm động khi gán một giá trị, cũng không cần biết tính bất thường của phép nhân nhị
phân khi nhân các giá trị dấu chấm động. Điều quan trọng là các số dấu chấm động hoạt động đúng đắn và
hiểu được.
Sự trừu tượng hóa dữ liệu giúp chúng ta không phải bận tâm về các chi tiết không cần thiết. Nếu lập
trình viên phải hiểu biết về tất cả các khía cạnh của vấn đề, ở mọi lúc và về tất cả các hàm của chương trình
thì chỉ ít hàm mới được viết ra, may mắn thay trừu tượng hóa theo dữ liệu đã tồn tại sẵn trong mọi ngôn ngữ
lập trình đối với các dữ liệu phức tạp như số dấu chấm động. Tuy nhiên chỉ mới gần đây, người ta mới phát
triển các ngôn ngữ cho phép chúng ta định nghĩa các kiểu dữ liệu trừu tượng riêng.
I.4. Lập trình hướng đối tượng
Khái niệm hướng đối tượng được xây dựng trên nền tảng của khái niệm lập trình có cấu trúc và sự trừu
tượng hóa dữ liệu. Sự thay đổi căn bản ở chỗ, một chương trình hướng đối tượng được thiết kế xoay quanh
dữ liệu mà chúng ta có thể làm việc trên đó, hơn là theo bản thân chức năng của chương trình. Điều này hoàn
toàn tự nhiên một khi chúng ta hiểu rằng mục tiêu của chương trình là xử lý dữ liệu. Suy cho cùng, công việc
mà máy tính thực hiện vẫn thường được gọi là xử lý dữ liệu. Dữ liệu và thao tác liên kết với nhau ở một mức
cơ bản (còn có thể gọi là mức thấp), mỗi thứ đều đòi hỏi ở thứ kia có mục tiêu cụ thể, các chương trình
hướng đối tượng làm tường minh mối quan hệ này.
Lập trình hướng đối tượng (Object Oriented Programming - gọi tắt là OOP) hay chi tiết hơn là Lập trình
định hướng đối tượng, chính là phương pháp lập trình lấy đối tượng làm nền tảng để xây dựng thuật giải, xây
có thể bạn quan tâm
Nghiên cứu vận dụng quan điểm dạy học tích cực của Robert Marzano vào...
159
975
316
Kinh tế quản lý
159
(New)
Cách xử lý lỗi không thể cài đặt và nâng cấp chương trình
14
1.820
324
Cơ sở dữ liệu
14
(New)
Giáo trình nguyên lý kế toán của ĐH BK Đà nẵng
141
892
256
Bài giảng, giáo trình
141
(New)
Luận văn: Thực trạng đầu tư nâng cao năng lực cạnh tranh và một số biệ...
82
759
307
Kinh tế quản lý
82
(New)
Một số phương pháp hay để thực hành kĩ năng lập trình của bạn
7
783
247
Lập trình
7
(New)
5 mẹo này sẽ giúp bạn cải thiện được khả năng lập trình logic
4
701
302
Lập trình
4
(New)
Khả năng tương thích trình duyệt trong JavaScript
3
686
299
Lập trình
3
(New)
12 cuốn sách dành giúp nâng cao trình độ tiếng anh hiệu quả
3
1.400
439
Tiếng Anh phổ thông
3
(New)
thông tin tài liệu
Tất tần tật về lập trình C+++
Mở rộng để xem thêm
tài liệu mới trong mục này
tài liệu hot trong mục này
tài liệu giúp tôi
Nếu bạn không tìm thấy tài liệu mình cần có thể gửi yêu cầu ở đây để chúng tôi tìm giúp bạn!
xem nhiều trong tuần
Giáo trình Quản trị học của Đại học kinh tế quốc dân
4 đề thi học sinh giỏi Toán lớp 2, có đáp án kèm theo
BIỂU MẪU ĐỀ NGHỊ NHẬP KHẨU THUỐC CHƯA CÓ GIẤY ĐĂNG KÝ LƯU HÀNH THUỐC TẠI VIỆT NAM KHÔNG VÌ MỤC ĐÍCH THƯƠNG MẠI
Hướng dẫn tự học Access
Sinh học 11 mạch gỗ và mạch rây của cây
Trắc nghiệm Hóa học 10 bài 2: Hạt nhân nguyên tử. Nguyên tố hóa học. Đồng vị
yêu cầu tài liệu
Giúp bạn tìm tài liệu chưa có
×
