Giáo trình Lập trình hướng đối tượng (Nghề: Lập trình viên máy tính - Cao đẳng) - Trường CĐ Nghề Kỹ thuật Công nghệ
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 (928.39 KB, 94 trang )
BỘ LAO ĐỘNG - THƯƠNG BINH VÀ XÃ HỘI
TRƯỜNG CAO ĐẲNG NGHỀ KỸ THUẬT CƠNG NGHỆ
-----š›&š›-----
GIÁO TRÌNH
MƠ ĐUN :LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG
NGHỀ: LẬP TRÌNH VIÊN MÁY TÍNH
TRÌNH ĐỘ: CAO ĐẲNG
Ban hành kèm theo Quyết định số: 13A/QĐ-CĐNKTCN ngày 10 tháng 01 năm 2019
của Hiệu trưởng Trường Cao đẳng nghề Kỹ thuật Công nghệ
Hà Nội, năm 2021
(Lưu hành nội bộ)
1
TUYÊN BỐ BẢN QUYỀN:
Tài liệu này thuộc loại sách giáo trình nên các nguồn thơng tin có thể được phép dùng
nguyên bản hoặc trích dùng cho các mục đích về đào tạo và tham khảo.
Mọi mục đích khác mang tính lệch lạc hoặc sử dụng với mục đích kinh doanh
thiếu lành mạnh sẽ bị nghiêm cấm.
MÃ TÀI LIỆU : MĐLTV 21
2
LỜI GIỚI THIỆU
C++ là ngơn ngữ lập trình hướng đối tượng được mở rộng từ ngôn ngữ C. Do vậy,
C++ có ưuđiểm là kế thừa được các điểm mạnh truyền thống của ngơn ngữ C như uyển
chuyển, tương thíchvới các thiết bị phần cứng. Hiện nay, C++ là một ngôn ngữ lập
trình phổ biến, được giảng dạy tạicác trường đại học trong nước và trên thế giới và đặc
biệt được sử dụng rộng rãi cho nhu cầu pháttriển của công nghiệp phần mềm hiện nay.
Tài liệu này không những nhằm giới thiệu cho sinh viên ngơn ngữ lập trình C++, mà
cịn mong muốn qua đó sinh viên có thể hiểu được tư tưởng củaphương pháp lập trình
hướng đối tượng nói chung. Nội dung của tài liệu bao gồm hai phần chính:
• Phần thứ nhất là lập trình nâng cao với C++, bao gồm lập trình C++ với con trỏ
và mảng, các kiểu dữ liệu có cấu trúc cùng các thao tác vào ra trên tệp.
• Phần thứ hai là lập trình hướng đối tượng với C++, bao gồm các định nghĩa và
các thao tác trên lớp đối tượng, tính kế thừa và tương ứng bội trong C++, cách sử dụng
một số lớp cơ bản trong thư viện C++.
Mặc dù có rất nhiều cố gắng, nhưng không tránh khỏi những sai sót, rất mong nhận
được sự đóng góp ý kiến của độc giả để giáo trình được hồn thiện hơn.
Xin chân thành cảm ơn!
Hà Nội, ngày 23 tháng 04 năm 2021
Tham gia biên soạn
1. Chủ biên Trần Thị Vinh
2. Tập thể Giảng viên Khoa CNTT
Mọi thơng tin đóng góp chia sẻ xin gửi về hòm thư hoặc
liên hệ số điện thoại 0978113529
3
MỤC LỤC
LỜI GIỚI THIỆU .......................................................................................................... 3
MỤC LỤC ..................................................................................................................... 4
BÀI 1: TỔNG QUAN VỀ LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG ................................ 11
1. Lịch sử phát triển .................................................................................................. 11
2. Khái niệm về lập trình hướng đối tượng và các đặc trưng ..................................... 11
3. Một số khái niệm cơ bản ....................................................................................... 11
3.1. Lớp, đối tượng ................................................................................................ 11
3.2. Trừu tượng hóa .............................................................................................. 12
3.3. Thơng điệp, đóng gói, che dấu thơng tin. ........................................................ 12
3.4. Kế thừa ........................................................................................................... 13
3.5. Đa hình .......................................................................................................... 13
4. Phân tích bài tốn theo tiếp cận hướng đối tượng .................................................. 13
5. Ngôn ngữ lập trình hướng đối tượng ..................................................................... 16
BÀI 2: LỚP VÀ ĐỐI TƯỢNG .................................................................................... 19
1. Định danh ............................................................................................................. 19
1.1 Quy định với định danh ................................................................................... 19
1.2.Quy ước với định danh .................................................................................... 20
2.1. Kiểu dữ liệu nguyên thủy ................................................................................ 21
2.2.Giá trị hằng ..................................................................................................... 23
2.3.Chuyển đổi kiểu dữ liệu ................................................................................... 23
2.4.Khai báo và khởi tạo biến, hằng ...................................................................... 24
3. Toán tử ................................................................................................................. 25
3.1.Toán tử số học ................................................................................................. 25
Toán tử số học trong C++ .............................................................................................. 25
3.2. Toán tử bit ...................................................................................................... 25
3.3.Toán tử quan hệ............................................................................................... 26
3.4. Toán tử logic .................................................................................................. 27
3.5. Toán tử gán .................................................................................................... 27
4. Nhập và hiển thị dữ liệu lên màn hình................................................................... 29
4.1 Hiển thị dữ liệu lên màn hình .......................................................................... 29
4
4.2 Nhập dữ liệu từ bàn phím ................................................................................ 29
5. Cấu trúc điều khiển ............................................................................................... 30
5.1. Lệnh if-else ..................................................................................................... 30
5.2. Lệnh switch-case ............................................................................................ 30
5.3. Vòng lặp while và do … while ........................................................................ 33
5.4.Vòng lặp for .................................................................................................... 34
5.5.Các lệnh làm thay đổi cấu trúc lập trình.......................................................... 34
5.6.Phạm vi biến.................................................................................................... 34
6.Mảng một chiều ..................................................................................................... 35
6.1.Khai báo và khởi tạo mảng .............................................................................. 35
6.2.Một số thao tác với mảng một chiều ................................................................ 35
7.Lập trình với cấu trúc lặp và các thao tác với mảng trong Java .............................. 36
BÀI 3: ĐÓNG GÓI VÀ XÂY DỰNG LỚP, TẠO VÀ SỬ DỤNG .............................. 38
1.Trừu tượng hóa dữ liệu .......................................................................................... 38
1.1.Trừu tượng hóa dữ liệu là gì? .......................................................................... 38
1.2.Trừu tượng hóa dữ liệu là gì? .......................................................................... 38
1.3.So sánh đối tượng và lớp ................................................................................. 39
2. Đóng gói và xây dựng lớp..................................................................................... 40
2.1. Đóng gói là gì?............................................................................................... 40
2.2. Xây dựng lớp .................................................................................................. 40
2.3. Che giấu dữ liệu ............................................................................................. 41
2.4. Phương thức set/get ........................................................................................ 41
3. Tạo và sử dụng đối tượng ..................................................................................... 41
3.1. Khởi tạo dữ liệu.............................................................................................. 41
3.2.Phương thức khởi tạo ...................................................................................... 41
3.3.Khai báo và khởi tạo đối tượng ....................................................................... 41
3.4.Sử dụng đối tượng ........................................................................................... 41
4. Từ khóa this.......................................................................................................... 43
5. Truyền tham số cho phương thức .......................................................................... 44
5.1. Truyền tham số kiểu dữ liệu tham trị .............................................................. 44
5.2. Truyền tham số kiểu dữ liệu tham chiếu.......................................................... 44
6. Chồng phương thức .............................................................................................. 45
7. Xây dựng lớp đơn giản, tạo và sử dụng các đối tượng........................................... 46
5
8. Lớp String, StringBuilder, StringBuffer. ............................................................... 55
BÀI 4: TỔNG QUAN VỀ JDBC ................................................................................. 59
1. Tổng quan về JDBC ............................................................................................. 59
2. Cài đặt JDBC........................................................................................................ 59
3. Kết nối cơ sở dữ liệu............................................................................................. 60
4. Tạo ứng dụng JDBC ............................................................................................. 61
BÀI 5: KẾ THỪA........................................................................................................ 64
1. Một số khái niệm cơ bản ....................................................................................... 64
1.1 Tổng qt hóa và đặc biệt hóa......................................................................... 64
1.2. Tính kế thừa ................................................................................................... 64
1.3. Lớp cơ sở, lớp dẫn xuất .................................................................................. 64
1.4. Các dạng kế thừa............................................................................................ 66
1.4.1. Đơn kế thừa ................................................................................................. 66
1.4.2. Đa kế thừa ................................................................................................... 66
2. Các hình thức kế thừa ........................................................................................... 68
2.1. Hình thức kế thừa private ............................................................................... 68
Kiểu kế thừa trong C++ ................................................................................................. 68
2.2. Hình thức kế thừa Protected ........................................................................... 68
2.3. Hình thức kế thừa Public ................................................................................ 68
3. Sự trùng tên trong kế thừa..................................................................................... 68
4. Lớp cơ sở ảo và lớp cơ sở trừu tượng ................................................................ 70
BÀI 6: ĐA HÌNH VÀ GIAO DIỆN ............................................................................. 73
1. Nạp chồng hàm, nạp chồng tốn tử ....................................................................... 73
2. Đa hình ................................................................................................................. 74
2.1. Khái niệm ....................................................................................................... 74
2.2. Vai trò ............................................................................................................ 74
2.3. Xây dựng ứng dụng sử dụng tính chất đa hình ................................................ 74
3. Giao diện (Interface) ............................................................................................. 75
3.1. Khái niệm ....................................................................................................... 75
3.2. Cách khai báo và xây dựng giao diện trong C# ............................................... 75
BÀI 7: LẬP TRÌNH ANDROID CƠ BẢN .................................................................. 80
1.Cài đặt Android Studio .......................................................................................... 80
2.Viết ứng dụng cơ bản: Nhập/Hiển thị, khai báo biến,... .......................................... 87
6
3.Lập trình hướng đối tượng trong Android .............................................................. 88
4.Tạo và sử dụng lớp trong Android ......................................................................... 89
5.Bắt sự kiện Onclick ............................................................................................... 90
6.Tùy chỉnh Layout .................................................................................................. 90
7.Tạo hàm con .......................................................................................................... 90
8.Chèn hình ảnh ImageView, gán hình nền cho đối tượng ........................................ 90
9.Sử dụng đối tượng CountDownTimer .................................................................... 91
10.Sử dụng ASYNC ................................................................................................. 91
11.Đọc file từ internet............................................................................................... 92
12.Đọc XML & RSS ................................................................................................ 92
13.Tạo diễn hoạt hình với Animation .................................................................... 92
7
GIÁO TRÌNH MƠ ĐUN
Tên mơ đun: Lập trình hướng đối tượng
Mã mơ đun: MĐLTV 21
Vị trí, tính chất, ý nghĩa và vai trị của mơ đun :
- Vị trí: Là mơ đun chun ngành. Mơ đun có thể được bố trí học khi đã học xong
các mơn học cơ sở ngành như: Cơ sở dữ liệu, Ngơn ngữ lập trình C/C++, Cấu
trúc dữ liệu và giải thuật.
- Tính chất: Là mô đun cung cấp các khái niệm, đặc trưng cơ bản của lập trình hướng
đối tượng như: đối tượng, lớp đối tượng, phương thức, thuộc tính, nạp chồng, kế
thừa, đóng gói, trừu tượng, đa hình,…Ngồi ra, học phần cịn cung cấp cách thức
giải quyết bài toán theo tư duy hướng đối tượng.
Mục tiêu của mơ đun:
- Về kiến thức
+ Trình bày được các khái niệm và các thành phần cơ bản của lập trình hướng đối
tượng.
+ Phân tích được bài toán theo tư duy hướng đối tượng
+ Xác định được các đối tượng và lớp đối tượng trong các bài toán cụ thể
- Về kỹ năng
+ Thiết kế và xây dựng được lớp đối tượng bằng ngơn ngữ lập trình cụ thể
+ Lập trình giải quyết được bài tốn thực tế ở mức đơn giản bằng ngơn ngữ lập
trình hướng đối tượng. Tích cực ứng dụng lập trình trực quan cho các ứng dụng
trong thực tế.
- Về năng lực tự chủ và trách nhiệm:
+ Khả năng tìm tài liệu, đọc hiểu tài liệu
+ Khả năng làm việc nhóm
Nội dung của mô đun:
Thời gian
Số
Tên các bài trong mô đun
Tổng
Lý
Thực
Kiểm
TT
số
thuyết
hành
tra*
1 Bài 1: Tổng quan về lập trình hướng đối
tượng
1. Lịch sử phát triển
2. Khái niệm về lập trình hướng đối tượng
15
5
10
và các đặc trưng
3. Một số khái niệm cơ bản
4. Phân tích bài tốn theo tiếp cận hướng
đối tượng
5. Ngơn ngữ lập trình hướng đối tượng
25
7
17
1
2 Bài 2: Lớp- Đối tượng
8
3
4
5
6
7
1. Định nghĩa Lớp đối tượng
2. Phạm vi Private, Public, Protected
3. Mảng đối tượng
4. Phương thức khởi tạo và phương thức
hủy bỏ
5. Con trỏ this
Bài 3: Đóng gói và xây dựng lớp; tạo và
sử dụng đối tượng
1. Trừu tượng hóa dữ liệu
2. Đóng gói và xây dựng lớp
3. Tạo và sử dụng đối tượng
4. Từ khóa this
5. Truyền tham số cho phương thức
6. Chồng phương thức
7. Xây dựng lớp đơn giản, tạo và sử dụng
các đối tượng
8. Lớp String, StringBuilder, StringBuffer.
Bài 4: Tổng quan về JDBC
1. Tổng quan về JDBC
2. Cài đặt JDBC
3. Kết nối Cơ sở dữ liệu
4. Tạo ứng dụng JDBC cơ bản
Bài5: Kế thừa
1. Một số khái niệm cơ bản
2. Các hình thức kế thừa
3. Sự trùng tên trong kế thừa
4. Lớp cơ sở ảo và lớp cơ sở trừu tượng
Bài 6: Đa hình và Giao diện
1. Nạp chồng hàm, nạp chồng tốn tử
2. Đa hình
3. Giao diện (Interface)
Bài 7: Lập trình Android cơ bản
1.Cài đặt Android Studio
2.Viết ứng dụng cơ bản: Nhập/Hiển thị,
khai báo biến,...
3.Lập trình hướng đối tượng trong Android
4.Tạo và sử dụng lớp trong Android
5.Bắt sự kiện Onclick
6.Tùy chỉnh Layout
7.Tạo hàm con
8.Chèn hình ảnh ImageView, gán hình nền
9
20
5
14
13
2
11
15
6
8
15
3
12
15
0
15
1
1
cho đối tượng
9.Sử dụng đối tượng CountDownTimer
10.Sử dụng ASYNC
11.Đọc file từ internet
12.Đọc XML & RSS
13.Tạo diễn hoạt hình với Animation
Thi kết thúc mô đun
Cộng
2
120
28
1
88
1
4
* Ghi chú: Thời gian kiểm tra lý thuyết được tính vào gìơ lý thuyết, Thời gian
kiểm tra thực hành được tính vào giờ thực hành.
2. Nội dung chi tiết:
10
BÀI 1: TỔNG QUAN VỀ LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG
Mã bài: MĐLTV 21.01
Giới thiệu:
Trong lập trình hướng cấu trúc, chương trình chính được chia nhỏ thành các chương
trình con và mỗi chương trình con thực hiện một cơng việc xác định. Chương trình
chính sẽ gọi đến chương trình con theo một giải thuật, hoặc một cấu trúc được xác định
trong chương trình chính.
Các ngơn ngữ lập trình cấu trúc phổ biến là Pascal, C và C++. Riêng C++ ngoài việc có
đặc trưng của lập trình cấu trúc do kế thừa từ C, cịn có đặc trưng của lập trình hướng
đối tượng. Cho nên C++ cịn được gọi là ngơn ngữ lập trình nửa cấu trúc, nửa hướng đối
tượng.
Mục tiêu:
- Trình bày được khái niệm và các đặc trưng của lập trình hướng đối tượng.
- Thực hiện được các thao tác cơ bản trên mơi trường lập trình cụ thể. - So sánh được
đặc trưng của lập trình hướng đối tượng với một số phương pháp lập trình đã học.
- Nhận dạng được các khái niệm đối tượng tron lập trình hướng đối tượng
- Sử dụng được các lệnh cơ bản trong ngơn ngữ lập trình hướng đối tượng cụ thể.
Nội dung chính:
1. Lịch sử phát triển
Trong lập trình hướng đối tượng:
• Người ta coi các thực thể trong chương trình là các đối tượng và sau đó trừu tượng hố
đối tượng thành lớp đối tượng.
• Dữ liệu được tổ chức thành các thuộc tính của lớp. Nguời ta ngăn chặn việc thay đổi
tuỳ
tiện dữ liệu trong chương trình bằng các cách giới hạn truy nhập như chỉ cho phép truy
nhập dữ liệu thông qua đối tượng, thông qua các phương thức mà đối tượng được cung
cấp...
• Quan hệ giữa các đối tượng là quan hệ ngang hàng hoặc quan hệ kế thừa: Nếu lớp B
kế
thừa từ lớp A thì A được gọi là lớp cơ sở và B được gọi là lớp dẫn xuất.
2. Khái niệm về lập trình hướng đối tượng và các đặc trưng
Đặc trưng cơ bản nhất của lập trình cấu trúc thể hiện ở mối quan hệ:
chương trình = Cấu trúc dữ liệu + Giải thuật
Trong đó:
• Cấu trúc dữ liệu là cách tổ chức dữ liệu cho việc xử lý bởi một hay nhiều chương trình
nào đó.
• Giải thuật là một quy trình để thực hiện một cơng việc xác định
Trong chương trình, giải thuật có quan hệ phụ thuộc vào cấu trúc dữ liệu:
• Một cấu trúc dữ liệu chỉ phù hợp với một số hạn chế các giải thuật.
• Nếu thay đổi cấu trúc dữ liệu thì phải thay đổi giải thuật cho phù hợp.
• Một giải thuật thường phải đi kèm với một cấu trúc dữ liệu nhất định.
3. Một số khái niệm cơ bản
3.1. Lớp, đối tượng
Đối tượng (Object)
Trong lập trình hướng đối tượng, đối tượng được coi là đơn vị cơ bản nhỏ nhất. Các dữ
diệu và
11
cách xử lí chỉ là thành phần của đối tượng mà không được coi là thực thể. Một đối
tượng chứa các
dữ liệu của riêng nó, đồng thời có các phương thức (hành động) thao tác trên các dữ liệu
đó:
Đối tượng = dữ liệu + phương thức
Lớp (Class)
Khi có nhiều đối tượng giống nhau về mặt dữ liệu và phương thức, chúng được nhóm
lại với nhau
và gọi chung là lớp:
• Lớp là sự trừu tượng hố của đối tượng
• Đối tượng là một thể hiện của lớp.
3.2. Trừu tượng hóa
Trừu tượng hóa dữ liệu (Data abstraction) liên quan tới việc chỉ cung cấp thơng tin
cần thiết tới bên ngồi và ẩn chi tiết cơ sở của chúng, ví dụ: để biểu diễn thơng tin cần
thiết trong chương trình mà khơng hiển thị chi tiết về chúng.
Trừu tượng hóa dữ liệu (Data abstraction) là một kỹ thuật lập trình mà dựa trên sự phân
biệt của Interface và Implementation (trình triển khai).
Xem xét ví dụ về một chiếc TV, bạn có thể bật/tắt, thay đổi kênh, chỉnh âm lượng, và
thêm các thiết bị ngoại vi như loa, VCR và DVD. Nhưng bạn không biết các chi tiết nội
vi của nó, đó là, bạn khơng biết cách nó nhận tín hiệu qua khơng khí hoặc qua dây cáp,
cách phiên dịch chúng và cuối cùng là hiển thị chúng trên màn hình.
Vì thế, có thể nói rằng một chiếc TV phân biệt rõ ràng trình triển khai nội vi của nó với
giao diện ngoại vi và bạn có thể thao tác với interface với các nút nguồn, điều khiển âm
lượng mà khơng cần có bất kỳ hiểu biết về những gì diễn ra bên trong nó.
Bây giờ, về mặt ngơn ngữ lập trình C++, thì các lớp C++ cung cấp Trừu tượng hóa dữ
liệu (Data abstraction) ở mức thật tuyệt vời. Chúng cung cấp đủ các phương thức public
tới bên ngoài để thao tác với tính năng của đối tượng và để thao tác dữ liệu đối tượng, ví
dụ: trạng thái mà khơng cần thực sự biết về cách lớp đó đã được triển khai nội tại.
Ví dụ, chương trình của bạn có thể tạo một lời gọi tới hàm sort() mà không cần biết về
hàm đó thực sự sử dụng thuật tốn gì để sắp xếp các giá trị đã cho. Thực ra, trình triển
khai cơ sở (underlying implementation) của tính năng sắp xếp có thể thay đổi tùy vào
thư viện, và miễn là Interface vẫn như cũ thì lời gọi hàm của bạn vẫn tiếp tục làm việc.
3.3. Thơng điệp, đóng gói, che dấu thơng tin.
Đóng gói dữ liệu (Encapsulation)
• Các dữ liệu được đóng gói vào trong đối tượng. Mỗi dữ liệu có một phạm vi truy nhập
riêng.
• Khơng thể truy nhập đến dữ liệu một cách tự do như lập trình cấu trúc
• Muốn truy nhập đến các dữ liệu đã được bảo vệ, phải thông qua các đối tượng, nghĩa
là
phải sử dụng các phương thức mà đối tượng cung cấp mới có thể truy nhập đến dữ liệu
của đối tượng đó.
Tuy nhiên, vì C++ chỉ là ngơn ngữ lập trình nửa đối tượng, cho nên C++ vẫn cho phép
định nghĩa
các biến dữ liệu và các hàm tự do, đây là kết quả kế thừa từ ngôn ngữ C, một ngôn ngữ
lập trình
thuần cấu trúc.
12
3.4. Kế thừa
Kế thừa (Inheritance)
Tính kế thừa của lập trình hướng đối tượng cho phép một lớp có thể kế thừa từ một số
lớp đã tồn
tại. Khi đó, lớp mới có thể sử dụng dữ liệu và phương thức của các lớp cơ sở như là của
mình.
Ngồi ra, lớp dẫn xuất cịn có thể bổ sung thêm một số dữ liệu và phương thức. Ưu
điểm của kế
thừa là khi thay đổi dữ liệu của một lớp, chỉ cần thay đổi các phương thức trong phạm
vi lớp cơ sở
mà không cần thay đổi trong các lớp dẫn xuất.
3.5. Đa hình
Đa hình (Polymorphsim)
Đa hình là khái niệm ln đi kèm với kế thừa. Do tính kế thừa, một lớp có thể sử dụng
lại các
phương thức của lớp khác. Tuy nhiên, nếu cần thiết, lớp dẫn xuất cũng có thể định
nghĩa lại một
số phương thức của lớp cơ sở. Đó là sự nạp chồng phương thức trong kế thừa. Nhờ sự
nạp chồng
phương thức này, ta chỉ cần gọi tên phương thức bị nạp chồng từ đối tượng mà khơng
cần quan
tâm đó là đối tượng của lớp nào. Chương trình sẽ tự động kiểm tra xem đối tượng là
thuộc kiểu
lớp cơ sở hay thuộc lớp dẫn xuất, sau đó sẽ gọi phương thức tương ứng với lớp đó. Đó
là tính đa hình.
4. Phân tích bài toán theo tiếp cận hướng đối tượng
Phương pháp lập trình hướng đối tượng
Xuất phát từ hai hạn chế chính của phương pháp lập trình cấu trúc:
Khơng quản lí được sự thay đổi dữ liệu khi có nhiều chương trình cùng thay đổi một
biến chung. Vấn đề này đặc biệt nghiêm trọng khi các ứng dụng ngày càng lớn, người ta
khơng thể kiểm sốt được sự truy nhập đến các biến dữ liệu chung.
Không tiết kiệm được tài nguyên con người: Giải thuật gắn liền với cấu trúc dữ liệu, nếu
thay đổi cấu trúc dữ liệu, sẽ phải thay đổi giải thuật, và do đó, phải viết lại mã chương
trình từ đầu.
Để khắc phục được hai hạn chế này khi giải quyết các bài toán lớn, người ta xây dựng
một phương pháp tiếp cận mới, là phương pháp lập trình hướng đối tượng, với hai mục
đích chính:
• Đóng gói dữ liệu để hạn chế sự truy nhập tự do vào dữ liệu, khơng quản lí được.
• Cho phép sử dụng lại mã nguồn, hạn chế việc phải viết lại mã từ đầu cho các chương
trình.
Việc đóng gói dữ liệu được thực hiện theo phương pháp trừu tượng hoá đối tượng thành
lớp từ thấp lên cao như sau:
• Thu thập các thuộc tính của mỗi đối tượng, gắn các thuộc tính vào đối tượng tương
ứng.
13
• Nhóm các đối tượng có các thuộc tính tương tự nhau thành nhóm, loại bỏ bớt các
thuộc tính cá biệt, chỉ giữ lại các thuộc tính chung nhất. Đây được gọi là q trình trừu
tượng hố đối tượng thành lớp.
• Đóng gói dữ liệu của các đối tượng vào lớp tương ứng.Mỗi thuộc tính của đối tượng
trở thành một thuộc tính của lớp tương ứng.
• Việc truy nhập dữ liệu được thực hiện thông qua các phương thức được trang bị cho
lớp. Không được truy nhập tự do trực tiếp đến dữ liệu.
• Khi có thay đổi trong dữ liệu của đối tượng, ta chỉ cần thay đổi các phương thức truy
nhập thuộc tính của lớp, mà khơng cần phải thay đổi mã nguồn của các chương trình sử
dụng lớp tương ứng.
Việc cho phép sử dụng lại mã nguồn được thực hiện thông qua cơ chế kế thừa trong lập
trình hướng đối tượng. Theo đó:
• Các lớp có thể được kế thừa nhau để tận dụng các thuộc tính, các phương thức của
nhau.
• Trong lớp dẫn xuất (lớp được kế thừa) có thể sử dụng lại các phương thức của lớp cơ
sở (lớp bị lớp khác kế thừa) mà khơng cần thiết phải cài đặt lại mã nguồn.
• Ngay cả khi lớp dẫn xuất định nghĩa lại các phương thức cho mình, lớp cơ sở cũng
khơng bị ảnh hưởng và khơng phải sửa lại bất kì một đoạn mã nguồn nào.
Ngơn ngữ lập trình hướng đối tượng phổ biến hiện nay là Java và C++.Tuy nhiên, C++
mặc dù cũng có những đặc trưng cơ bản của lập trình hướng đối tượng nhưng vẫn
khơng phải là ngơn ngữ lập trình thuần hướng đối tượng.Java thật sự là một ngôn ngữ
lập trình thuần hướng đối tượng.
Đặc trưng
Lập trình hướng đối tượng có hai đặc trưng cơ bản:
• Đóng gói dữ liệu: dữ liệu ln được tổ chức thành các thuộc tính của lớp đối
tượng.Việc truy nhập đến dữ liệu phải thông qua các phương thức của đối tượng lớp.
• Sử dụng lại mã nguồn: việc sử dụng lại mã nguồn được thể hiện thông qua cơ chế kế
thừa. Cơ chế này cho phép các lớp đối tượng có thể kế thừa từ các lớp đối tượng
khác.Khiđó, trong các lớp kế thừa, có thể sử dụng các phương thức (mã nguồn) của các
lớp bị kế thừa, mà không cần phải định nghĩa lại.
Ưu điểm
Lập trình hướng đối tượng có một số ưu điểm nổi bật:
• Khơng cịn nguy cơ dữ liệu bị thay đổi tự do trong chương trình. Vì dữ liệu đã được
đóng gói vào các đối tượng.Nếu muốn truy nhập vào dữ liệu phải thông qua các phương
thức cho phép của đối tượng.
• Khi thay đổi cấu trúc dữ liệu của một đối tượng, không cần thay đổi các đổi mã nguồn
của các đối tượng khác, mà chỉ cần thay đổi một số hàm thành phần của đối tượng bị
thay đổi.
Điều này hạn chế sự ảnh hưởng xấu của việc thay đổi dữ liệu đến các đối tượng khác
trong chương trình.
• Có thể sử dụng lại mã nguồn, tiết kiệm tài nguyên. Vì nguyên tắc kế thừa cho phép các
lớp kế thừa sử dụng các phương thức được kế thừa từ lớp khác như những phương thức
của chính nó, mà khơng cần thiết phải định nghĩa lại.
• Phù hợp với các dự án phần mềm lớn, phức tạp.
Phương pháp phân tích và thiết kế hướng đối tượng:
14
Một vấn đề cơ bản đặt ra cho phương pháp hướng đối tượng là từ một bài toán ban đầu,
làm sao để thu được một tập các đối tượng, với các chức năng được phối hợp với nhau,
đáp ứng được u cầu của bài tốn đặt ra?
Phương pháp phân tích thiết kế hướng đối tượng ra đời nhằm trả lời cho câu hỏi này.
Mục đích là xây dựng một tập các lớp đối tượng tương ứng với mỗi bài toán, phương
pháp này tiến hành theo hai pha chính:
Pha phân tích: Chuyển đổi u cầu bài tốn từ ngơn ngữ tự nhiên sang ngơn ngữ mơ
hình.
Pha thiết kế: Chuyển đổi đặc tả bài tốn dưới dạng ngơn ngữ mơ hình sang một mơ hình
cụ thể có thể cài đặt được.
Hai pha phân tích và thiết kế này bao gồm nhiều bước khác nhau(gồm 6 bước):
• Mơ tả bài tốn
• Đặc tả u cầu
• Trích chọn đối tượng
• Mơ hình hố lớp đối tượng
• Thiết kế tổng quan
• Thiết kế chi tiết.
Bước 1: Mơ tả bài tốn
Bài tốn ban đầu được phát biểu dưới dạng ngơn ngữ tự nhiên, bao gồm:
• Mục đích, chức năng chung
• Các u cầu về thơng tin dữ liệu
• Các yêu cầu về chức năng thực hiện
Bước 2: Đặc tả yêu cầu
Các yêu cầu được hình thức hoá lên một mức cao hơn bằng cách sử dụng ngôn ngữ kiểu
kịch bản(scenario) để mô tả. Trong một kịch bản, mỗi chức năng, mỗi hoạt động được
mô tả bằng một kịch bản, bao gồm:
• Các tác nhân tham gia vào kịch bản.
• Vai trị của mỗi tác nhân trong kịch bản.
• Thứ tự các hành động mà mỗi tác nhân thực hiện: khi nào thực hiện, tác động vào tác
nhân nào, thơng tin nào được trao đổi.
Q trình trên được tiến hành với tất cả các chức năng yêu cầu của hệ thống.
Bước 3: Trích chọn đối tượng
Bước này sẽ tiến hành đề xuất các đối tượng có thể có mặt trong hệ thống:
• Dựa vào các kịch bản được mô tả trong bước hai, chọn ra các tác nhân có xuất hiện để
đề xuất thành các đối tượng.
• Lựa chọn các đối tượng bằng cách loại bỏ các tác nhân bên ngồi hệ thống, các tác
nhân trùng lặp.
• Cuối cùng, ta thu được tập các đối tượng của hệ thống.
Bước 4: Mơ hình hố lớp đối tượng
Bước này tiến hành trừu tượng hố đối tượng thành các lớp:
• Thu thập tất cả các thuộc tính của mỗi đối tương vừa thu thập được, dựa vào yêu cầu
về thông tin trong yêu cầu hệ thống (từ bước 1).
• Thu thập các hành động mà mỗi đối tượng cần thực hiện, dựa vào các kịch bản mà đối
tượng tương ứng có tham gia (trong bước 2).
• Nhóm các đối tượng tương tự nhau, hoặc có nhiều thuộc tính gần giống nhau.
• Loại bỏ một số thuộc tính cá biệt, riêng tư của một số đối tượng trong nhóm.
15
• Mơ hình mỗi nhóm đối tượng cịn lại thành lớp: Các thuộc tính chung của các đối
tượng thành thuộc tính của lớp, các hành động của các đối tượng thành phương thức của
lớp.
Kết quả thu được một tập các lớp đối tượng ban đầu của hệ thống.
Bước 5: Thiết kế tổng quát
Bước này sẽ tiến hành thiết kế vĩ mô, nghĩa là thiết kế mối quan hệ giữa các lớp trong
hệ thống:
• Xác định sơ đồ thừa kế, nếu có, giữa các lớp: Nếu hai lớp có một số thuộc tính chung,
thì tách các thuộc tính chung làm thành một lớp cơ sở, và hai lớp ban đầu đều dẫn xuất
từ lớp cơ sở đó. Thơng thường, lớp các trừu tượng (chung nhất) sẽ làm lớp cơ sở, lớp
càng cụ thể, càng chi tiết thì làm lớp dẫn xuất (lớp con, cháu).
• Xác định tương tác, nếu có, giữa các lớp: Dựa vào các kịch bản được mô tả trong bước
2, hai tác nhân có tương tác với nhau thì hai lớp tương ứng ở bước này cũng có tương
tác với nhau.
Kết quả thu được của bước này là một sơ đồ quan hệ bên ngoài giữa các lớp trong hệ
thống.
Bước 6: Thiết kế chi tiết
Bước này sẽ thực hiện thiết kế ở mức vi mô, nghĩa là thiết kế kiến trúc bên trong của
mỗi lớp đối tượng:
• Tổ chức dữ liệu của lớp theo các thuộc tính. Qui định phạm vi truy nhập cho từng
thuộc tính.
• Thiết kế chi tiết cách cư xử của lớp đối tượng thông qua các phương thức của lớp: Xác
định kiểu dữ liệu trả về, kiểu tham số của phương thức, mô tả thuật toán chi tiết cho
từng phương thức, nếu cần.
Kết quả thu được của bước này là một tập các lớp với thiết kế chi tiết kiến trúc bên
trong.
Sau các bước phân tích thiết kế hướng đối tượng từ một yêu cầu của bài tốn ban đầu, ta
thu được một mơ hình hệ thống hướng đối tượng chi tiết:
• Có cái nhìn tổng quan, vĩ mơ về hệ thống bằng mơ hình thiết kế tổng quan, chỉ rõ số
lượng các lớp đối tượng, mối quan hệ kế thừa và quan hệ tương tác giữa các lớp đối
tượng trong hệ thống.
• Có cái nhìn chi tiết, vi mơ về hệ thống bằng mơ hình thiết kế chi tiết. Mơ hình này chỉ
rõ bên trong mỗi lớp đối tương: các thuộc tính, các phương thức với kiểu trả về và kiểu
tham số, thuật tốn chi tiết cho mỗi phương thức.
Sau pha phân tích và thiết kế hướng đối tượng, ta thu được đặc tả hệ thống dưới dạng
mơ hình các lớp: quan hệ giữa các lớp và kiến trúc bên trong của mỗi lớp. Đây sẽ là đầu
vào cho pha tiếp theo, pha lập trình hướng đối tượng, như chúng ta đã biết.
5. Ngơn ngữ lập trình hướng đối tượng
Đặc trưng
Lập trình hướng đối tượng có hai đặc trưng cơ bản:
• Đóng gói dữ liệu: dữ liệu luôn được tổ chức thành các thuộc tính của lớp đối tượng.
Việc
truy nhập đến dữ liệu phải thơng qua các phương thức của đối tượng lớp.
• Sử dụng lại mã nguồn: việc sử dụng lại mã nguồn được thể hiện thông qua cơ chế kế
thừa. Cơ chế này cho phép các lớp đối tượng có thể kế thừa từ các lớp đối tượng khác.
Khi
16
đó, trong các lớp dẫn xuất, có thể sử dụng các phương thức (mã nguồn) của các lớp cơ
sở
mà không cần phải định nghĩa lại.
Ưu điểm
Lập trình hướng đối tượng có một số ưu điểm nổi bật:
• Khơng cịn nguy cơ dữ liệu bị thay đổi tự do trong chương trình. Vì dữ liệu đã được
đóng
gói vào các đối tượng. Nếu muốn truy nhập vào dữ liệu phải thông qua các phương thức
được cho phép của đối tượng.
• Khi thay đổi cấu trúc dữ liệu của một đối tượng, không cần thay đổi mã nguồn của các
đối
tượng khác, mà chỉ cần thay đổi một số thành phần của đối tượng dẫn xuất. Điều này
hạn
chế sự ảnh hưởng xấu của việc thay đổi dữ liệu đến các đối tượng khác trong chương
trình.
• Có thể sử dụng lại mã nguồn, tiết kiệm tài ngun, chi phí thời gian. Vì ngun tắc kế
thừa cho phép các lớp dẫn xuất sử dụng các phương thức từ lớp cơ sở như những
phương
thức của chính nó, mà khơng cần thiết phải định nghĩa lại.
• Phù hợp với các dự án phần mềm lớn, phức tạp.
17
Bài tập thực hành
Hãy phân tích bài tốn sau theo hướng tiếp cận đối tượng
Xây dựng lớp Color gồm:
Thuộc tính: TenMau, MaMau
Phương thức:
· Cấu tử không tham số
· Cấu tử có tham số
· Hủy
· Nạp chồng tốn tử nhập
· Nạp chồng toán tử xuất
· getTenMau() : hàm trả về TenMau
Xây dựng lớp Point gồm:
Thuộc tính: int x, y
Phương thức:
· Cấu tử khơng tham số
· Cấu tử có tham số
· Hủy
· Nạp chồng toán tử nhập
· Nạp chồng toán tử xuất
· CheoChinh : hàm kiểm tra Point có thuộc đường chéo chính hay khơng (1
điểm thuộc đường chéo chính khi và chỉ khi tung độ bằng hoành độ).
Xây dựng lớp Pixel kế thừa từ lớp Color và Point bao gồm thêm:
Phương thức:
· Cấu tử khơng tham số
· Cấu tử có tham số
· Nạp chồng toán tử nhập
· Nạp chồng toán tử xuất
· KiemTra: hàm kiểm tra Pixel thuộc đường chéo chính và có màu “Xanh” hay
khơng?
Chương trình chính: Nhập vào từ bàn phím n Pixel (n nhập từ bàn phím).
Hiển thị thơng
tin các Pixel thuộc đường chéo chính và có màu xanh.
18
BÀI 2: LỚP VÀ ĐỐI TƯỢNG
Mã bài: MĐLVT 21.02
Giới thiệu
Ngôn ngữ C++ được phát triển từ C lên, nó được bổ sung thêm tính hướng đối tượng.
Các lớp (class) là tính năng trung tâm của C++ mà hỗ trợ lập trình hướng đối tượng và
thường được gọi là các kiểu người dùng tự định nghĩa (user-defined).
Một lớp được sử dụng để xác định form của một đối tượng và nó kết nối sự biểu diễn dữ
liệu và các phương thức để thao tác các dữ liệu đó vào trong một package gọn gàng. Dữ
liệu và hàm bên trong một lớp được gọi là các thành viên của lớp đó.
Mục tiêu
- Trình bày được các khái niệm Lớp, lớp đối tượng, thuộc tính, phương thức.
- Trình bày được khái niệm về phạm vi thơng tin trong lớp.
- Trình bày được khái niệm và tác dục của hàm tạo, hàm hủy- Phân tích và xác định
được các thành phần thuộc tính và phương thức của lớp.
- Trình bày được cú pháp định nghĩa lớp, định nghĩa các thành phần của lớp với ngơn
ngữ lập trình cụ thể.
- Trình bày được cú pháp và xác định được nội dung hàm hủy, hàm tạo trong ngơn ngữ
lập trình cụ thể.
- Sử dụng được ngơn ngữ lập trình hướng đối tượng định nghĩa được lớp với các thành
phần.
- Phân tích và xác định được các lớp đối tượng trong bài toán thực tế.
- Xây dựng được chương trình, sử dụng lớp đối tượng đã định nghĩa được.
Nội dung
1. Định danh
1.1 Quy định với định danh
Một khi phương thức được khai báo là trừu tượng thì khi một con trỏ gọi đến phương
thức đó, chương trình sẽ thực hiện phương thức tương ứng với đối tượng mà con trỏ
đang trỏ tới, thay vìthực hiện phương thức của lớp cùng kiểu với con trỏ. Đây được gọi
là hiện tượng đa hình (tươngứng bội) trong C++.
Chương trình 6.9 minh hoạ việc sử dụng phương thức trừu tượng: lớp Bus kế thừa từ
lớp Car, hai lớp này cùng định nghĩa phương thức trừu tượng show().
· Khi ta dùng một con trỏ có kiểu lớp Car trỏ vào địa chỉ của một đối tượng kiểu
Car, nó sẽ gọi phương thức show() của lớpCar.
· Khi ta dùng cũng con trỏ đó, trỏ vào địa chỉ của một đối tượng kiểu Bus, nó sẽ gọi
phương thức show() của lớpBus.
Chương trình 6.9 hiển thị kết quả thông báo như sau:
This is a Ford having a speed of 100km/h and its price is $3000
This is a bus of type Mercedes, on the line 27, having a speed of
150km/h and its price is $5000
Dòng thứ nhất là kết quả khi con trỏ ptrCar trỏ đến địa chỉ của đối tượng
myCar, thuộc lớp Car nên sẽ gọi phương thức show() của lớp Car với các dữ
liệu của đối tượng myCar: (100, Ford, 1463000). Dòng thứ hai tương ứng là
kết quả khi con trỏ ptrCar trỏ đến địa chỉ của đối tượng myBus, thuộc lớp Bus
nên sẽ gọi phương thức show() của lớp Bus, cùng với các tham số của đối tượng
myBus: (150, Mercedes, 5000, 27).
19
Lưu ý:
Trong trường hợp ở lớp dẫn xuất không định nghĩa lại phương thức trừu tượng, thì
chương trình sẽ gọi phương thức của lớp cơ sở, nhưng với dữ liệu của lớp dẫnxuất.
Ví dụ, nếu trong chương trình 6.9, lớp Bus khơng định nghĩa chồng phương thức
trừu tượng show() thì kết quả hiển thị sẽ là hai dịng thơng báo giống nhau, chỉ khác
nhau ở dữ liệu của hai đối tượng khác nhau:
This is a Ford having a speed of 100km/h and its price is $3000 This is a Mercedes
having a speed of 150km/h and its price is$5000
1.2.Quy ước với định danh
Thơng thường khi mới học lập trình c++ sẽ chỉ viết những chương trình đơn giản nên
khơng quan tâm đến việc đặt tên trong c++. Nhưng sau này, khi làm những dự án lớn
nếu khơng có cách đặt tên cụ thể thì sẽ rất khó hiểu cho cả mình với người khác. Nên
trong bài này mình sẽ nói về một số quy ước đặt tên trong c++.
Quy tắc chung
· Tên phải bắt đầu bằng chữ cái hoặc dấu gạch dưới _. Ví dụ: Laptrinh1, _Laptrinh...
· Khơng được dùng những từ khóa như: const, char, int …
· Tên khơng được có các tốn tử.
· Hai biến trong cùng một hàm khơng được trùng tên.
· Tên biến khơng có dấu cách.
Biến là một giá trị không thay đổi
Các biến khai báo là const thì phải viết hoa tồn bộ tên biến hoặc đặt tên có chữ "k"
đứng trước tên biến.
Tên tệp.
Tất cả các tên tệp phải là chữ thường và có thể bao gồm dấu gạch dưới ( _) hoặc dấu
gạch ngang ( -). Tuân theo quy ước mà dự án của bạn sử dụng và đặt tên thật cụ thể.
Ví dụ :
· my_useful_class.cc
· my-useful-class.cc
Tên hàm
Tên hàm trong c++ thường sẽ viết hoa chữ cái đầu của mỗi từ mới
Class
Tên class nên là một danh từ và sẽ viết hoa chữ cái đầu của tất cả các từ.
Tên biến
Tên biến trong c++ các bạn nên đặt là từ có ý nghĩa, ngắn gọn, dễ hiểu có thể viêt
thường, dung dấu gạch ngang "_" hoặc viết hoa khi có viết từ mới nhưng thơng thường
mình sẽ dùng dấu gạch ngang, miễn sao bạn tuân theo cách đặt tên chung mà mình đã
20
nêu
ở
trên.
2. Các kiểu dữ liệu
2.1. Kiểu dữ liệu nguyên thủy
Số nguyên, số thực, ký tự, boolean
Kiểu dữ liệu trong C++ xác định loại dữ liệu mà một biến có thể lưu trữ như số
nguyên, số thực, ký tự vv. Bạn có thể lưu thơng tin của các kiểu dữ liệu (Data Type) đa
dạng như Character, Wide Character, integer, floating-point, double floating point,
Boolean, …. Dựa trên kiểu dữ liệu của một biến, hệ thống sẽ cấp phát bộ nhớ và quyết
định những gì có thể được lưu giữ trong bộ nhớ dành riêng đó.Tên tiếng Anh là
Primitive Type, cịn có thể gọi là kiểu dữ liệu gốc, kiểu dữ liệu cơ bản, hay kiểu dữ liệu
có sẵn trong C++. Bên cạnh các kiểu dữ liệu gốc này, C++ cũng cung cấp các kiểu dữ
liệu do người dùng tự định nghĩa (user-defined). Bảng dưới đây liệt kê danh sách 7
kiểu dữ liệu cơ bản trong C++:
Kiểu dữ liệu
Từ khóa
Boolean
bool
Ký tự
char
Số nguyên
int
Số thực
float
Số thực dạng Double
double
Kiểu khơng có giá trị
void
Kiểu Wide character
wchar_t
Một số kiểu cơ bản có thể được sửa đổi bởi sử dụng một hoặc nhiều modifier sau:
· signed (kiểu có dấu)
· unsigned (kiểu khơng có dấu)
· short
· long
Các loại dữ liệu nguyên thủy
Các kiểu dữ liệu cơ bản dựa trên số nguyên và số thực. Ngôn ngữ C hỗ trợ cả signed và
unsigned.
Kích thước bộ nhớ của các loại dữ liệu cơ bản có thể thay đổi theo hệ điều hành 32
hoặc 64 bit.
Hãy xem các kiểu dữ liệu cơ bản. Kích thước của nó được cho theo kiến trúc 32 bit.
Bảng sau hiển thị kiểu biến, lượng bộ nhớ nó dùng để lưu giá trị trong bộ nhớ, và giá
trị lớn nhất và nhỏ nhất có thể được lưu giữ với các kiểu biến đó:
Kiểu
Kích thước bộ nhớ Vùng giá trị
21
char
1 byte
-127 tới 127 hoặc 0 tới 255
unsigned char
1 byte
0 tới 255
signed char
1 byte
-127 tới 127
int
4 byte
-2147483648 tới 2147483647
unsigned int
4 byte
0 tới 4294967295
signed int
4 byte
-2147483648 tới 2147483647
short int
2 byte
-32768 tới 32767
unsigned short int
Range
0 tới 65,535
signed short int
Range
-32768 tới 32767
long int
4 byte
-2,147,483,647 tới 2,147,483,647
signed long int
4 byte
Tương tự như long int
unsigned long int
4 byte
0 tới 4,294,967,295
float
4 byte
+/- 3.4e +/- 38 (~7 chữ số)
double
8 byte
+/- 1.7e +/- 308 (~15 chữ số)
long double
8 byte
+/- 1.7e +/- 308 (~15 chữ số)
wchar_t
2 hoặc 4 byte
1 wide character
Ví dụ sử dụng tốn tử để lấy gia kích cỡ kiểu dữ liệu
#include <iostream>
using namespace std;
intmain() {
cout << "Kich co cua char la: "<< sizeof(char) << endl;
cout << "Kich co cua int la: "<< sizeof(int) << endl;
cout << "Kich co cua short int la: "<< sizeof(shortint) << endl;
cout << "Kich co cua long int la: "<< sizeof(longint) << endl;
cout << "Kich co cua float la: "<< sizeof(float) << endl;
cout << "Kich co cua double la: "<< sizeof(double) << endl;
cout << "Kich co cua wchar_t la: "<< sizeof(wchar_t) << endl;
return0;
}
Kết quả:
Kich co cua char la: 1
Kich co cua int la: 4
Kich co cua short int la: 2
Kich co cua long int la: 4
22
Kich co cua float la: 4
Kich co cua double la: 8
Kich co cua wchar_t la: 2
2.2.Giá trị hằng
Hằng số trong C++ là một giá trị hoặc biến không thể thay đổi trong chương trình, ví
dụ: 10, 20, 'a', 3.4, "lập trình c++", vv.
Từ khóa const được sử dụng để định nghĩa hằng số trong lập trình C++.
constfloatPI = 3.14;
#include <iostream>
using namespace std;
int main() {
const float PI = 3.14;
cout<< "Gia tri PI = " << PI;
return 0;
}
2.3.Chuyển đổi kiểu dữ liệu
C++ cho phép các kiểu dữ liệu char, int và double có các Modifier đặt trước chúng.
Một Modifier được sử dụng để thông báo ý nghĩa của kiểu cơ sở, giúp cho nó tăng sự
chính xác hơn với sự cần thiết của các tình huống đa dạng.
Dưới đây là các Modifier trong C/C++:
· signed (có dấu)
· unsigned (khơng có dấu)
· long
· short
Các Modifier là: signed, unsigned, long, và short có thể được áp dụng cho kiểu
integer. Ngoài ra, signed và unsigned có thể được áp dụng cho kiểu char, và long có
thể áp dụng cho kiểu double.
Các Modifier là signed và unsigned cũng có thể được sử dụng như là tiền tố cho các
Modifier là long hoặc short modifiers. Ví dụ: unsigned long int.
C++ cho phép kiểu khai báo tắt để khai báo các unsigned, short, or long integer. Bạn
có thể chỉ đơn giản sử dụng từ unsigned, short, hoặc long, mà khơng cần int. Ví dụ
sau minh họa hai khai báo là hợp lệ trong C/C++ để khai báo các biến unsigned
integer:
1
unsigned x;
2
unsigned inty;
Để phân biệt sự khác nhau giữa hai Modifier là signed integer và unsigned integer
được thông dịch bởi C/C++, bạn nên chạy chương trình sau:
1
2
3
4
5
6
7
8
#include <iostream>
usingnamespacestd;
/*
* Chương trình này chỉ ra diểm khác nhau giữa
* 2 kiểu số nguyên signed và unsigned.
*/
intmain() {
23
shortinti;
// số nguyên signed short int
9
shortunsigned intj; // số nguyên unsigned short int
10
j = 32769;
11
i = j;
12
cout << i << " "<< j;
13
return0;
14
}
15
Nó sẽ cho kết quả
1
-32767 32769
2.4.Khai báo và khởi tạo biến, hằng
Cú pháp khai báo biến
Cú pháp để khai báo một biến trong C:
1
type variable_list;
Ví dụ về khai báo biến:
inta;
1
floatb;
2
charc;
3
Ở đây, a, b, c là các biến và int, float, char là các kiểu dữ liệu.
Chúng ta cũng có thể cung cấp giá trị trong khi khai báo các biến như được đưa ra dưới
đây:
inta = 10, b = 20; // Khai báo 2 biến kiểu số nguyên
1
float= 20,8;
2
charc = 'A';
3
Quy tắc khai báo biến trong C
· Một biến có thể có các chữ cái, chữ số và dấu gạch dưới.
· Tên biến chỉ có thể bắt đầu bằng bảng chữ cái và dấu gạch dưới. Nó khơng thể
bắt đầu bằng chữ số.
· Khơng có khoảng trắng trong tên biến.
· Tên biến không phải là bất kỳ từ hoặc từ khóa dành riêng như int, float, vv.
Tên biến hợp lệ:
inta;
int_ab;
inta30;
Tên biến không hợp lệ:
int2;
inta b;
intlong;
24
3. Toán tử
3.1.Toán tử số học
Toán tử số học trong C++
Bảng dưới liệt kê các toán tử số học được hỗ trợ bởi ngôn ngữ C++:
Giả sử biến A giữ giá trị 10, biến B giữ 20 thì:
Tốn Miêu tả
tử
Ví dụ
+
Cộng hai toán hạng
A + B kết quả là 30
-
Trừ toán hạng thứ hai từ toán hạng đầu
A - B kết quả là -10
*
Nhân hai toán hạng
A * B kết quả là 200
/
Phép chia
B / A kết quả là 2
%
Phép lấy số dư
B % A kết quả là 0
++
Toán tử tăng (++), tăng giá trị toán
hạng thêm một đơn vị
A++ kết quả là 11
--
Toán tử giảm (--), giảm giá trị toán
hạng đi một đơn vị
A-- kết quả là 9
3.2. Toán tử bit
Toán tử so sánh bit trong C++
Toán tử so sánh bit làm việc trên đơn vị bit, tính tốn biểu thức so sánh từng bit. Bảng
dưới đây về &, |, và ^ như sau:
p
q
p&q
p|q
p^q
0
0
0
0
0
0
1
0
1
1
1
1
1
1
0
1
0
0
1
1
Giả sử nếu A = 60; và B = 13; thì bây giờ trong định dạng nhị phân chúng sẽ là như
sau:
A = 0011 1100
B = 0000 1101
----------------A&B = 0000 1100
A|B = 0011 1101
25
