Các mở rộng của C++ - Các giá trị tham số mặc định
Một trong các đặc tính nổi bật nhất của C++ là khả năng định nghĩa các giá trị tham số mặc định cho các hàm. Bình thường khi gọi một hàm, chúng ta cần gởi một giá trị cho mỗi tham số đã được định nghĩa trong hàm đó, chẳng hạn chúng ta có đoạn ...
Một trong các đặc tính nổi bật nhất của C++ là khả năng định nghĩa các giá trị tham số mặc định cho các hàm. Bình thường khi gọi một hàm, chúng ta cần gởi một giá trị cho mỗi tham số đã được định nghĩa trong hàm đó, chẳng hạn chúng ta có đoạn chương trình sau:
void MyDelay(long Loops); //prototype
………………………………..
void MyDelay(long Loops)
{
for(int I = 0; I < Loops; ++I)
;
}
Mỗi khi hàm MyDelay() được gọi chúng ta phải gởi cho nó một giá trị cho tham số Loops. Tuy nhiên, trong nhiều trường hợp chúng ta có thể nhận thấy rằng chúng ta luôn luôn gọi hàm MyDelay() với cùng một giá trị Loops nào đó. Muốn vậy chúng ta sẽ dùng giá trị mặc định cho tham số Loops, giả sử chúng ta muốn giá trị mặc định cho tham số Loops là 1000. Khi đó đoạn mã trên được viết lại như sau :
void MyDelay(long Loops = 1000); //prototype
………………………………..
void MyDelay(long Loops)
{
for(int I = 0; I < Loops; ++I)
;
}
Mỗi khi gọi hàm MyDelay() mà không gởi một tham số tương ứng thì trình biên dịch sẽ tự động gán cho tham số Loops giá trị 1000.
MyDelay(); // Loops có giá trị là 1000
MyDelay(5000); // Loops có giá trị là 5000
Giá trị mặc định cho tham số có thể là một hằng, một hàm, một biến hay một biểu thức.
Ví dụ 2.11: Tính thể tích của hình hộp
|
||
 CT2_11.CPP 1: #include <iostream.h>2: int BoxVolume(int Length = 1, int Width = 1, int Height = 1);3:4: int main()5: {6: cout << "The tich hinh hop mac dinh: "7: << BoxVolume() << endl << endl 8: << "The tich hinh hop voi chieu dai=10,do rong=1,chieu cao=1:"9: << BoxVolume(10) << endl << endl10: << "The tich hinh hop voi chieu dai=10,do rong=5,chieu cao=1:"11: << BoxVolume(10, 5) << endl << endl12: << "The tich hinh hop voi chieu dai=10,do rong=5,chieu cao=2:"13: << BoxVolume(10, 5, 2)<< endl;14: return 0;15: }16: //Tính thể tích của hình hộp17: int BoxVolume(int Length, int Width, int Height)18: {19: return Length * Width * Height;20: }  |
