Last updated on December 15, 2006
Table of Contents
C++ templates allow one to implement a generic Queue
C++ Provides two model of templates: Class template, and functions template. Use function templates to write generic functions that can be used with arbitrary types. For example, one can write searching and sorting routines which can be used with any arbitrary type. The Standard Template Library generic algorithms have been implemented as function templates, and the containers have been implemented as class templates.
Class Templates
Implementing a class template
A class template definition looks like a regular class definition, except it is prefixed by the keyword template. For example, here is the definition of a class template for a Stack.
Banyak C + + menggunakan program umum seperti susunan struktur data, dan daftar antrian. Sebuah program mungkin memerlukan antrian pelanggan dan antrian pesan. Satu dapat dengan mudah menerapkan antrian pelanggan, kemudian mengambil kode yang sudah ada dan melaksanakan antrian pesan. Program tumbuh, dan sekarang ada perlu untuk antrian pesanan. Jadi hanya mengambil pesan dari antrian dan yang dikonversi ke antrian pesanan (Salin, paste, menemukan, menggantikan ????). Perlu membuat beberapa perubahan ke antrian pelaksanaan? Tidak yang sangat mudah, karena kode telah digandakan di banyak tempat. Re-inventing kode sumber yang tidak cerdas dalam pendekatan yang berorientasi objek lingkungan yang mendorong kembali kegunaan. Tampaknya untuk membuat kesalahan yang sama lagi untuk menerapkan antrian yang dapat berisi semua jenis arbitrary daripada duplicating kode. Bagaimana satu melakukannya? Jawabannya adalah dengan menggunakan jenis para-meterization, lebih umum dikenal sebagai template.
C + + menyediakan dua jenis template: template kelas dan fungsi template. Gunakan fungsi template generik untuk menulis fungsi yang dapat digunakan dengan jenis arbitrary. Misalnya, satu dapat menulis dan mencari sortasi rutinitas yang dapat digunakan dengan semua jenis arbitrary. Standar Perpustakaan Template generik algoritma telah dilaksanakan sebagai fungsi template, dan kontainer telah dilaksanakan sebagai kelas template.
Sebuah kelas template definisi seperti yang biasa kelas definisi, kecuali itu prefixed oleh kata kunci template. Misalnya, di sini adalah definisi dari kelas template untuk Stack.
class Stack
(
publik:
Stack (int = 10);
~ Stack () (hapus [] stackPtr;)
int push (Konstan & T);
int pop (T &);
int isEmpty () (Konstan kembali atas == -1;)
int isFull () (Konstan kembali atas == ukuran - 1;)
pribadi:
int ukuran; / / jumlah elemen pada Stack.
int atas;
T * stackPtr;
);
T is a type parameter and it can be any type. For example, Stack
When compiling B.cpp, the compiler has both the declarations and the definitions available. At this point the compiler does not need to generate any definitions for template classes, since there are no instantiations. When the compiler compiles main.cpp, there are two instantiations: template class B
//stack.h
#pragma once
template
class Stack
{
public:
Stack(int = 10) ;
~Stack() { delete [] stackPtr ; }
int push(const T&);
int pop(T&) ; // pop an element off the stack
int isEmpty()const { return top == -1 ; }
int isFull() const { return top == size - 1 ; }
private:
int size ; // Number of elements on Stack
int top ;
T* stackPtr ;
} ;
//constructor with the default size 10
template
Stack
{
size = s > 0 && s < top =" -1" stackptr =" new">
int Stack
{
if (!isFull())
{
stackPtr[++top] = item ;
return 1 ; // push successful
}
return 0 ; // push unsuccessful
}
// pop an element off the Stack
template
int Stack
{
if (!isEmpty())
{
popValue = stackPtr[top--] ;
return 1 ; // pop successful
}
return 0 ; // pop unsuccessful
}
Ketika kompilasi B.cpp, compiler telah baik deklarasi dan definisi yang tersedia. Pada titik ini compiler tidak perlu menghasilkan apa-apa untuk template definisi kelas, karena tidak ada instantiations. Ketika compiler main.cpp, terdapat dua instantiations: template
/ / stack.h
# pragma sekali
template
kelas Stack
(
publik:
Stack (int = 10);
~ Stack () (hapus [] stackPtr;)
int push (Konstan & T);
int pop (T &); / pop / unsur mematikan sebuah konsep
int isEmpty () (Konstan kembali atas == -1;)
int isFull () (Konstan kembali atas == ukuran - 1;)
pribadi:
int ukuran; / / Jumlah elemen pada Stack
int atas;
T * stackPtr;
);
/ / pembina dengan ukuran standar 10
template
Stack
(
ukuran = s> 0 & & s <1000? atas =" -1;" t =" [ukuran];">
int Stack
(
jika (! isFull ())
(
stackPtr [+ + top] = item;
return 1; / / push berhasil
)
return 0; / / push gagal
)
/ / Pop yang keluar dari elemen Stack
template
int Stack
(
jika (! isEmpty ())
(
popValue = stackPtr [top -];
return 1; / / pop berhasil
)
return 0; / / pop gagal
)
To be Continued....
Berlanjut....
