C++ Bài 4.2: Con trỏ và đối tượng

C++ cho phép sử dụng các toán tử chuẩn của ngôn ngữ giữa các lớp giống như với các kiểu dữ liệu cơ bản. Ví dụ:

int a, b, c;
a = b + c;

là hoàn toàn hợp lệ vì các biến ở đây đều có kiểu là các kiểu dữ liệu cơ bản. Tuy nhiên, việc chúng ta có thể thực hiện thao tác sau đây có vẻ không hiển nhiên lắm (thực tế là nó không hợp lệ):

struct { char product [50]; float price; } a, b, c;
a = b + c;

Phép gán một lớp (hay một cấu trúc) với một đối tượng cùng kiểu là được phép (copy constructor mặc định). Nhưng phép cộng sẽ gây ra lỗi vì nó được dùng với các kiểu dữ liệu không cơ bản.

Nhưng cần phải cám ơn khả năng quá tải toán tử của C++, chúng ta có thể làm cho các đối tượng kiểu như trên có thể chấp nhận các toán tử đó mà không làm thay đổi ý nghĩa của nó đối với các kiểu dữ liệu cơ bản. Dưới đây là danh sách tất cả các toán tử có thể được quá tải:

+    -    *    /    =    <    >    +=   -=   *=   /=   <<   >>
<<=  >>=  ==   !=   <=   >=   ++   --   %    &    ^    !    |
~    &=   ^=   |=   &&   ||   %=   []   ()   new  delete

Để làm quá tải một toán tử chúng ta chỉ cần viết một hàm thành viên của lớp có tên operator theo sau là toán tử chúng ta muốn làm quá tải. Mẫu như sau:

type operator sign (parameters);

Dưới đây là ví dụ về việc quá tải toán tử +. Chúng ta chuẩn bị tính tổng hai vector hai chiều a(3,1) và b(1,2). Phép cộng giữa hai vector hai chiều chỉ đơn giản là cộng hai toạ độ x để lấy toạ độ kết quả x , cộng hai toạ độ y để lấy toạ độ kết quả y. Trong trường hợp này kết quả sẽ là (3+1,1+2) = (4,3).

// vectors: ví dụ về quá tải toán tử #include class CVector { public: int x,y; CVector () {}; CVector (int,int); CVector operator + (CVector); }; CVector::CVector (int a, int b) { x = a; y = b; } CVector CVector::operator+ (CVector param) { CVector temp; temp.x = x + param.x; temp.y = y + param.y; return (temp); } int main () { CVector a (3,1); CVector b (1,2); CVector c; c = a + b; cout <<>

4,3

Nếu bạn thấy quá nhiều CVector hãy để ý rằng một số trong chúng tham chiếu đến tên lớp CVector còn số còn lại là tên các hàm (constructor và destructor). Đừng lẫn lộn

CVector (int, int);            // Hàm có tên Vector (constructor)
CVector operator+ (CVector);   // Hàm operator+  trả về kiểu CVector

Hàm operator+ của lớp CVector được dùng để quá tải toán tử số học +. Hàm này có thể được gọi bằng một trong các cách:

c = a + b;
c = a.operator+ (b);

Hãy chú ý rằng chúng ta đã thêm vào constructor rỗng (không có tham số) và chúng ta định nghĩa nó với một khối lệnh cũng rỗng nốt: CVector () { }; điều này là cần thiết vì còn có một constructor khác, CVector (int, int); và vì vậy các constructors mặc định không tồn tại trong CVector nếu chúng ta không khai nó một cách rõ ràng. Khai báo sau đây sẽ là không hợp lệ: CVector c; Dù thế nào chăng nữa, tôi cần phải cảnh báo rằng một khối lệnh rỗng không nên để tạo một constructor vì nó không thoả mãn chức năng tối thiểu mà một constructor nên có, đó là việc khởi tạo tất cả các biến trong lớp. Trong trường hợp của chúng ta constructor này đã để các biến x và y là không xác định. Vì vậy một khai báo thích hợp hơn sẽ là một cái gì đó giống như thế này: CVector () { x=0; y=0; }; để cho đơn giản tôi đã không viết vào trong ví dụ trên.

Cùng với việc tạo một constructor rỗng và một copy constructor, C++ còn mặc định định nghĩa toán tử gán (=) giữa hai lớp có cùng một kiểu. Nó copy toàn bộ nội dung của các thành viên không tĩnh (non-static) của đối tượng bên phải phép gán cho đối tượng bên trái. Tất nhiên bạn có thể định nghĩa lại nó để thực hiện chức năng khác mà bạn muốn, ví dụ như chỉ copy một số thành viên nào đó của lớp.

Việc quá tải các toán tử không bắt buộc hoạt động của nó phải liên quan đến ý nghĩa thông thường của nó mặc dù điều này là nên làm. Ví dụ có vẻ không logic lắm nếu sử dụng toán tử + để trừ hai lớp hay toán tử == để điền số 0 vào một lớp mặc dù điều đó là hoàn toàn hợp lệ.