||
|
||
|
Chúng ta chạy ví dụ 2.11, kết quả ở hình 2.13
Hình 2.13: Kết quả của ví dụ 2.11
Chú ý:
Các tham số có giá trị mặc định chỉ được cho trong prototype của hàm và không được lặp lại trong định nghĩa hàm (Vì trình biên dịch sẽ dùng các thông tin trong prototype chứ không phải trong định nghĩa hàm để tạo một lệnh gọi).
Một hàm có thể có nhiều tham số có giá trị mặc định. Các tham số có giá trị mặc định cần phải được nhóm lại vào các tham số cuối cùng (hoặc duy nhất) của một hàm. Khi gọi hàm có nhiều tham số có giá trị mặc định, chúng ta chỉ có thể bỏ bớt các tham số theo thứ tự từ phải sang trái và phải bỏ liên tiếp nhau, chẳng hạn chúng ta có đoạn chương trình như sau:
int MyFunc(int a= 1, int b , int c = 3, int d = 4); //prototype sai!!!
int MyFunc(int a, int b = 2 , int c = 3, int d = 4); //prototype đúng
………………………..
MyFunc(); // Lỗi do tham số a không có giá trị mặc định
MyFunc(1);// OK, các tham số b, c và d lấy giá trị mặc định
MyFunc(5, 7); // OK, các tham số c và d lấy giá trị mặc định
MyFunc(5, 7, , 8); // Lỗi do các tham số bị bỏ phải liên tiếp nhau
Trong C, hàm nhận tham số là con trỏ đòi hỏi chúng ta phải thận trọng khi gọi hàm. Chúng ta cần viết hàm hoán đổi giá trị giữa hai số như sau:
void Swap(int *X, int *Y);
{
int Temp = *X;
*X = *Y;
*Y = *Temp;
}
Để hoán đổi giá trị hai biến A và B thì chúng ta gọi hàm như sau:
Swap(&A, &B);
Rõ ràng cách viết này không được thuận tiện lắm. Trong trường hợp này, C++ đưa ra một kiểu biến rất đặc biệt gọi là biến tham chiếu (reference variable). Một biến tham chiếu giống như là một bí danh của biến khác. Biến tham chiếu sẽ làm cho các hàm có thay đổi nội dung các tham số của nó được viết một cách thanh thoát hơn. Khi đó hàm Swap() được viết như sau:
void Swap(int &X, int &Y);
{
int Temp = X;
X = Y;
Y = Temp ;
}
Chúng ta gọi hàm như sau :
Swap(A, B);
Với cách gọi hàm này, C++ tự gởi địa chỉ của A và B làm tham số cho hàm Swap(). Cách dùng biến tham chiếu cho tham số của C++ tương tự như các tham số được khai báo là Var trong ngôn ngữ Pascal. Tham số này được gọi là tham số kiểu tham chiếu (reference parameter). Như vậy biến tham chiếu có cú pháp như sau :
data_type&variable_name;
Trong đó:
data_type: Kiểu dữ liệu của biến.
variable_name: Tên của biến
Khi dùng biến tham chiếu cho tham số chỉ có địa chỉ của nó được gởi đi chứ không phải là toàn bộ cấu trúc hay đối tượng đó như hình 2.14, điều này rất hữu dụng khi chúng ta gởi cấu trúc và đối tượng lớn cho một hàm.
Hình 2.14: Một tham số kiểu tham chiếu nhận một tham chiếu tới một biến được chuyển cho tham số của hàm.
Ví dụ 2.12: Chương trình hoán đổi giá trị của hai biến.
|
||
 CT2_12.CPP 1: #include <iostream.h>2: //prototype3 void Swap(int &X,int &Y);4: 5: int main()6: {7: int X = 10, Y = 5;8: cout<<"Truoc khi hoan doi: X = "<<X<<",Y = "<<Y<<endl;9: Swap(X,Y);10: cout<<"Sau khi hoan doi: X = "<<X<<",Y = "<<Y<<endl;11: return 0;12: }13:14: void Swap(int &X,int &Y)15: {16: int Temp=X;17: X=Y;18: Y=Temp;19: }  |
||
|
||
|
Chúng ta chạy ví dụ 2.12, kết quả ở hình 2.15
Hình 2.15: Kết quả của ví dụ 2.12
Đôi khi chúng ta muốn gởi một tham số nào đó bằng biến tham chiếu cho hiệu quả, mặc dù chúng ta không muốn giá trị của nó bị thay đổi thì chúng ta dùng thêm từ khóa const như sau :
int MyFunc(const int & X);
Hàm MyFunc() sẽ chấp nhận một tham số X gởi bằng tham chiếu nhưng const xác định rằng X không thể bị thay đổi.
Biến tham chiếu có thể sử dụng như một bí danh của biến khác (bí danh đơn giản như một tên khác của biến gốc), chẳng hạn như đoạn mã sau :
int Count = 1;
int & Ref = Count; //Tạo biến Ref như là một bí danh của biến Count
++Ref; //Tăng biến Count lên 1 (sử dụng bí danh của biến Count)
Các biến tham chiếu phải được khởi động trong phần khai báo của chúng và chúng ta không thể gán lại một bí danh của biến khác cho chúng. Chẳng hạn đoạn mã sau là sai:
int X = 1;
int & Y; //Lỗi: Y phải được khởi động.
Khi một tham chiếu được khai báo như một bí danh của biến khác, mọi thao tác thực hiện trên bí danh chính là thực hiện trên biến gốc của nó. Chúng ta có thể lấy địa chỉ của biến tham chiếu và có thể so sánh các biến tham chiếu với nhau (phải tương thích về kiểu tham chiếu).
Ví dụ 2.13: Mọi thao tác trên trên bí danh chính là thao tác trên biến gốc của nó.
|
||
 CT2_13.CPP 1: #include <iostream.h>2: int main()3: {4: int X = 3;5: int &Y = X; //Y la bí danh của X6: int Z = 100;7:8: cout<<"X="<<X<<endl<<"Y="<<Y<<endl;9: Y *= 3;10: cout<<"X="<<X<<endl<<"Y="<<Y<<endl;11: Y = Z;12: cout<<"X="<<X<<endl<<"Y="<<Y<<endl;13: return 0;14: }  |
