Hàm và lớp template trong
Lập trình hướng đối tượng
Bởi:
unknown
Trong phần này, chúng ta tìm hiểu về một trong các đặc tính còn lại của C++, đó là
template (khuôn mẫu). Các template cho phép chúng ta để định rõ, với một đoạn mã
đơn giản, một toàn bộ phạm vi của các hàm có liên quan (đa năng hóa)–gọi là các hàm
template-hoặc một toàn bộ phạm vi của các lớp có liên quan-gọi là lớp template.
Chúng ta có thể viết một hàm template đơn giản cho việc sắp xếp một mảng và C++ tự
động phát sinh các hàm template riêng biệt mà sẽ sắp xếp một mảng int, sắp xếp một
mảng float, …
Chúng ta có thể viết một lớp template cho lớp stack và sau đó C++ tự động phát sinh
các lớp template riêng biệt như lớp stack của int, lớp stack của float,…
Các hàm template
Các hàm đa năng hóa bình thường được sử dụng để thực hiện các thao tác tương tự trên
các kiểu khác nhau của dữ liệu. Nếu các thao tác đồng nhất cho mỗi kiểu, điều này có
thể thực hiện mạch lạc và thuận tiện hơn sử dụng các hàm template. Lập trình viên viết
định nghĩa hàm template đơn giản. Dựa vào các kiểu tham số cung cấp trong lời gọi hàm
này, trình biên dịch tự động phát sinh các hàm mã đối tượng riêng biệt để xử lý mỗi
kiểu của lời gọi thích hợp. Trong C, điều này có thể được thực hiện bằng cách sử dụng
các macro tạo với tiền xử lý #define. Tuy nhiên, các macro biểu thị khả năng đối với
các hiệu ứng lề nghiêm trọng và không cho phép trình biên dịch thực hiện việc kiểm tra
kiểu. Các hàm template cung cấp một giải pháp mạch lạc giống như các macro, nhưng
cho phép kiểm tra kiểu đầy đủ. Chẳng hạn, chúng ta muốn viết hàm lấy trị tuyệt đối của
một số, chúng ta có thể viết nhiều dạng khác nhau như sau:
int MyAbs(int X) { return X>=0?X:-X; } long MyAbs(long X)
{ return X>=0?X:-X; } double MyAbs(double X) { return
X>=0?X:-X; }
Hàm và lớp template trong Lập trình hướng đối tượng
1/6
Tuy nhiên với các hàm này chúng ta vẫn chưa có giải pháp tốt, mang tính tổng quát nhất
như hàm có tham số kiểu int nhưng giá trị trả về là double và ngược lại.
Tất cả các hàm template định nghĩa bắt đầu với từ khóa template theo sau một danh
sách các tham số hình thức với hàm template vây quanh trong các ngoặc nhọn (<và >);
Mỗi tham số hình thức phải được đặt trước bởi từ khóa class như:
template <class T>
hoặc template <class T1, class T2,…>
Các tham số hình thức của một định nghĩa template được sử dụng để mô tả các kiểu của
các tham số cho hàm, để mô tả kiểu trả về của hàm, và để khai báo các biến bên trong
hàm. Phần định nghĩa hàm theo sau và được định nghĩa giống như bất kỳ hàm nào. Chú
ý từ khóa class sử dụng để mô tả các kiểu tham số của hàm template thực sự nghĩa là
"kiểu có sẵn và kiểu người dùng định nghĩa bất kỳ".
Khi đó, hàm trị tuyệt đối ở trên viết theo hàm template:
template <class T> T MyAbs(T x) { return (x>=0)?x:-x; }
Hàm template MyAbs() khai báo một tham số hình thức Tcho kiểu của một số. Tđược
tham khảo như một tham số kiểu. Khi trình biên dịch phát hiện ra một lời gọi hàm
MyAbs() trong chương trình, kiểu của tham số thứ nhất của hàm MyAbs() được thay thế
cho Tthông qua định nghĩa template, và C++ tạo một hàm template đầy đủ để trả về
trị tuyệt đối của một số của kiểu dữ liệu đã cho. Sau đó, hàm mới tạo được biên dịch.
Chẳng hạn:
cout<<MyAbs(-2)<<endl; cout<<MyAbs(3.5)<<endl;
Trong lần gọi thứ nhất, hàm MyAbs() có tham số thực là int nên trình biên dịch tạo
ra hàm int MyAbs(int)theo dạng của hàm template, lần thứ hai sẽ tạo ra hàm float
MyAbs(float).
Mỗi tham số hình thức trong một định nghĩa hàm template phải xuất hiện trong danh
sách tham số của hàm tối thiểu một lần. Tên của tham số hình thức chỉ có thể sử dụng
một lần trong danh sách tham số của phần đầu template.
Ví dụ 9.1: Sử dụng hàm template để in các giá trị của một mảng có kiểu bất kỳ.
1: //Chương trình 9.1 2: #include <iostream.h> 3: 4:
template<class T> 5: void PrintArray(T *Array, const int
Count) 6: { 7: for (int I = 0; I < Count; I++) 8: cout <<
Hàm và lớp template trong Lập trình hướng đối tượng
2/6
Array[I] << " "; 9: 10: cout << endl; 11: } 12: 13: int
main() 14: { 15: const int Count1 = 5, Count2 = 7, Count3
= 6; 16: int A1[Count1] = {1, 2, 3, 4, 5}; 17: float
A2[Count2] = {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7}; 18: char
A3[Count3] = "HELLO"; 19: cout << "Array A1 contains:" <<
endl; 20: PrintArray(A1, Count1); //Hàm template kiểu int
21: cout << "Array A2 contains:" << endl; 22:
PrintArray(A2, Count2); //Hàm template kiểu float 23: cout
<< "Array A3 contains:" << endl; 24: PrintArray(A3,
Count3); //Hàm template kiểu char 25: return 0; 26: }
Chúng ta chạy ví dụ 9.1, kết quả ở hình 9.1
Kết quả của ví dụ 9.1 (Hình 9.1)
Ví dụ 9.2:Hàm template có thể có nhiều tham số.
1: //Chương trình 9.2 2: #include <iostream.h> 3: 4:
template<class T> 5: T Max(T a, T b) 6: { 7: return
(a>b)?a:b; 8: } 9: 10: int main() 11: { 12: float A,B; 13:
cout<<"Enter first number:"; 14: cin>>A; 15: cout<<"Enter
second number:"; 16: cin>>B; 17:
cout<<"Maximum:"<<Max(A,B); 18: return 0; 19: }
Chúng ta chạy ví dụ 9.2, kết quả ở hình 9.2
Kết quả của ví dụ 9.2 (Hình 9.2)
Một hàm template có thể được đa năng hóa theo vài cách. Chúng ta có thể cung cấp
các hàm template khác mà mô tả cùng tên hàm nhưng các tham số hàm khác nhau. Một
hàm template cũng có thể được đa năng hóa bởi cung cấp hàm non-template với cùng
tên hàm nhưng các tham số hàm khác nhau. Trình biên dịch thực hiện một xử lý so sánh
Hàm và lớp template trong Lập trình hướng đối tượng
3/6
để xác định hàm gọi khi một hàm được gọi. Đầu tiên trình biên dịch cố gắng tìm và sử
dụng một đối sánh chính xác mà các tên hàm và các kiểu tham số đối sánh chính xác.
Nếu điều này thất bại, trình biên dịch kiểm tra nếu một hàm template đã có mà có thể
phát sinh một hàm template với một đối sánh chính xác của tên hàm và các kiểu tham
số. Nếu một hàm template như thế được tìm thấy, trình biên dịch phát sinh và sử dụng
hàm template thích hợp. Chú ý xử lý đối sánh này với các template đòi yêu các đối sánh
chính xác trên tất cả kiểu tham số-không có các chuyển đổi tự động được áp dụng.
Các lớp template
Bên cạnh hàm template, ngôn ngữ C++ còn trang bị thêm lớp template, lớp này cũng
mang đầy đủ ý tưởng của hàm template. Các lớp template được gọi là các kiểu có tham
số (parameterized types) bởi vì chúng đòi hỏi một hoặc nhiều tham số để mô tả làm thế
nào tùy chỉnh một lớp template chung để tạo thành một lớp template cụ thể.
Chúng ta cài đặt một lớp Stack, thông thường chúng ta phải định nghĩa trước một kiểu
dữ liệu cho từng phần tử của stack. Nhưng điều này chỉ mang lại sự trong sáng cho một
chương trình và không giải quyết được vấn đề tổng quát. Do đó chúng ta định nghĩa lớp
template Stack.
Ví dụ 9.3 :
File TSTACK.H:
1: //TSTACK.H 2: //Lớp template Stack 3: #ifndef TSTACK_H
4: #define TSTACK_H 5: 6: #include <iostream.h> 7: 8:
template<class T> 9: class Stack 10: { 11: private: 12:
int Size; //Kích thước stack 13: int Top; 14: T *StackPtr;
15: public: 16: Stack(int = 10); 17: ~Stack() 18: { 19:
delete [] StackPtr; 20: } 21: int Push(const T&); 22: int
Pop(T&); 23: int IsEmpty() const 24: { 25: return Top ==
-1; 26: } 27: int IsFull() const 28: { 29: return Top ==
Size - 1; 30: } 31: }; 32: 33: template<class T> 34:
Stack<T>::Stack(int S) 35: { 36: Size = (S > 0 && S <
1000) ? S : 10; 37: Top = -1; 38: StackPtr = new T[Size];
39: } 40: 41: template<class T> 42: int
Stack<T>::Push(const T &Item) 43: { 44: if (!IsFull()) 45:
{ 46: StackPtr[++Top] = Item; 47: return 1; 48: } 49:
return 0; 50: } 51: 52: template<class T> 53: int
Stack<T>::Pop(T &PopValue) 54: { 55: if (!IsEmpty()) 56: {
57: PopValue = StackPtr[Top--]; 58: return 1; 59: } 60:
return 0; 61: } 62: 63: #endif
Hàm và lớp template trong Lập trình hướng đối tượng
4/6
File CT9_3.CPP:
1: //CT9_3.CPP 2: //Chương trình 9.3 3: #include
"tstack.h" 4: 5: int main() 6: { 7: Stack<float>
FloatStack(5); 8: float F = 1.1; 9: cout << "Pushing
elements onto FloatStack" << endl; 10: while
(FloatStack.Push(F)) 11: { 12: cout << F << ' '; 13: F +=
1.1; 14: } 15:cout << endl << "Stack is full. Cannot push
" << F << endl 16: << endl << "Popping elements from
FloatStack" << endl; 17: while (FloatStack.Pop(F)) 18:
cout << F << ' '; 19: cout << endl << "Stack is empty.
Cannot pop" << endl; 20: Stack<int> IntStack; 21: int I =
1; 22: cout << endl << "Pushing elements onto IntStack" <<
endl; 23: while (IntStack.Push(I)) 24: { 25: cout << I <<
' '; 26: ++I ; 27: } 28:cout << endl << "Stack is full.
Cannot push " << I << endl 29: << endl << "Popping
elements from IntStack" << endl; 30: while
(IntStack.Pop(I)) 31: cout << I << ' '; 32: cout << endl
<< "Stack is empty. Cannot pop" << endl; 33: return 0; 34:
}
Chúng ta chạy ví dụ 9.3, kết quả ở hình 9.3
Kết quả của ví dụ 9.3 (Hình 9.3)
Hàm thành viên định nghĩa bên ngoài lớp template bắt đầu với phần đầu là
Hàm và lớp template trong Lập trình hướng đối tượng
5/6