Chương 4.

Khuôn hình (template)

Nội dung
4.1. Khái niệm
4.2. Khuôn hình hàm
4.3. Khuôn hình lớp
4.4. Một số bài tập
 4.1. Khái niệm
• template là từ khóa trong C++,

• ta có thể hiểu đây là kiểu dữ liệu trừu tượng,

• đặc trưng cho các kiểu dữ liệu cơ bản.

• template là từ khóa báo cho trình biên dịch biết là đoạn mã sau
đây sẽ định nghĩa cho nhiều kiểu dữ liệu và mã nguồn sẽ được
biên dịch tương ứng cho từng kiểu dữ liệu.
 4.2. Khuôn hình hàm
• Định nghĩa chồng hàm cho phép dùng một tên duy nhất cho nhiều hàm thực hiện các
công việc khác nhau.

• int tMax(int x, int y){return (x > y) ? x : y;} template <class T> T tMax(T x, T y){
return (x > y) ? x : y;
• float tMax(float x, float y){return (x > y) ? x : y;} }

• double tMax(double x, double y){return (x > y) ? x : y;}

• SV tMax(SV x, SV y){ return (x > y) ? x : y;}//so sánh theo dtb

• NV tMax(NV x, NV y){ return (x > y) ? x : y;}//so sánh theo hsl

 4.2. Khuôn hình hàm
template <class T> T tMax(T x, T y){ class SV{
//...
return (x > y) ? x : y; float dtb() {return (d1+d2+d3)/3;}
} bool operator>(SV x, SV y){
return x.dtb() > y.dtb();
}
};
class NV{
//...
bool operator>(NV x, NV y){
return x.hsl > y.hsl;
}
};
 4.2. Khuôn hình hàm
#include<>
//...
template <class T> T tMax(T x, T y){
return (x > y) ? x : y;
}
int main(){
int x=12, y=35;
int z=tMax(x, y);
cout<<z;
}
4.2. Khuôn hình hàm
• Cách xây dựng:

template <class T, class U, ...> int fct (T a, T *b, U c) {

//nội dung của hàm

• Trong đó:
• T, U, ...: là các kiểu tượng trưng nào đó
• template <class T, class U, ...>: xác định khuôn hình với các tham số kiểu T, U, ...
 4.2. Khuôn hình hàm
void doi_cho(int &x, int &y){int tg=x; x=y; y=tg;}

void doi_cho(float &x, float &y){float tg=x; x=y; y=tg;}

void doi_cho(double &x, double &y){double tg=x; x=y; y=tg;}

void doi_cho(SV &x, SV &y){SV tg=x; x=y; y=tg;}

void doi_cho(NV &x, NV &y){NV tg=x; x=y; y=tg;}

template <class T> void doi_cho(T &x, T &y){

T tg=x; x=y; y=tg;
}
4.2. Khuôn hình hàm
• Bài tập:
1. Viết khuôn hình hàm tìm vị trí phần tử min của mảng
2. Viết khuôn hình hàm tìm phần tử min của mảng
3. Viết khuôn hình hàm tìm phần tử min của đoạn [u, v] trong mảng
4. Viết khuôn hình hàm sắp xếp đoạn [u, v] trong mảng
5. Viết khuôn hình hàm nhập một mảng có n phần tử
6. Xây dựng khuôn hình hàm tìm vị trí phần tử lớn nhất trong mảng
4.2. Khuôn hình hàm
template <class T> int tMax(T a[], int n){
int vt = 0;
for(int i=1; i<n; i++)
if(a[i] > a[vt]) vt = i;
return vt;
}
int main(){
SV *a; int n=9;
a=new SV[n];
//nhập mảng sinh viên
vt=tMax(a, n);//
//in kết quả
}
4.3. Khuôn hình lớp
- Class: Nhóm các dữ liệu khác kiểu vào với nhau thành 1 lớp; bao gói dữ
liệu và việc xử lý dữ liệu đó vào cùng một chỗ. Tăng tính bảo mật cho dữ
liệu cũng như abstraction (trừu tượng hóa) dữ liệu với người dùng.

- Template: Gom các xử lý với nhiều kiểu dữ liệu khác nhau về cùng một
chỗ để tránh việc viết lại code và tổng quát hóa quá trình xử lý dữ liệu.

>> Tựu chung hai ý tưởng này làm 1 ta sẽ thấy được việc vì sao lại xây
dựng các class template.
Ví dụ class template
Ví dụ thông dụng nhất về việc xây dựng các class template là
xây dựng các cặp (pair).
- Cặp <string, string> trong từ điển - <từ, nghĩa của từ>
- Cặp <int, string> trong quản lý danh sách sinh viên - <mã số
sinh viên, họ tên>
........
 Lớp sinh viên int SV::getId () {
return this->masv;
class SV { };
int masv;
string hten; string SV::getName () {
return this->hten;
public : };
SV (int ma, string ht) : masv(ma), hten (ht) { };
int getId ();
string getName ();
};
 Lớp từ vựng - WordBook string WB::getW () {
class WB{ return this->word;
};
string word;
string meaning;
string WB::getM () {
public : return this->meaning;
WB (string tu, string nghia){ };
word = tu;
meaning = nghia;
};
string getW ();
string getM ();
};
 So sánh 2 lớp
class SV {
class WB{
string word;
int masv;
string meaning; string hten;
public : public :
WB (string tu, string nghia){ SV (int ma, string ht) :
word = tu; masv(ma), hten (ht) { };
meaning = nghia; int getId ();
};
string getName ();
string getW ();
string getM (); };
};
Ví dụ

template <class T, class V>

class myPair { template <class T, class V>
T first; T myPair<T,V>::getFirst () {
V second; return this->first;
public : };
myPair (T first, V second) :
first(first), second (second) { }; template <class T, class V>
// get method V myPair<T,V>::getSecond () {
T getFirst (); return this->second;
V getSecond (); };
};
Sử dụng
• Khi sử dụng ta phải xác định đầy đủ các đối số (nếu không có đối
số nào được định trước – đối số ngầm định).
• myPair <int, string> x;
• myPair <string, string> y;
• myPair <int, int> pair0 (100,100);
• // Hay phức tạp hơn với con trỏ.
• myPair<int, int> *pair1 = new myPair<int, int> (1,2);
• myPair<int, string> *pair2 = new myPair<int, string> (10020273, "Coco
Rude");
• myPair<string, string>
• *pair3 = new myPair<string, string> ("Coco Rude", "Trai dua tho lo =))");
Cách thức tạo class template
• template <class T, class V, ......> class myClass {
// to do something
}
 Xây dựng phương thức
• Định nghĩa phương thức myMethod (T a, V b ...) bên ngoài class thì ta
phải thêm danh sách các kiểu vào trước như sau:
• template <class T, class V ....> xyz_type myClass <T, V, ....> :: myMethod (T a,
V b, ....) {
// to do something
•}
• //giả thiết phương thức myMethod có kiểu xyz_type nào đó
 Ví dụ: Class template Array

template <class T> class myArray {

int spt;
T *array;
public: int main ( ) {

myArray () { myArray<int, 5> intAr;

// to do something intAr.setElement(0,100);

}; cout << intAr.getElement(0) << endl;

void setElement (int index, T value) { return 0;

array[index] = value; }
};
T getElement (int index) {
return array[index];
};
};
Ngầm định
• template <class Type = int> //defaults to type int
• class Point
•{
• Type x;
• Type y;
• };
•
• Point<> point;