||
|
||
|
Chúng ta chạy ví dụ 2.13, kết quả ở hình 2.16
Hình 2.16: Kết quả của ví dụ 2.13
Ví dụ 2.14: Lấy địa chỉ của biến tham chiếu
|
||
 CT2_14.CPP 1: #include <iostream.h>2: int main()3: {4: int X = 3;5: int &Y = X; //Y la bí danh của X6:7: cout<<"Dia chi cua X = "<<&X<<endl;8: cout<<"Dia chi cua bi danh Y= "<<&Y<<endl;9: return 0;10: }  |
||
|
||
|
Chúng ta chạy ví dụ 2.14, kết quả ở hình 2.17
Hình 2.17: Kết quả của ví dụ 2.14
Chúng ta có thể tạo ra biến tham chiếu với việc khởi động là một hằng, chẳng hạn như đoạn mã sau :
int & Ref = 45;
Trong trường hợp này, trình biên dịch tạo ra một biến tạm thời chứa trị hằng và biến tham chiếu chính là bí danh của biến tạm thời này. Điều này gọi là tham chiếu độc lập (independent reference).
Các hàm có thể trả về một tham chiếu, nhưng điều này rất nguy hiểm. Khi hàm trả về một tham chiếu tới một biến cục bộ của hàm thì biến này phải được khai báo là static, ngược lại tham chiếu tới nó thì khi hàm kết thúc biến cục bộ này sẽ bị bỏ qua. Chẳng hạn như đoạn chương trình sau:
int & MyFunc()
{
static int X = 200; //Nếu không khai báo là static thì điều này rất nguy hiểm.
return X;
}
Khi một hàm trả về một tham chiếu, chúng ta có thể gọi hàm ở phái bên trái của một phép gán.
Ví dụ 2.15:
|
||
 CT2_15.CPP 1: #include <iostream.h>2: 3: int X = 4;4: //prototype5: int & MyFunc();6: 7: int main()8: {9: cout<<"X="<<X<<endl;10: cout<<"X="<<MyFunc()<<endl;11: MyFunc() = 20; //Nghĩa là X = 2012: cout<<"X="<<X<<endl;13: return 0;14: }15:16: int & MyFunc()17: {18: return X;19: }  |
