C + + Template Tutorial
Last updated on December 15, 2006
Terakhir diperbaharui pada 15 Desember 2006
Table of Contents
Daftar Isi
Many C++ programs use common data structures like stacks, queues and lists. A program may require a queue of customers and a queue of messages. One could easily implement a queue of customers, then take the existing code and implement a queue of messages. The program grows, and now there is a need for a queue of orders. So just take the queue of messages and convert that to a queue of orders (Copy, paste, find, replace????). Need to make some changes to the queue implementation? Not a very easy task, since the code has been duplicated in many places. Re-inventing source code is not an intelligent approach in an object oriented environment which encourages re-usability. It seems to make more sense to implement a queue that can contain any arbitrary type rather than duplicating code. How does one do that? The answer is to use type parameterization, more commonly referred to as templates.
C++ templates allow one to implement a generic Queue
template that has a type parameter T. T can be replaced with actual types, for example, Queue, and C++ will generate the class Queue. Changing the implementation of the Queue becomes relatively simple. Once the changes are implemented in the template Queue, they are immediately reflected in the classes Queue, Queue, and Queue. Templates are very useful when implementing generic constructs like vectors, stacks, lists, queues which can be used with any arbitrary type. C++ templates provide a way to re-use source code as opposed to inheritance and composition which provide a way to re-use object code.
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.Pendahuluan
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 + + template memungkinkan untuk melaksanakan satu yang umum Antrian template yang memiliki jenis parameter T. T dapat diganti dengan jenis sebenarnya, misalnya, Antrian , dan C + + akan menghasilkan kelas Antrian . Mengubah pelaksanaan menjadi dari Antrian relatif sederhana. Setelah perubahan yang dilaksanakan dalam template Antrian , mereka akan segera tercermin dalam kelas Antrian , Antrian , dan Antrian . Template sangat berguna saat pelaksanaan konstruksi yang generik seperti vektor, susunan, daftar, antrian yang dapat digunakan dengan semua jenis arbitrary. C + + template memberikan cara untuk kembali menggunakan kode sumber yang bertentangan untuk warisan dan komposisi yang memberikan cara untuk kembali menggunakan kode obyek.
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.
Kelas Template
Pelaksana sebuah 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.
template
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, where Token is a user defined class. T does not have to be a class type as implied by the keyword class. For example, Stack and Stack are valid instantiations, even though int and Message* are not "classes".
T adalah jenis parameter dan dapat jenis apapun. Misalnya, Stack , dimana Bukti adalah ditetapkan pengguna kelas. T tidak harus menjadi kelas tipe tersirat oleh kata kunci kelas. Misalnya, Stack dan Stack berlaku instantiations, walaupun int dan Pesan * tidak "kelas".
Implementing template member functions is somewhat different compared to the regular class member functions. The declarations and definitions of the class template member functions should all be in the same header file. The declarations and definitions need to be in the same header file.
Pelaksana Template kelas anggota
Pelaksana template anggota fungsi sedikit berbeda dibandingkan dengan fungsi anggota kelas reguler. The deklarasi dan definisi dari fungsi anggota kelas template harus di header file yang sama. Deklarasi dan definisi yang harus di header file yang sama. Consider the following.
Consider the following.
Pertimbangkan yang berikut.
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 and B. At this point the compiler has the declarations but no definitions! While implementing class template member functions, the definitions are prefixed by the keyword template. Here is the complete implementation of class template Stack:
//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::Stack(int s)
{
size = s > 0 && s < top =" -1" stackptr =" new">
int Stack::push(const T& item)
{
if (!isFull())
{
stackPtr[++top] = item ;
return 1 ; // push successful
}
return 0 ; // push unsuccessful
}
// pop an element off the Stack
template
int Stack::pop(T& popValue)
{
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 kelas B dan B . Pada titik ini compiler memiliki deklarasi tetapi tidak definisi! Sedangkan pelaksanaan fungsi anggota kelas template, definisi yang prefixed oleh kata kunci template. Berikut adalah menyelesaikan pelaksanaan kelas template Stack:
/ / 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 :: Stack (int s)
(
ukuran = s> 0 & & s <1000? atas =" -1;" t =" [ukuran];">
int Stack :: push (Konstan T & item)
(
jika (! isFull ())
(
stackPtr [+ + top] = item;
return 1; / / push berhasil
)
return 0; / / push gagal
)
/ / Pop yang keluar dari elemen Stack
template
int Stack :: pop (T & popValue)
(
jika (! isEmpty ())
(
popValue = stackPtr [top -];
return 1; / / pop berhasil
)
return 0; / / pop gagal
)
To be Continued....
Berlanjut....
