Đa năng hóa toán tử-toán tử và dấu phẩy

Toán tử dấu phẩy là toán tử hai ngôi. Chúng ta có thể đa năng hóa toán tử dấu phẩy có ý nghĩa tùy thích. Tuy nhiên, nếu muốn đa năng hóa toán tử phẩy có ý nghĩa tương tự như toán tử phẩy bình thường, chúng ta cần bỏ qua toán hạng bên trái dấu phẩy (nghĩa là đối tượng mà qua đó hàm toán tử tương ứng được gọi) và trả về đối tượng bên phải dấu phải như là kết quả của toán tử. Do vậy trong một danh sách gồm các biểu thức được ngăn cách bởi các dấu phẩy, mọi toán hạng trừ toán hạng ngoài cùng bên phải đều bị bỏ qua.

Ví dụ 4.10: Đa năng hóa toán tử dấu phẩy.

CT4_10.CPP1: #include <iostream.h> 2:3: class Point4: {5: private:6: int X,Y;7: public:8: Point(int A=0,int B=0);9: Point operator +(Point P);10: Point operator ,(Point P);11: void Print() const;12: };13:14: Point::Point(int A,int B)15: {16: X = A;17: Y = B;18: }19:20: Point Point::operator+(Point P)21: {22: Point Tmp;23: Tmp.X=X+P.X;24: Tmp.Y=Y+P.Y;25: return Tmp;26: }27:28: Point Point::operator,(Point P)29: {30: Point Tmp;31: Tmp.X=P.X;32: Tmp.Y=P.Y;33: cout<<P.X<<" "<<P.Y<<endl;34: return Tmp;35: }36:37: void Point::Print() const38: {39: cout<<"X="<<X<<",Y="<<Y<<endl;40: }41:42: int main()43: {44: Point P1(2,6),P2(5,20),P3(1,1);45: cout<<"Point 1:";46: P1.Print();47: cout<<"Point 2:";48: P2.Print();49: cout<<"Point 3:";50: P3.Print();51: P1=(P1,P1+P2,P3);52: cout<<"Point 1:";53: P1.Print();54: return 0;55: }

Chúng ta chạy ví dụ 4.10, kết quả ở hình 4.15

Hình 4.15: Kết quả của ví dụ 4.10

Toán tử dấu mũi tên -> (hoặc toán tử con trỏ cấu trúc) cho phép chúng ta truy cập thành viên của đối tượng thuộc class, struct và union khi được áp dụng vào con trỏ chỉ đến đối tượng đó. Chúng ta có thể đa năng hóa toán tử này, hàm toán tử của toán tử -> phải là hàm thành viên của lớp. Nếu toán tử -> có dạng a-> thì hàm toán tử là a.operator->()

Ví dụ 4.11: Đa năng hóa toán tử ->.

CT4_11.CPP1: #include <iostream.h> 2:3: class MyClass4: {5: public:6: int Data;7: MyClass * operator ->()8: {9: return this;10: }11: };12:13: int main()14: {15: MyClass M;16: M->Data = 10;17: cout<<M.Data<<" "<<M->Data;18: return 0;19: }

Chúng ta chạy ví dụ 4.11, kết quả ở hình 4.16

Hình 4.16: Kết quả của ví dụ 4.11

Khi đa năng hóa toán tử ->, C++ quy định hàm toán tử của nó phải trả về:

 Hoặc là con trỏ trỏ đến đối tượng thuộc lớp chứa thành viên dữ liệu cần truy cập (lớp mà trong đó hàm toán tử được định nghĩa). Một toán tử -> bình thường sẽ được trình biên dịch tự động áp dụng vào con trỏ ấy để truy cập thành viên dữ liệu đó của đối tượng.

 Hoặc là đối tượng thuộc lớp khác. Lớp này phải chứa định nghĩa hàm toán tử. Trình biên dịch sẽ tự động áp dụng toán tử -> trên đối tượng được trả về.Kết quả thu được có thể là một con trỏ trỏ đến đối tượng hoặc một đối tượng. Cứ thế, chúng ta có sự diễn dịch theo lối đệ quy cho tới khi nào kết quả là một con trỏ trỏ đến đối tượng thuộc lớp chứa thành viên dữ liệu cần truy cập.

Ví dụ 4.12: Minh họa quá trình diễn dịch đệ quy khi đa năng hóa toán tử ->.