||
|
||
|
Chúng ta chạy ví dụ 2.15, kết quả ở hình 2.18
Hình 2.18: Kết quả của ví dụ 2.15
Chú ý:
Mặc dù biến tham chiếu trông giống như là biến con trỏ nhưng chúng không thể là biến con trỏ do đó chúng không thể được dùng cấp phát động.
Chúng ta không thể khai báo một biến tham chiếu chỉ đến biến tham chiếu hoặc biến con trỏ chỉ đến biến tham chiếu. Tuy nhiên chúng ta có thể khai báo một biến tham chiếu về biến con trỏ như đoạn mã sau:
int X;
int *P = &X;
int * & Ref = P;
Với ngôn ngữ C++, chúng ta có thể đa năng hóa các hàm và các toán tử (operator). Đa năng hóa là phương pháp cung cấp nhiều hơn một định nghĩa cho tên hàm đã cho trong cùng một phạm vi. Trình biên dịch sẽ lựa chọn phiên bản thích hợp của hàm hay toán tử dựa trên các tham số mà nó được gọi.
Đa năng hóa các hàm (Functions overloading) :
Trong ngôn ngữ C cũng như mọi ngôn ngữ máy tính khác, mỗi hàm đều phải có một tên phân biệt. Đôi khi đây là một điều phiều toái. Chẳng hạn như trong ngôn ngữ C, có rất nhiều hàm trả về trị tuyệt đối của một tham số là số, vì cần thiết phải có tên phân biệt nên C phải có hàm riêng cho mỗi kiểu dữ liệu số, do vậy chúng ta có tới ba hàm khác nhau để trả về trị tuyệt đối của một tham số :
int abs(int i);
long labs(long l);
double fabs(double d);
Tất cả các hàm này đều cùng thực hiện một chứa năng nên chúng ta thấy điều này nghịch lý khi phải có ba tên khác nhau. C++ giải quyết điều này bằng cách cho phép chúng ta tạo ra các hàm khác nhau có cùng một tên. Đây chính là đa năng hóa hàm. Do đó trong C++ chúng ta có thể định nghĩa lại các hàm trả về trị tuyệt đối để thay thế các hàm trên như sau :
int abs(int i);
long abs(long l);
double abs(double d);
Ví dụ 2.16:
|
||
 CT2_16.CPP 1: #include <iostream.h>2: #include <math.h>3: 4: int MyAbs(int X);5: long MyAbs(long X);6: double MyAbs(double X);7:8: int main()9: {10: int X = -7;11: long Y = 200000l;12: double Z = -35.678;13: cout<<"Tri tuyet doi cua so nguyen (int) "<<X<<" la "14: <<MyAbs(X)<<endl;15: cout<<"Tri tuyet doi cua so nguyen (long int) "<<Y<<" la "16: <<MyAbs(Y)<<endl;17: cout<<"Tri tuyet doi cua so thuc "<<Z<<" la "18: <<MyAbs(Z)<<endl;19: return 0;20: }21:22: int MyAbs(int X)23: {24: return abs(X);25: }26:27: long MyAbs(long X)28: {29: return labs(X);30: }31:32: double MyAbs(double X)33: {34: return fabs(X);35: }  |
