Bài 5.1

Templates (mẫu) là một tính năng mới được giới thiệu bởi chuẩn ANSI-C++. Nếu bạn sử dụng một trình biên dịch C++ chưa tương thích với chuẩn này thì bạn không thể sử dụng mẫu.

Các mẫu hàm Các mẫu cho phép tạo các hàm có thể chấp nhận bất kì kiểu dữ liệu nào làm tham số và trả về giá trị mà không phải làm quá tải hàm với tất cả các kiểu dữ liệu có thể. Khai báo mẫu của nó có thể là một trong hai kiểu sau:

template indetifier > function_declaration ;
template indetifier > function_declaration ;
sự khác biệt duy nhất giữa hai kiểu khai báo mẫu này là việc sử dụng từ khoá class hay typename , sự khác nhau giữa chúng là không rõ ràng vì cả hai đều có cùng một ý nghĩa và đều cho một kết quả như nhau.
Ví dụ, để tạo một hàm mẫu trả về giá trị lớn hơn của hai đối tượng chúng ta có thể sử dụng:
template
GenericType GetMax (GenericType a, GenericType b) {
return (a>b?a:b);
} Ở dòng đầu tiên, chúng ta đã tạo một mẫu cho một kiểu dữ liệu tổng quát với tên GenericType . Vì vậy trong hàm sau đó, GenericType trở thành một kiểu dữ liệu hợp lệ và nó được sử dụng như là một kiểu dữ liệu cho hai tham số a , b và giá trị trả về của hàm GetMax .
GenericType thực sự không biểu diễn một kiểu dữ liệu cụ thể nào, chúng ta có thể gọi hàm với bất kì kiểu dữ liệu hợp lệ nào. Kiểu dữ liệu này sẽ đáp ứng như là pattern(mẫu) và sẽ thay thế GenericType bên trong hàm. Cách thức để gọi một lớp mẫu với một kiểu dữ liệu mẫu như sau:

function pattern > ( parameters );
Ví dụ, để gọi hàm GetMax và so sánh hai giá trị nguyên kiểu int chúng ta có thể viết:

int x,y;
GetMax (x,y);

Ok, dưới đây là ví dụ đầy đủ:





// mẫu hàm
#include

template
T GetMax (T a, T b) {
T result;
result = (a>b)? a : b;
return (result);
}