Mặc dù khai báo mẫu của hàm operator+ là khá hiển nhiên vì nó lấy phần bên phải của toán tử làm tham số cho hàm operator+, các toán tử khác không phải cái nào cũng rõ ràng như thế. Ở đây chúng ta có một bảng tổng kết về việc các hàm operator phải được khai báo như thế nào (thay thế @ bằng các toán tử tương ứng):

Biểu thức	Toán tử (@)	Hàm thành viên	Hàm toàn cục
@a	+ - * & ! ~ ++ --	A::operator@()	operator@(A)
a@	++ --	A::operator@(int)	operator@(A, int)
a@b	+ - * / % ^ & | < > == != <= >= << >> && || ,	A::operator@(B)	operator@(A, B)
a@b	= += -= *= /= %= ^= &= |= <<= >>= [ ]	A::operator@(B)	-
a(b, c...)	()	A::operator()(B, C...)	-
a->b	->	A::operator->()	-

* trong đó a là một đối tượng của lớp A, b là một đối tượng của lớp B và c là một đối tượng của lớp C.

Như bạn có thể thấy trong bảng này, có hai cách để quá tải các toán tử của lớp: như là một hàm thành viên và như là một hàm toàn cục. Khác nhau giữa chúng không rõ ràng tuy nhiên tôi cần phải nhắc lại rằng các hàm không phải là thành viên của một lớp không thể truy xuất đến các thành viên là private hoặc protected của lớp trừ phi hàm toàn cục đó là bạn của lớp (thuật ngữ này sẽ được đề cập đến ở bài sau).

Từ khoá this

Từ khoá this ở bên trong một lớp đại diện cho đối tượng của lớp đó đang được thực hiện trong bộ nhớ. Nó là một con trỏ luôn có giá trị là địa chỉ của đối tượng.

Nó có thể được dùng để kiểm tra xem tham số được truyền cho một hàm thành viên có phải chính bản thân đối tượng hay không. Ví dụ:

// this #include class CDummy { public: int isitme (CDummy& param); }; int CDummy::isitme (CDummy& param) { if (&param == this) return 1; else return 0; } int main () { CDummy a; CDummy* b = &a; if ( b->isitme(a) ) cout << "yes, &a is b"; return 0; }

yes, &a is b

Nó cũng thường được dùng trong hàm thành viên operator= mà trả về địa chỉ đối tượng (tránh việc sử dụng đối tượng tạm thời). Tiếp theo ví dụ về vector ở đầu bài chúng ta có thể viết một hàm operator= như sau:

CVector& CVector::operator= (const CVector& param)
{
x=param.x;
y=param.y;
return *this;
}

Trong thực tế đây chính là đoạn mã được mặc định tạo ra nếu chúng ta không viết hàm thành viên operator=.

Các thành viên tĩnh

Một lớp có thể chứa các thành viên tĩnh, cả dữ liệu và các hàm.

Các dữ liệu tĩnh còn được gọi là "biến của lớp" vì nội dung của chúng không phụ thuộc vào một đối tượng nào. Chỉ có một giá trị duy nhất cho tất cả các đối tượng trong cùng một lớp.

Ví dụ, nó có thể được trong trường hợp bạn muốn có một biến chứa số đối tượng thuộc lớp đã được khai báo:

// static members in classes #include class CDummy { public: static int n; CDummy () { n++; }; ~CDummy () { n--; }; }; int CDummy::n=0; int main () { CDummy a; CDummy b[5]; CDummy * c = new CDummy; cout <<>

7 6

Trong thực tế, các thành viên tĩnh có cùng thuộc tính với các biến toàn cục. Vì vậy, để tránh việc chúng bị khai báo nhiều lần, theo chuẩn ANSI-C++ chúng ta chỉ được viết phần khai báo mẫu trong phần khai báo của lớp. Để có thể khởi tạo một thành viên tĩnh chúng ta phải viết một định nghĩa ở bên ngoài lớp, giống như ở trong ví dụ trước.

Vì nó là một biến duy nhất cho tất cả các đối tượng thuộc lớp, nó có thể được tham chiếu đến như là thành viên của bất kì đối tượng nào thuộc lớp hay thậm chí chính bản thân tên lớp (tất nhiên điều này chỉ hợp lệ với các thành viên tĩnh):

cout <<>

Hai lời gọi trong ví dụ trên đều tham chiếu đến cùng một biến: biến tĩnh n trong lớp CDummy.

Một lần nữa, tôi phải nhắc lại rằng nó là một biến toàn cục (nghĩa là bạn có thể truy xuất nó từ bất kì đâu). Sự khác biệt duy nhất là bạn phải dùng nó với tên lớp.

Chúng ta cũng có thể tạo ra các hàm tĩnh giống như các biến tĩnh. Chúng cũng có ý nghĩa như đối với các biến tĩnh: đó là các hàm toàn cục có thể được gọi như thể là các đối tượng của một lớp. Chúng chỉ có thể truy xuất đến phần dữ liệu tĩnh cũng như không được phép sử dụng từ khoá this vì nó tạo tham chiếu đến một con trỏ đối tượng. Các hàm này thực tế không phải là thành viên của bất kì đối tượng nào mà thực chất là của lớp.