||
|
||
|
Chúng ta chạy ví dụ 2.16 , kết quả ở hình 2.19
Hình 2.19: Kết quả của ví dụ 2.16
Trình biên dịch dựa vào sự khác nhau về số các tham số, kiểu của các tham số để có thể xác định chính xác phiên bản cài đặt nào của hàm MyAbs() thích hợp với một lệnh gọi hàm được cho, chẳng hạn như:
MyAbs(-7); //Gọi hàm int MyAbs(int)
MyAbs(-7l); //Gọi hàm long MyAbs(long)
MyAbs(-7.5); //Gọi hàm double MyAbs(double)
Quá trình tìm được hàm được đa năng hóa cũng là quá trình được dùng để giải quyết các trường hợp nhập nhằng của C++. Chẳng hạn như nếu tìm thấy một phiên bản định nghĩa nào đó của một hàm được đa năng hóa mà có kiểu dữ liệu các tham số của nó trùng với kiểu các tham số đã gởi tới trong lệnh gọi hàm thì phiên bản hàm đó sẽ được gọi. Nếu không trình biên dịch C++ sẽ gọi đến phiên bản nào cho phép chuyển kiểu dễ dàng nhất.
MyAbs(‘c’); //Gọi int MyAbs(int)
MyAbs(2.34f); //Gọi double MyAbs(double)
Các phép chuyển kiểu có sẵn sẽ được ưu tiên hơn các phép chuyển kiểu mà chúng ta tạo ra (chúng ta sẽ xem xét các phép chuyển kiểu tự tạo ở chương 3).
Chúng ta cũng có thể lấy địa chỉ của một hàm đã được đa năng hóa sao cho bằng một cách nào đó chúng ta có thể làm cho trình biên dịch C++ biết được chúng ta cần lấy địa chỉ của phiên bản hàm nào có trong định nghĩa. Chẳng hạn như:
int (*pf1)(int);
long (*pf2)(long);
int (*pf3)(double);
pf1 = MyAbs; //Trỏ đến hàm int MyAbs(int)
pf2 = MyAbs; //Trỏ đến hàm long MyAbs(long)
pf3 = MyAbs; //Lỗi!!! (không có phiên bản hàm nào để đối sánh)
Các giới hạn của việc đa năng hóa các hàm:
Bất kỳ hai hàm nào trong tập các hàm đã đa năng phải có các tham số khác nhau.
Các hàm đa năng hóa với danh sách các tham số cùng kiểu chỉ dựa trên kiểu trả về của hàm thì trình biên dịch báo lỗi. Chẳng hạn như, các khai báo sau là không hợp lệ:
void Print(int X);
int Print(int X);
Không có cách nào để trình biên dịch nhận biết phiên bản nào được gọi nếu giá trị trả về bị bỏ qua. Như vậy các phiên bản trong việc đa năng hóa phải có sự khác nhau ít nhất về kiểu hoặc số tham số mà chúng nhận được.
Các khai báo bằng lệnh typedef không định nghĩa kiểu mới. Chúng chỉ thay đổi tên gọi của kiểu đã có. Chúng không ảnh hưởng tới cơ chế đa năng hóa hàm. Chúng ta hãy xem xét đoạn mã sau:
typedef char * PSTR;
void Print(char * Mess);
void Print(PSTR Mess);
Hai hàm này có cùng danh sách các tham số, do đó đoạn mã trên sẽ phát sinh lỗi.
Đối với kiểu mảng và con trỏ được xem như đồng nhất đối với sự phân biệt khác nhau giữa các phiên bản hàm trong việc đa năng hóa hàm. Chẳng hạn như đoạn mã sau se phát sinh lỗi:
void Print(char * Mess);
void Print(char Mess[]);
Tuy nhiên, đối với mảng nhiều chiều thì có sự phân biệt giữa các phiên bản hàm trong việc đa năng hóa hàm, chẳng hạn như đoạn mã sau hợp lệ:
void Print(char Mess[]);
void Print(char Mess[][7]);
void Print(char Mess[][9][42]);
const và các con trỏ (hay các tham chiếu) có thể dùng để phân biệt, chẳng hạn như đoạn mã sau hợp lệ:
void Print(char *Mess);
void Print(const char *Mess);
Đa năng hóa các toán tử (Operators overloading) :
Trong ngôn ngữ C, khi chúng ta tự tạo ra một kiểu dữ liệu mới, chúng ta thực hiện các thao tác liên quan đến kiểu dữ liệu đó thường thông qua các hàm, điều này trở nên không thoải mái.
Ví dụ 2.17: Chương trình cài đặt các phép toán cộng và trừ số phức
|
||
 CT2_17.CPP 1: #include <stdio.h>2: /* Định nghĩa số phức */3: typedef struct4: {5: double Real;6: double Imaginary;7: }Complex;8:9: Complex SetComplex(double R,double I);10: Complex AddComplex(Complex C1,Complex C2);11: Complex SubComplex(Complex C1,Complex C2);12: void DisplayComplex(Complex C);13:14: int main(void)15: {16: Complex C1,C2,C3,C4;17:18: C1 = SetComplex(1.0,2.0);19: C2 = SetComplex(-3.0,4.0);20: printf("