CT4_12.CPP1: #include <iostream.h> 2: #include <string.h>3: #include <stdlib.h>4:5: class String6: {7: public:8: char *St;9: String(char *S)10: {11: St=strdup(S);12: }13: ~String()14: {15: free(St);16: }17: };18:19: class StringPointer20: {21: private:22: String *M;23: public:24: StringPointer(String &S):M(&S)25: {26: }27: String * operator ->()28: {29: return M;30: }31: };32:33: int main()34: {35: StringPointer X(String("Chuc cac ban may man!"));36: cout<<X->St;37: return 0;38: }

Chúng ta chạy ví dụ 4.12, kết quả ở hình 4.17

Hình 4.17: Kết quả của ví dụ 4.12

Chúng ta có thể đa năng hóa toán tử gán (=) nhưng hàm toán tử của nó phải là hàm thành viên của lớp. Nếu toán tử gán có dạng a=b thì hàm toán tử có dạng a.operator(b).

Ví dụ 4.13: Đa năng hóa toán tử gán.

CT4_13.CPP1: #include <iostream.h> 2: #include <string.h>3:4: class String5: {6: private:7: char *St;8: int Len;9: public:10: String(char *S);11: ~String();12: char *GetStr();13: String & operator=(String &Obj);14: };15:16: String::String(char *S)17: {18: Len=strlen(S);19: St=new char[Len+1];20: strcpy(St,S);21: }22:23: String::~String()24: {25: delete []St;26: }27:28: char * String::GetStr()29: {30: return St;31: }32:33: String & String::operator=(String &Obj)34: {35: if (Len< Obj.Len)36: {37: delete [] St;38: St=new char[Obj.Len+1];39: }40: Len=Obj.Len;41: strcpy(St,Obj.St);42: return *this;43: }44:45: int main()46: {47: String S1("Hello"), S2("Chao");48: cout<<"S1="<<S1.GetStr()<<endl;49: cout<<"S2="<<S2.GetStr()<<endl;50: S2=S1;51: cout<<"S1="<<S1.GetStr()<<endl;52: cout<<"S2="<<S2.GetStr()<<endl;53: return 0;54: }

Chúng ta chạy ví dụ 4.13, kết quả ở hình 4.18

Hình 4.18: Kết quả của ví dụ 4.13

Phần lớn các chương trình xử lý thông tin sự đa dạng của các kiểu. Đôi khi tất cả các thao tác "dừng lại bên trong một kiểu". Chẳng hạn, một số nguyên với một số nguyên tạo thành một số nguyên (miễn là kết quả không quá lớn để được biểu diễn như một số nguyên). Nhưng thật cần thiết để chuyển đổi dữ liệu của một kiểu tới dữ liệu của kiểu khác. Điều này có thể xảy ra trong các phép gán, các kết quả tính toán, trong việc chuyển các giá trị tới hàm, và trong việc trả về trị từ hàm. Trình biên dịch biết làm thế nào để thực hiện các chuyển đổi nào đó trong số các kiểu có sẵn. Các lập trình viên có thể ép buộc các chuyển đổi trong số các kiểu có sẵn bởi ép kiểu.

Nhưng đối với các kiểu do người dùng định nghĩa thì trình biên dịch không thể tự động biết làm thế nào chuyển đổi trong số các kiểu dữ liệu do người dùng định nghĩa và các kiểu có sẵn. Lập trình viên phải chỉ rõ làm sao các chuyển đổi như vậy sẽ xuất hiện. Các chuyển đổi như thế có thể được thực hiện với constructor chuyển đổi.

Một toán tử chuyển đổi kiểu có thể được sử dụng để chuyển đổi một đối tượng của một lớp thành đối tượng của một lớp khác hoặc thành một đối tượng của một kiểu có sẵn. Toán tử chuyển đổi kiểu như thế phải là hàm thành viên không tĩnh và không là hàm friend. Prototype của hàm thành viên này có cú pháp:

operator <data type> ();

Ví dụ 4.14:  Toán tử chuyển đổi kiểu

CT4_14.CPP1: #include <iostream.h> 2: 3: class Number4: {5: private:6: float Data;7: public:8: Number(float F=0.0)9: {10: Data=F;11: }12: operator float()13: {14: return Data;15: }16: operator int()17: {18: return (int)Data;19: }20: };21:22: int main()23: {24: Number N1(9.7), N2(2.6);25: float X=(float)N1; //Gọi operator float()26: cout<<X<<endl;27: int Y=(int)N2; //Gọi operator int()28: cout<<Y<<endl;29: return 0;30: }

Chúng ta chạy ví dụ 4.14, kết quả ở hình 4.19

Hình 4.19: Kết quả của ví dụ 4.14