int main () {
int i=5, j=6, k;
long l=10, m=5, n;
k=GetMax(i,j);
n=GetMax(l,m);
cout
6
10
(Trong trường hợp này chúng ta gọi kiểu dữ liệu tổng quát là T thay vì GenericType vì nó ngắn hơn, thêm vào đó nó là một trong những tên phổ biến nhất được dùng cho mẫu mặc dù chúng ta có thể sử dụng bất cứ tên hợp lệ nào).
Ở ví dụ trên chúng ta đã sử dụng cùng một hàm GetMax() với các tham số kiểu int và long chỉ với một phiên bản duy nhất của hàm. Như vậy có thể nói chúng ta đã viết một mẫu hàm và gọi nó bằng hai kiểu khác nhau.
Như bạn có thể thấy, bên trong mẫu hàm GetMax() kiểu T có thể được dùng để khai báo các đối tượng mới:

T result;

Trong trường hợp cụ thể này kiểu dữ liệu tổng quát T được sử dụng như là tham số chao hàm GetMax , trình biên dịch có thể tự động tìm thấy kiểu dữ liệu nào phải truyền cho nó mà không cần bạn phải chỉ định hay . Bởi vậy chúng ta có thể viết:

int i,j;
GetMax (i,j);
Cách này được sử dụng phổ biến hơn và cũng cho kết quả như vậy:





// mẫu hàm II
#include

template
T GetMax (T a, T b) {
return (a>b?a:b);
}

int main () {
int i=5, j=6, k;
long l=10, m=5, n;
k=GetMax(i,j);
n=GetMax(l,m);
cout
6
10
Chú ý trong trường hợp này, bên trong hàm main() chúng ta đã gọi hàm mẫu GetMax() mà không chỉ định rõ kiểu dữ liệu ở giữa hai ngoặc nhọn . Trình biên dịch sẽ tự động xác định kiểu dữ liệu nào là cần thiết chô mỗi lời gọi.
Vì hàm mẫu của chúng ta chỉ dùng một kiểu dữ liệu (class T ) và cả hai tham số của nó đều có cùng một kiểu, chúng ta không thể gọi hàm mẫu với tham số là hai đối tượng có kiểu khác nhau:

int i;
long l;
k = GetMax (i,l);

Chúng ta cũng có thể khiến cho hàm cho hàm mẫu chấp nhận nhiều hơn một kiểu dữ liệu tổng quát. Ví dụ:
template
T GetMin (T a, U b) {
return (a Trong trường hợp này, hàm mẫu GetMin() chấp nhận hai tham số có kiểu khác nhau và trả về một đối tượng có cùng kiểu với tham số đầu tiên (T ). Ví dụ, sau khi khai báo như trên chúng ta có thể gọi hàm như sau:
int i,j;
long l;
i = GetMin (j,l); hoặc thậm chí:
i = GetMin (j,l);
Các lớp mẫu
Chúng ta cũng có thể viết các lớp mẫu, một lớp mà có các thành viên dựa trên các kiểu dữ liệu tổng quát không cần phải được định nghĩa ở thời điểm tạo lớp. Ví dụ

template
class pair {
T values [2];
public:
pair (T first, T second)
{
values[0]=first; values[1]=second;
}
}; Lớp mà chúng ta vừa định nghĩa dùng để lưu trữ hai phần tử có kiểu bất kì. Ví dụ, nếu chúng ta muốn khai báo một đối tượng thuộc lớp này để lưu trữ hai giá trị nguyên kiểu int có giá trị là 115 and 36 chúng ta có thể viết:

pair myobject (115, 36);
lớp này cũng có thể được dùng để lưu trữ bất kì kiểu dữ liệu nào khác:

pair myfloats (3.0, 2.18);
Hàm thành viên duy nhất được định nghĩa inline bên trong định nghĩa của lớp, tuy nhiên nếu chúng ta định nghĩa một hàm thành viên bên ngoài lớp chúng ta luôn phải đặt trước dòng định nghĩa tiền tố template .





// mẫu lớp
#include

template
class pair {
T value1, value2;
public:
pair (T first, T second)
{value1=first; value2=second;}
T getmax ();
};

template
T pair::getmax ()
{
T retval;
retval = value1>value2? value1 : value2;
return retval;
}

int main () {
pair myobject (100, 75);
cout
100 chú ý cách bắt đầu định nghĩa hàm getmax :

template T >
T pairT >::getmax ()
Tất cả các T xuất hiện ở đó đều là cần thiết. Mỗi khi bạn khai báo một hàm thành viên bạn sẽ phải theo một khuôn mẫu tương tự như thế.
Chuyên môn hoá mẫu Việc chuyên môn hoá mẫu cho phép một mẫu tạo ra những bản thực thi đặc biệt khi làm việc với một loại dữ liệu xác định nào đó. Ví dụ, giả sử rằng lớp mẫu pair có một hàm dùng để trả về phần dư trong phép chia giữa hai trường ở trong, nhưng chúng ta chỉ muốn nó làm việc khi kiểu dữ liệu là int còn những kiểu còn lại thì hàm luôn trả về 0 . Nó có thể được làm theo cách sau:





// Chuyên môn hoá mẫu
#include

template
class pair {
T value1, value2;
public:
pair (T first, T second)
{value1=first; value2=second;}
T module () {return 0;}
};

template
class pair {
int value1, value2;
public:
pair (int first, int second)
{value1=first; value2=second;}
int module ();
};

template
int pair::module() {
return value1%value2;
}

int main () {
pair myints (100,75);
pair myfloats (100.0,75.0);
cout
25
0
Như bạn có thể thấy sự chuyên môn hoá được định nghĩa theo cách sau:

template class class_name type >
Sự chuyên môn hoá này là một phần của một mẫu, vì vậy chúng ta phải bắt đầu phần khai báo với template . Và rõ ràng rằng đó là sự chuyên môn hoá cho một kiểu dữ liệu cụ thể nên chúng ta không thể dùng một kiểu dữ liệu tổng quát, cặp ngoặc nhọn cũng phải để trống. Sau phần tên lớp chúng ta phải viết thêm tên kiểu dữ liệu muốn dùng ở giữa cặp ngoặc nhọn .
Khi chúng ta chuyên biệt hoá một kiểu dữ liệu cho một mẫu chúng ta cũng phải định nghĩa tất cả các thành viên tương xứng với sự chuyên môn hoá đó (nếu bạn thấy chưa rõ lắm, hãy xem lại ví dụ trên trong đó chúng ta đã phải viết lại constructor cho chính nó mặc dù cái này hoàn toàn giống như constructor ở trong lớp tổng quát. Nguyên nhân là do không có thành viên nào được "thừa kế" từ lớp tổng quát cho lớp chuyên môn hoá.
Các giá trị tham số cho mẫu
Bên cạnh các tham số của mẫu là kiểu dữ liệu (được đứng trước bởi từ khoá class hay typename ), các hàm mẫu và các lớp mẫu còn có thể có các tham số khác không phải là kiểu mà chúng có thể là các giá trị hằng. Trong ví dụ dưới đây lớp mẫu được dùng để lưu trữ mảng:





// array template
#include

template
class array {
T memblock [N];
public:
setmember (int x, T value);
T getmember (int x);
};

template
array::setmember (int x, T value) {
memblock[x]=value;
}

template
T array::getmember (int x) {
return memblock[x];
}

int main () {
array myints;
array myfloats;
myints.setmember (0,100);
myfloats.setmember (3.0,3.1416);
cout
100
3.1416
Chúng ta cũng có thể thiết lập các giá trị mặc định cho bất kì tham số mẫu nào giống như với các tham số của hàm bình thường.
Ví dụ:

template // Trường hợp phổ biến nhất: một tham số lớp.
template // Hai tham số lớp.
template // Một lớp và một giá trị nguyên.
template // Một tham số lớp với giá trị mặc định.
template // Tham số là một hàm.
Mẫu và các dự án Theo quan điểm của trình biên dịch, các mẫu không phải là các hàm hay lớp thông thường. Chúng được dịch theo nhu cầu. Điều đó có nghĩa là mã của một hàm mẫu không được dịch cho đến khi cần dùng đến. Với các trình dịch ở thời điểm thực hiện bài viết, trình dịch sẽ tạo ra từ mẫu một hàm cụ thể cho kiểu dữ liệu được yêu cầu.
Khi các dự án phát triển lên, nó thường chi mã của một chương trình thành nhiều file khác nhau. Trong những trường hợp đó, nói chúng phần giao tiếp và phần thực hiện là tách biệt. Lấy ví dụ một thư viện hàm nào đó, phần giao tiếp thường gồm tất cả những khai báo mẫu của các hàm có thể được gọi, chúng thường được khai báo trong một "header file"với phần mở rộng .h , và phần thực hiện (phần định nghĩa cả các hàm đó) được đặt trong các file mã C++ riêng.
Đối với mẫu, chúng ta có một điều bắt buộc khi thực hiện các dự án nhiều file: phần thực hiện (phần định nghĩa) của một lớp mẫu hay hàm mẫu phải nằm trong cùng một file với phần khai báo. Điều này có nghĩa là chúng ta không thể tách phần giao tiếp thành một file riêng mà phải gộp cả phần giao tiếp và phần thực thi vào bất kì fiel nào sử dụng mẫu.
Trở lại với trường hợp thư viện hàm, nếu chúng ta muốn tạo một thư viện hàm mẫu, thay vì việc tạo một header file (.h ) chúng ta nên tạo một "template file" chứa cả phần giao tiếp và phần thực thi của các hàm mẫu (không có một quy định nào về phần mở rộng của những file này, bạn thích dùng thế nào cũng được hoặc cứ để là .h cho tiện). Một điều cuối cùng nữa là việc một "template file" được dùng nhiều lần trong một dự án sẽ không gây ra lỗi liên kết vì chúng được dịch theo nhu cầu và những trình biên dịch hỗ trợ templates sẽ biết phải làm thế nào để không sinh mã lặp trong các trường hợp đó.