So phuc thu nhat:");21: DisplayComplex(C1);22: printf("
So phuc thu hai:");23: DisplayComplex(C2);24: C3 = AddComplex(C1,C2); //Hơi bất tiện !!! 25: C4 = SubComplex(C1,C2);26: printf("
Tong hai so phuc nay:");27: DisplayComplex(C3);28: printf("
Hieu hai so phuc nay:");29: DisplayComplex(C4);30: return 0;31: }32:33: /* Đặt giá trị cho một số phức */34: Complex SetComplex(double R,double I)35: {36: Complex Tmp;37:38: Tmp.Real = R;39: Tmp.Imaginary = I;40: return Tmp;41: }42: /* Cộng hai số phức */43: Complex AddComplex(Complex C1,Complex C2)44: {45: Complex Tmp;46:47: Tmp.Real = C1.Real+C2.Real;48: Tmp.Imaginary = C1.Imaginary+C2.Imaginary;49: return Tmp;50: }51:52: /* Trừ hai số phức */53: Complex SubComplex(Complex C1,Complex C2)54: {55: Complex Tmp;56:57: Tmp.Real = C1.Real-C2.Real;58: Tmp.Imaginary = C1.Imaginary-C2.Imaginary;59: return Tmp;60: }61:62: /* Hiển thị số phức */63: void DisplayComplex(Complex C)64: {65: printf("(%.1lf,%.1lf)",C.Real,C.Imaginary);66: }  |
||
|
||
|
Chúng ta chạy ví dụ 2.17, kết quả ở hình 2.20
Hình 2.20: Kết quả của ví dụ 2.17
Trong chương trình ở ví dụ 2.17, chúng ta nhận thấy với các hàm vừa cài đặt dùng để cộng và trừ hai số phức 1+2i và –3+4i; người lập trình hoàn toàn không thoải mái khi sử dụng bởi vì thực chất thao tác cộng và trừ là các toán tử chứ không phải là hàm. Để khắc phục yếu điểm này, trong C++ cho phép chúng ta có thể định nghĩa lại chức năng của các toán tử đã có sẵn một cách tiện lợi và tự nhiên hơn rất nhiều. Điều này gọi là đa năng hóa toán tử. Khi đó chương trình ở ví dụ 2.17 được viết như sau:
Ví dụ 2.18:
|
||
 CT2_18.CPP 1: #include <iostream.h>2: // Định nghĩa số phức3: typedef struct4: {5: double Real;6: double Imaginary;7: }Complex;8:9: Complex SetComplex(double R,double I);10: void DisplayComplex(Complex C);11: Complex operator + (Complex C1,Complex C2);12: Complex operator - (Complex C1,Complex C2);13:14: int main(void)15: {16: Complex C1,C2,C3,C4;17:18: C1 = SetComplex(1.0,2.0);19: C2 = SetComplex(-3.0,4.0);20: cout<<"