Các toán tử new và delete toàn cục có thể được đa năng hóa. Điều này cho phép các lập trình viên C++ có khả năng xây dựng một hệ thống cấp phát bộ nhớ theo ý người dùng, cói cùng giao tiếp như hệ thống cấp phát mặc định.

Có hai cách đa năng hóa các toán tử new và delete:

 Chúng ta có thể đa năng hóa một cách toàn cục nghĩa là thay thế hẳn các toán tử new và delete mặc định.

 Chúng ta năng hóa các toán tử new và delete với tư cách là hàm thành viên của lớp nếu muốn các toán tử new và delete áp dụng đối với lớp đó. Khi chúng ta dùng new và delete đối với lớp nào đó, trình biên dịch sẽ kiểm tra xem new và delete có được định nghĩa riêng cho lớp đó hay không; nếu không thì dùng new và delete toàn cục (có thể đã được đa năng hóa).

Hàm toán tử của toán tử new và delete có prototype như sau:

void * operator new(size_t size );

void operator delete(void * ptr );

Trong đó tham số kiểu size_t được trình biên dịch hiểu là kích thước của kiểu dữ liệu được trao cho toán tử new.

Đa năng hóa toán tử new và delete toàn cục:

Ví dụ 4.15: Đa năng hóa toán tử new và delete toàn cục đồng thời chứng tỏ rằng toán tử new và delete do đa năng hóa thay thế toán tử new và delete mặc định.

CT4_15.CPP1: #include <iostream.h> 2: #include <stdlib.h>3:4: class Point5: {6: private:7: int X, Y;8: public:9: Point(int A=0,int B=0)10: {11: X=A;12: Y=B;13: cout<<"Constructor!"<<endl;14: }15: ~Point()16: {17: cout<<"Destructor!"<<endl;18: }19: void Print() const20: {21: cout<<"X="<<X<<","<<"Y="<<Y<<endl;22: }23: };24:25: void * operator new(size_t Size)26: {27: return malloc(Size);28: }29:30: void operator delete(void *Ptr)31: {32: free(Ptr);33: }34:35: int main()36: {37: Point *P1,*P2;38: P1= new Point(10,20);39: if (P1==NULL)40: {41: cout<<"Out of memory!"<<endl;42: return 1;43: }44: P2= new Point(-10,-20);45: if (P2==NULL)46: {47: cout<<"Out of memory!"<<endl;48: return 1;49: }50: int *X=new int;51: if (X==NULL)52: {53: cout<<"Out of memory!"<<endl;54: return 1;55: }56: *X=10;57: cout<<"X="<<*X<<endl;58: cout<<"Point 1:";59: P1->Print();60: cout<<"Point 2:";61: P2->Print();62: delete P1;63: delete P2;64: delete X;65: return 0;66: }

Chúng ta chạy ví dụ 4.15, kết quả ở hình 4.20

Hình 4.20: Kết quả của ví dụ 4.15

Đa năng hóa toán tử new và delete cho một lớp:

Nếu muốn toán tử new và delete có tính chất đặc biệt chỉ khi áp dụng cho đối tượng của lớp nào đó, chúng ta có thể đa năng hóa toán tử new và delete với tư cách là hàm thành viên của lớp đó. Việc này không khác lắm so với cách đa năng hóa toán tử new và delete một cách toàn cục.

Ví dụ 4.16: Đa năng hóa toán tử new và delete cho một lớp.

CT4_16.CPP1: #include <iostream.h> 2: #include <stdlib.h>3: class Number4: {5: private:6: int Data;7: public:8: Number(int X=0)9: {10: Data=X;11: }12:13: void * operator new(size_t Size)14: {15: cout<<"Toan tu new cua lop!"<<endl;16: return ::new unsigned char[Size];17: }18:19: void operator delete(void *Ptr)20: {21: cout<<"Toan tu delete cua lop!"<<endl;22: ::delete Ptr;23: }24:25: void Print() const26: {27: cout<<"Data:"<<Data<<endl;28: }29:30: };31:32: int main()33: {34: Number *N;35: N= new Number(10);36: if (N==NULL)37: {38: cout<<"Out of memory!"<<endl;39: return 1;40: }41: int *X=new int;42: if (X==NULL)43: {44: cout<<"Out of memory!"<<endl;45: return 1;46: }47: *X=10;48: cout<<"X="<<*X<<endl;49: N->Print();50: delete N;51: delete X;52: return 0;53: }

Chúng ta chạy ví dụ 4.16, kết quả ở hình 4.21

Hình 4.21: Kết quả của ví dụ 4.16