Các lớp
Lớp là một phương thức logic để tổ chức dữ liệu và các hàm trong cùng một cấu
trúc. Chúng được khai báo sử dụng từ khoá class, từ này có chức năng tương tự
với từ khoá của C struct nhưng có khả năng gộp thêm các hàm thành viên.
Dạng thức của nó như sau:
class class_name {
permission_label_1:
member1;
permission_label_2:
member2;
...
} object_name;
trong đó class_name là tên của lớp ( kiểu người dùng tự định nghĩa) và trường
mặc định object_name là một hay một vài tên đối tượng hợp lệ. Phần thân của
khai báo chứa các thành viên của lớp, đó có thể là dữ liệu hay các hàm và có thể
là các nhãn cho phép ( permission labels) là một trong những từ khoá sau
đây: private:, public: hoặc protected:.
• Các thành viên private của một lớp chỉ có thể được truy xuất từ các
thành viên khác của lớp hoặc từ các lớp "bạn bè".
• Các thành viên protected có thể được truy xuất từ các thành viên trong
cùng một lớp và các lớp bạn bè, thêm vào đó là từ các thành viên của các
lớp thừa kế
• Cuối cùng, các thành viên public có thể được truy xuất từ bất kì chỗ nào
mà lớp nhìn thấy.
Nếu chúng ta khai báo các thành viên của một lớp trước khi thêm vào các nhãn
cho phép thì các thành viên đó được coi là private.
Ví dụ:
class CRectangle {
int x, y;
public:
void set_values (int,int);
int area (void);
} rect;
Khai báo lớp CRectangle và một đối tượng có tên rect có kiểu là lớp
CRectangle. Lớp này chứa bốn thành viên: hai viến có kiểu int (x và y) trong
phần private (vì private là sự cho phép mặc định) và hai hàm trong phần
public: set_values() và area(), ở đây chúng ta chỉ mới khai báo mẫu.
Hãy chú ý sự khác biệt giữa tên lớp và tên đối đối tượng: Trong ví dụ trước,
CRectangle là tên lớp còn rect là tên một đối tượng có kiểu CRectangle.
Trong các phần tiếp theo của chương trình chúng ta có thể truy xuất đến các thành
viên public của đối tượng rect như là đối với các hàm hay các biến thông thường
bằng cách đặt tên của đối tượng rồi sau đó là một dấu chấm và tên thành viên của
lớp (như chúng ta đã làm với các cấu trúc của C). Ví dụ:
rect.set_value (3,4);
myarea = rect.area();
nhưng chúng ta không có khả năng truy xuất đến x hay y vì chúng là các thành
viên private của lớp và chúng chỉ có thể được truy xuất từ các thành viên của cùng
một lớp. Bối rối? Đây là ví dụ đầy đủ về lớp CRectangle:
// classes example
#include <iostream.h>
class CRectangle {
int x, y;
public:
void set_values
(int,int);
int area (void)
{return (x*y);}
};
void
CRectangle::set_values
(int a, int b) {
x = a;
y = b;
}
int main () {
CRectangle rect;
rect.set_values (3,4);
cout << "area: " <<
area: 12
rect.area();
}
Một điều mới trong đoạn mã này là toán tử phạm vi :: được dùng trong khai báo
set_values(). Nó được sử dụng để khai báo ở bên ngoài các thành viên của
một lớp. Chú ý rằng chúng ta đã định nghĩa đầy đủ hàm area() ngay bên trong
lớp trong khi hàm set_values() mới chỉ được khai báo mẫu còn định nghĩa
của nó nằm ở ngoài lớp. Trong phần khai báo ở ngoài này chúng ta bắt buộc phải
dùng toán tử ::.
Sự khác biệt duy nhất giữa việc khai báo đầy đủ một hàm bên trong lớp và việc chỉ
khai báo mẫu là trong trường hợp thứ nhất hàm sẽ được tự động coi là inline bởi
trình dịch, còn trong trường hợp thứ hai nó sẽ là một hàm thành viên bình thường.
Lý do khiến chúng ta khai báo x và y là các thành viên private vì chúng ta đã
định nghĩa một hàm để thâótc với chúng (set_values()) và không có lý do gì
để truy nhập trực tiếp đến các biến này. Có lẽ trong ví dụ rất đơn giản này bạn
không thấy được một tiện ích lớn khi bảo vệ hai biến này nhưng trong các dự án
lớn hơn nó có thể là rất quan trọng khi đảm bảo được rằng các giá trị đó không bị
thay đổi một cách không mong muốn.
Một ích lợi nữa của lớp là chúng ta có thể khai báo một vài đối tượng khác nhau từ
nó. Ví dụ, tiếp sau đây là ví dụ trước về lớp CRectangle, tôi chỉ thêm phần khai
báo thêm đối tượng rectb.
// class example
#include <iostream.h>
class CRectangle {
int x, y;
public:
void set_values
(int,int);
int area (void)
{return (x*y);}
};
void
CRectangle::set_values
(int a, int b) {
x = a;
rect area: 12
rectb area: 30
y = b;
}
int main () {
CRectangle rect, rectb;
rect.set_values (3,4);
rectb.set_values (5,6);
cout << "rect area: " <<
rect.area() << endl;
cout << "rectb area: "
<< rectb.area() << endl;
}
Chú ý rằng lời gọi đến rect.area() không cho cùng kết quả với
rectb.area() vì mỗi đối tượng của lớp CRectangle có các biến và các hàm
của riêng nó
Trên đây là những khái niệm cơ bản về đối tượng và lập trình hướng đối tượng.
Trong đối tượng các dữ liệu và các hàm là các thuộc tính thay vì trước đây đối
tượng là các tham số của hàm trong lập trình cấu trúc. Trong bài này các phần tiếp
sau chúng ta sẽ nói đến những lợi ích của phương thức này.
Constructors và destructors
Nói chung các đối tượng cần phải khởi tạo các biến hoặc cấp phát bộ nhớ động
trong quá trình tạo ra chúng để có thể hoạt động tốt và tránh được việc trả về các
giá trị không mong muốn. Ví dụ, điều gì sẽ xảy ra nếu chúng ta gọi hàm area()
trước khi gọi hàm set_values?Có lẽ kết quả sẽ là một giá trị không xác định vì
các thành viên x và y chưa được gán một giá trị cụ thể nào.
Để tránh điều này, một lớp cần có một hàm đặc biệt: một constructor, hàm này có
thể được khai báo bằng cách đặt tên trùng với tên của lớp. Nó sẽ được gọi tự động
khi một khai báo một đối tượng mới hoặc cấp phát một đối tượng có kiểu là lớp
đó. Chúng ta thêm một constructor vào lớp CRectangle:
// classes example
#include <iostream.h>
class CRectangle {
int width, height;
public:
rect area: 12
rectb area: 30
CRectangle (int,int);
int area (void)
{return (width*height);}
};
CRectangle::CRectangle
(int a, int b) {
width = a;
height = b;
}
int main () {
CRectangle rect (3,4);
CRectangle rectb (5,6);
cout << "rect area: " <<
rect.area() << endl;
cout << "rectb area: "
<< rectb.area() << endl;
}
Như bạn có thể thấy, kết quả của ví dụ này giống với ví dụ trước. Trong trường
hợp này chúng ta chỉ thay thế hàm set_values bằng một hàm constructor.
Hãy chú ý cách mà các tham số được truyền cho constructor khi một đối tượng
được tạo ra:
CRectangle rect (3,4);
CRectangle rectb (5,6);
Bạn có thể thấy rằng constructor không có giá trị trả về, ngay cả kiểu void cũng
không. Điều này luôn luôn phải như vậy.
Destructor làm các chức năng ngược lại. Nó sẽ được tự động gọi khi một đối
tượng được giải phóng khỏi bộ nhớ hay phạm vi tồn tại của nó đã kết thúc (ví dụ
như nếu nó được định nghĩa là một đối tượng cục bộ bên trong một hàm và khi
hàm đó kết thúc thì phạm vi tồn tại của nó cũng hết) hoặc nó là một đối tượng đối
tượng được cấp phát động và sẽ giải phóng bởi toán tử delete.
Destructor phải có cùng tên với tên lớp với dấu (~) ở đằng trước và nó không được
trả về giá trị nào.