So phuc thu nhat:";21: DisplayComplex(C1);22: cout<<"
So phuc thu hai:";23: DisplayComplex(C2);24: C3 = C1 + C2;25: C4 = C1 - C2;26: cout<<"
Tong hai so phuc nay:";27: DisplayComplex(C3);28: cout<<"
Hieu hai so phuc nay:";29: DisplayComplex(C4);30: return 0;31: }32:33: //Đặt giá trị cho một số phức34: Complex SetComplex(double R,double I)35: {36: Complex Tmp;37:38: Tmp.Real = R;39: Tmp.Imaginary = I;40: return Tmp;41: }42:43: //Cộng hai số phức44: Complex operator + (Complex C1,Complex C2)45: {46: Complex Tmp;47:48: Tmp.Real = C1.Real+C2.Real;49: Tmp.Imaginary = C1.Imaginary+C2.Imaginary;50: return Tmp;51: }52:53: //Trừ hai số phức54: Complex operator - (Complex C1,Complex C2)55: {56: Complex Tmp;57:58: Tmp.Real = C1.Real-C2.Real;59: Tmp.Imaginary = C1.Imaginary-C2.Imaginary;60: return Tmp;61: }62:63: //Hiển thị số phức64: void DisplayComplex(Complex C)65: {66: cout<<"("<<C.Real<<","<<C.Imaginary<<")";67: }   |
||
|
||
|
Chúng ta chạy ví dụ 2.18, kết quả ở hình 2.21
Hình 2.21: Kết quả của ví dụ 2.18
Như vậy trong C++, các phép toán trên các giá trị kiểu số phức được thực hiện bằng các toán tử toán học chuẩn chứ không phải bằng các tên hàm như trong C. Chẳng hạn chúng ta có lệnh sau:
C4 = AddComplex(C3, SubComplex(C1,C2));
thì ở trong C++, chúng ta có lệnh tương ứng như sau:
C4 = C3 + C1 - C2;
Chúng ta nhận thấy rằng cả hai lệnh đều cho cùng kết quả nhưng lệnh của C++ thì dễ hiểu hơn. C++ làm được điều này bằng cách tạo ra các hàm định nghĩa cách thực hiện của một toán tử cho các kiểu dữ liệu tự định nghĩa. Một hàm định nghĩa một toán tử có cú pháp sau:
data_type operator operator_symbol ( parameters )
{
………………………………
}
Trong đó:
data_type: Kiểu trả về.
operator_symbol: Ký hiệu của toán tử.
parameters: Các tham số (nếu có).
Trong chương trình ví dụ 2.18, toán tử + là toán tử gồm hai toán hạng (gọi là toán tử hai ngôi; toán tử một ngôi là toán tử chỉ có một toán hạng) và trình biên dịch biết tham số đầu tiên là ở bên trái toán tử, còn tham số thứ hai thì ở bên phải của toán tử. Trong trường hợp lập trình viên quen thuộc với cách gọi hàm, C++ vẫn cho phép bằng cách viết như sau:
C3 = operator + (C1,C2);
C4 = operator - (C1,C2);
Các toán tử được đa năng hóa sẽ được lựa chọn bởi trình biên dịch cũng theo cách thức tương tự như việc chọn lựa giữa các hàm được đa năng hóa là khi gặp một toán tử làm việc trên các kiểu không phải là kiểu có sẵn, trình biên dịch sẽ tìm một hàm định nghĩa của toán tử nào đó có các tham số đối sánh với các toán hạng để dùng. Chúng ta sẽ tìm hiểu kỹ về việc đa năng hóa các toán tử trong chương 4.
Các giới hạn của đa năng hóa toán tử:
Chúng ta không thể định nghĩa các toán tử mới.
Hầu hết các toán tử của C++ đều có thể được đa năng hóa. Các toán tử sau không được đa năng hóa là :
| Toán tử | Ý nghĩa |
| :: | Toán tử định phạm vi. |
| .* | Truy cập đến con trỏ là trường của struct hay thành viên của class. |
| . | Truy cập đến trường của struct hay thành viên của class. |
| ?: | Toán tử điều kiện |
| sizeof |
và chúng ta cũng không thể đa năng hóa bất kỳ ký hiệu tiền xử lý nào.
Chúng ta không thể thay đổi thứ tự ưu tiên của một toán tử hay không thể thay đổi số các toán hạng của nó.
Chúng ta không thể thay đổi ý nghĩa của các toán tử khi áp dụng cho các kiểu có sẵn.
Đa năng hóa các toán tử không thể có các tham số có giá trị mặc định.
Các toán tử có thể đa năng hoá:
| + | - | * | / | % | ^ |
| ! | = | < | > | += | -= |
| ^= | &= | |= | << | >> | <<= |
| <= | >= | && | || | ++ | -- |
| () | [] | new | delete | & | | |
| ~ | *= | /= | %= | >>= | == |
| != | , | -> | ->* |
Các toán tử được phân loại như sau :
Các toán tử một ngôi : * & ~ ! ++ -- sizeof (data_type)
Các toán tử này được định nghĩa chỉ có một tham số và phải trả về một giá trị cùng kiểu với tham số của chúng. Đối với toán tử sizeof phải trả về một giá trị kiểu size_t (định nghĩa trong stddef.h)
Toán tử (data_type) được dùng để chuyển đổi kiểu, nó phải trả về một giá trị có kiểu là data_type.
Các toán tử hai ngôi:
* / % + - >> << > <
>= <= == != & | ^ && ||
Các toán tử này được định nghĩa có hai tham số.
Các phép gán: = += -= *= /= %= >>= <<= ^= |=
Các toán tử gán được định nghĩa chỉ có một tham số. Không có giới hạn về kiểu của tham số và kiểu trả về của phép gán.
Toán tử lấy thành viên : ->
Toán tử lấy phần tử theo chỉ số: []
Toán tử gọi hàm: ()
