template<class T>
class Array{
//...
};
T就是类参数，T前面的关键字是class或typename。
类参数是个符号，代表通过关键字class或typename将要被某个确定类型代替的类型
template和<之间可以有一个空格，但是通常不要有
我们将Array<double>和Array<char>称为模板类Array<T>的模板实例
不可能存在一个类型为Array或Array<T>的对象，但我们可以定义类型为Array<int>的对象。也就是说，一个对象不能属于像Array这样的模板类，但可以属于Array<char>
这样的模板类实例
用内建或自定义的数据类型都可以创建模板实例
模板类可以作为一种数据类型出现在参数列表中
template<class T>
ostream & operator<<(ostream& os,const Array<T>& ar) {
for(int i = 0 ;i < ar.get_size() ; i ++)
os << ar[i] << endl;
return os;
}
模板类必须至少有一个类参数，当然可以有多个类参数。模板类还可以有非类参数的参数。一般称之为函数类型参数（无类型模板参数），一个模板类可以有多个函数类型参数，这些参数的数据类型可以使内建类型或自定义类型参数
template<class T,int x,int y>
class Sample {
};
用具体的数据类型代替模板头中的类参数，并用具体的数值代替模板头中的函数类型参数，就可以实例化一个模板类，所以模板类有时称为参数化的类
模板类中的成员函数可以以内联函数的形式定义
模板类中的函数类型参数是类参数中除了class或typename定义的类型
例子：
头文件stack.h:
#include <iostream>
#include <string>
#include <cassert>
using namespace std;
template<class T>
class Stack {
public:
enum {DefaultStack=50,EmptyStack=-1};
Stack();
Stack(int);
~Stack();
void push(const T&);
T pop();
T topNoPop() const;
bool empty() const;
bool full() const;
private:
T *elements;
int top;
int size;
void allocate() {
elements = new T[size];
top = EmptyStack;
}
void msg(const char *m) const {
cout << "*** " << m << " ***" << endl;
}
friend ostream& operator<<(ostream&,const Stack<T> &);
};
template<class T>
Stack<T>::Stack() {
size = DefaultStack;
allocate();
}
template<class T>
Stack<T>::Stack(int s) {
if(s < 0)
s *= -1;
else if( 0 == s)
s = DefaultStack;
size = s;
allocate();
}
template<class T>
Stack<T>::~Stack() {
delete[] elements;
}
template<class T>
void Stack<T>::push(const T& e) {
assert(!full());
if(!full())
elements[++top] = e;
else
msg("Stack full!");
}
template<class T>
T Stack<T>::pop() {
assert(!empty());
if(!empty())
return elements[top --];
else {
msg("Stack empty!");
T dummy_value = 0;
return dummy_value;
}
}
template<class T>
T Stack<T>::topNoPop() const {
assert(top > EmptyStack);
if(!empty())
return elements[top];
else {
msg("Stack empty!");
T dummy_value = 0;
return dummy_value;
}
}
template<class T>
bool Stack<T>::empty() const {
return top <= EmptyStack;
}
template<class T>
bool Stack<T>::full() const {
return top+1 >= size;
}
template<class T>
ostream& operator<<(ostream& os,const Stack<T> &s) {
s.msg("Stack conents:");
int t = s.top;
while(t > s.EmptyStack)
cout << s.elements[t--] << endl;
return os;
}
测试文件：
结果：
标准模板库（Standard Template Library）STL是标准C++库的一部分。STL的模板类为C++提供了完善的数据结构
容器、算法、和迭代器是STL的三个基本组成部分。
一个STL容器是对象的集合。
STL包括vector、stack、queue、deque、list、set和map等
STL算法是对容器进行处理的函数，例如：copy、sort、search、merge和permute等
STL迭代器是一访问器中的一种机制，一次访问一个对象
STL的迭代器可分为 正向、反向、双向和随机遍历
和C++数组不同，STL容器的大小自动变化。
STL基本容器可以分两组：序列式容器和关联式容器
例子：vector容器
vector支持两端插入，并提供begin和end成员函数，分别用来访问头部和尾部元素。两个函数都返回一个可随机访问的迭代器
begin：
如果容器不为空，指向容器的第一个元素
如果容器为空，指向容器尾部之后的位置
end：
仅指向容器尾部之后的位置
vector和deque的区别主要在于他们的底层实现不同，特别是插入和删除操作的实现机制不同。
对于vector来说，不管其大小时多少，在头部插入的效率总是比在尾部插入的效率低。在尾部插入将耗费固定的时间。在头部插入时，耗时与vector大小乘正比。
deque与vector不同，不管插入还是删除操作，也不管这些操作是头部还是在尾部进行，算法效率是固定的
例子：list容器
list有两种迭代器：
list<type>::iterator
list<type>::const_iterator
type是我们要定义的类型
vector、deque和list
三者都是STL的基本序列式容器：都有insert和erase成员函数
vector和deque都重载了[]而list没有，因此我们用list时要使用迭代器
另外效率上也有差别：
STL的关联式容器：set和map
set是一种集合，其中包含0个或多个不重复的和不排序的元素，这些元素被称为键值
例子：（set）
set重载了而多个insert成员函数，我们既可以向vector那样采用指定插入位置，也可以不指定
s.insert(s.begin(),66);
s.insert(s.end(),99);
s.insert(33);
不论采用哪种重载方式，insert均能保证在set中不含重复的键
find是set中另一个常用的函数用来查看set中是否包含某个指定的键值，如果存在返回指向该键的迭代器，否则返回end成员函数的值
例子：（map）
map也定义了insert函数，map还重载了[]操作符
容器适配器是基本容器的衍生物，并利用基本容器来实现其特定功能。
容器适配器有三种：stack，queue和priority_queue
stack适配器用于创建LIFO列表。queue适配器用于创建FIFO列表
priority_queue用于创建带优先级的队列，其元素以某种优先顺序进行删除
例子：（stack）
默认情况下STL stack衍生自deque因此
stack<char> s;
等价于
stack<char, deque<char> > s;
如果需要让stack从vector衍生，可采用如下定义方式：
stack<char , vector<char> > s;
stack中的
top函数返回栈顶元素
pop函数删除栈顶元素
两个通常配对使用top一个元素判断后，再pop
例子：（queue）
和stack相同，默认情况下，queue衍生自deque。
queue也有push和pop成员函数
同时提供了front成员函数，用来访问queue头元素
例子： (priority_queue)
在默认情况下，priority_queue衍生自vector
优先队列是指该队列以某种优先级顺序删除队列中的元素。例如，一个整数优先级队列可能以降序方式来删除元素。这样就保证了在删除元素的过程中保持队列元素的优先级顺序
priority_queue使用我们熟悉的push和pop成员函数来插入和删除。top返回不删除
我们熟悉的string类以及bitset类也可以做STL容器来使用：
例子：（bitset）
bitset是二进制序列。bitset并不是数学意义上的集合，因为它可以包含重复的数字（毕竟只有0和1）
由于bitset默认构造函数将所有的位都清0，
但是可以用转型构造函数初始一个bitset的值 bitset(unsigned long n);
bitset<8> bs(9) 就创建一个00001001的bitset
bitset可完成如下功能
1>将某个指定位设置为0或1
2>对某个位或所有位取反
3>测试某个位为0或1
4>进行左移或右移操作
5>进行与、或和异或等标准二进制操作
6>将bitset转型为string或unsigned long类型
#include <iostream>
#include <string>
#include <bitset>
using namespace std;
const featureCount = 9;
const unsigned Framed = 1;
const unsigned Bordered = 2;
const unsigned StdMenu = 4;
const unsigned ToolBar = 8;
const unsigned StatusBar= 16;
class Window {
public:
Window(const string &n,unsigned f) {
name = n;
features = bitset<featureCount>(f);
createWindow();
}
Window(const char *n ,unsigned f) {
name = n;
features = bitset<featureCount>(f);
createWindow();
}
private:
void createWindow() {
cout << "\n*** Windows feature for " << name
<< " given bit mask " << features << ":" << endl;
if(features[0])
cout << "\t" << "framed" << endl;
if(features[1])
cout << "\t" << "bordered" << endl;
if(features[2])
cout << "\t" << "with standard menu" << endl;
if(features[3])
cout << "\t" << "with tool bar" << endl;
if(features[4])
cout << "\t" << "with status bar" << endl;
}
string name;
bitset<featureCount> features;
};
int main() {
Window w1("w1",Framed | ToolBar | StatusBar);
Window w2("w2",ToolBar | Framed | StatusBar);
Window w3("w3",Framed | StdMenu | StatusBar | ToolBar | Bordered );
return 0;
}
结果：
STL有大量用来处理容器的算法。这些算法可以分为如下几类：排序和搜索、数值处理、集合运算、复制等
STL算法是用模板函数实现的，如STL的reverse算法:
template<class BidirectionalIterator >
void reverse(BidirectionalIterator it1,BidirectionalIterator it2);
STL算法使用迭代器来变量容器，并在迭代过程中处理容器中的元素：
例子1：
例子2：
STL算法nth_element将序列中的中值元素(median elememt)放置到序列的中间位置。仅仅是找到并放到中间位置，不会对序列排序，结果我们可以看到
nth_element有三个参数，第一个迭代器标志序列头部，第二个要放置的位置，最后一个迭代器标志序列的尾部
STL的copy算法三个参数，前两个是迭代器的范围，最后一个是输出型迭代器：
输出迭代器实例：ostream_iterator<char>
表达式ostream_iterator<char>(cout," ")调用带参数的构造函数来创建迭代器，这个构造函数的第一个参数为输出流，本来为cout，第二个参数是可选的，用来指定输出到输出流的各项之间的分隔符，本例为空格符
输出迭代器例子：
STL除了上面的还有其他构件：
函数对象(function object)、函数适配器(function adaptor) 和 STL alocator
函数对象是一个类对象，它对函数调用操作符() 进行重载，并且该重载函数是公有的。可用STL的函数对象来代替普通函数
上面的dump函数：
void dump(int i) { cout << i << endl;}
在该程序中将dump作为for_each第三个参数
for_each(v.begin(),v.end(),dump);
作为另一种实现方式，我们可以设计一个函数对象:
template<clasls T>
struct dumpIt {
void operator()(T arg) { cout << arg << endl; }
};
然后调用这个模板类的int型实例的重载调用操作符
for_each(v.begin(),v.end(),dumpIt<int>());
由于在默认的情况下结构的成员是公有的，因此我们使用关键字struct来创建dumpIt类。之所以将函数对象的函数调用操作符设计为公有的，是因为要在函数对象的定义之外使用它
一个函数对象的开销比指针传递函数的开销小，所以函数对象通常比常规函数执行速度更快
函数适配器是用来以现有函数对象创建新函数对象的构件。因此函数适配器类似于容器适配器。
有多种函数适配器，包括函数对象求反，在函数对象的重载函数调用操作符中绑定常数和参数，把函数指针转换成函数对象，以及构造现有函数对象之外的新函数对象
两种内建STL函数对象类型为unary_function和binary_funciton
函数对象unary_function第一个模板参数是重载函数调用操作符的参数类型此处为unsigned
第二个模板参数是操作符返回类型，此处为bool
not1（1代表一元）
STL allocator是一个模板类，用于内存管理。
看一个大例子：
#include <iostream>
#include <fstream>
#include <deque>
#include <algorithm>
#include <string>
using namespace std;
const string inFile = "stockData.dat";
const string Unknown = "????";
class Stock {
public:
Stock() {
symbol = Unknown;
open = close = gainLoss = volume = 0;
}
Stock(const string &s,double o,double c,unsigned long v) {
symbol = s;
open = o;
close = c;
volume = v;
gainLoss = (close - open) / open;
}
const string & getSymbol() const {
return symbol;
}
double getOpen() const {
return open;
}
double getClose() const {
return close;
}
unsigned long getVolume() const {
return volume;
}
double getGainLoss() const {
return gainLoss;
}
private:
string symbol;
double open;
double close;
double gainLoss;
unsigned long volume;
};
struct winCmp {
bool operator()(const Stock & s1,const Stock & s2) const {
return s1.getGainLoss() > s2.getGainLoss();
}
};
struct volCmp {
bool operator()(const Stock& s1, const Stock & s2) const {
return s1.getVolume() > s2.getVolume() ;
}
};
void output(bool volFlag,
const string& name,
const char * openLabel,double open,
const char * closeLabel,double close,
const char * gainLabel,double gain,
const char * volLabel, unsigned long vol) {
cout << "*** " << name << endl;
if(volFlag)
cout << '\t' << volLabel << vol << endl;
cout << '\t' << gainLabel << gain << endl
<< '\t' << openLabel << open << endl
<< '\t' << closeLabel << close << endl;
if(!volFlag)
cout << '\t' << volLabel << vol << endl;
}
struct winPr {
void operator() (const Stock & s ) const {
output(false,
s.getSymbol(),
"Open Price: ",s.getOpen(),
"Closing Price: ",s.getClose(),
"% Changed: ",s.getGainLoss() * 100,
"Volume: ",s.getVolume() );
}
};
struct volPr {
void operator() (const Stock & s) const {
output( true,
s.getSymbol(),
"Opening Price: ",s.getOpen(),
"Closing Price: ",s.getClose(),
"% Changed: ",s.getGainLoss() * 100,
"Volume: ",s.getVolume() );
}
};
void herald(const char *);
void input(deque<Stock> &);
int main() {
deque<Stock> stocks;
input(stocks);
herald("Gainers in descending order: ");
sort(stocks.begin(),stocks.end(),winCmp());
for_each(stocks.begin(),stocks.end(),winPr());
herald("Loser in asceding order: ");
for_each(stocks.rbegin(),stocks.rend(),winPr());
herald("Volume in descending order: " );
sort(stocks.begin(),stocks.end(),volCmp());
for_each(stocks.begin(),stocks.end(),volPr());
return 0;
}
void input(deque<Stock> & d) {
string s ;
double o,c,v;
ifstream input(inFile.c_str());
while(input >> s >> o >> c>> v)
d.insert(d.end(),Stock(s,o,c,v));
input.close();
}
void herald(const char *s) {
cout << endl << "******* " << s <<endl;
}
结果：
完整结果文件输出：
******* Gainers in descending order:
*** COHU
% Changed: 5.17382
Open Price: 48.9
Closing Price: 51.43
Volume: 134900
*** ALCD
% Changed: 2.46607
Open Price: 60.42
Closing Price: 61.91
Volume: 230000
*** GMGC
% Changed: 1.81159
Open Price: 2.76
Closing Price: 2.81
Volume: 129400
*** MSFT
% Changed: 1.55296
Open Price: 135.87
Closing Price: 137.98
Volume: 8301700
*** ZTEC
% Changed: -0.784016
Open Price: 39.54
Closing Price: 39.23
Volume: 100300
*** TMXI
% Changed: -8.59873
Open Price: 3.14
Closing Price: 2.87
Volume: 255000
*** BUTI
% Changed: -13.8286
Open Price: 8.75
Closing Price: 7.54
Volume: 159000
*** EPEX
% Changed: -17.3342
Open Price: 15.98
Closing Price: 13.21
Volume: 54000
******* Loser in asceding order:
*** EPEX
% Changed: -17.3342
Open Price: 15.98
Closing Price: 13.21
Volume: 54000
*** BUTI
% Changed: -13.8286
Open Price: 8.75
Closing Price: 7.54
Volume: 159000
*** TMXI
% Changed: -8.59873
Open Price: 3.14
Closing Price: 2.87
Volume: 255000
*** ZTEC
% Changed: -0.784016
Open Price: 39.54
Closing Price: 39.23
Volume: 100300
*** MSFT
% Changed: 1.55296
Open Price: 135.87
Closing Price: 137.98
Volume: 8301700
*** GMGC
% Changed: 1.81159
Open Price: 2.76
Closing Price: 2.81
Volume: 129400
*** ALCD
% Changed: 2.46607
Open Price: 60.42
Closing Price: 61.91
Volume: 230000
*** COHU
% Changed: 5.17382
Open Price: 48.9
Closing Price: 51.43
Volume: 134900
******* Volume in descending order:
*** MSFT
Volume: 8301700
% Changed: 1.55296
Opening Price: 135.87
Closing Price: 137.98
*** TMXI
Volume: 255000
% Changed: -8.59873
Opening Price: 3.14
Closing Price: 2.87
*** ALCD
Volume: 230000
% Changed: 2.46607
Opening Price: 60.42
Closing Price: 61.91
*** BUTI
Volume: 159000
% Changed: -13.8286
Opening Price: 8.75
Closing Price: 7.54
*** COHU
Volume: 134900
% Changed: 5.17382
Opening Price: 48.9
Closing Price: 51.43
*** GMGC
Volume: 129400
% Changed: 1.81159
Opening Price: 2.76
Closing Price: 2.81
*** ZTEC
Volume: 100300
% Changed: -0.784016
Opening Price: 39.54
Closing Price: 39.23
*** EPEX
Volume: 54000
% Changed: -17.3342
Opening Price: 15.98
Closing Price: 13.21
模板类和继承：
一个模板类可以从另一个模板类或非模板类派生而来，模板类或模板类实例都可以作为基类，而它们的派生类既可以是模板类，也可以使非模板类
1>
class B {
// ...
};
template<class T>
class TD : public B {
// ...
};
2>
template<class T>
class TB {
// ...
};
class D : public TB<int> {
// ...
};
template<class T>
class TB {
// ...
};
template<class T>
class D : public TB<T> {
// ...
};
还可以对STL模板类进行继承