模板和标准模板库

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模板类进行继承