C++模板

模板是C++最有特色的语法，也是最复杂的语法。它将类型看作一种参数来进行编程。

1. 模板函数

2. 模板类

   1 class Stack {
   2     int *data_;
   3     int size_;
   4     int capacity_;
   5 public:
   6     Stack(int capacity) {
   7         capacity_ = capacity;
   8         size_ = 0;
   9         data_ = new int[capacity_];
  10     }
  11     ~Stack() {
  12         delete[] data_;
  13     }
  14     void push(int t) {
  15         data_[size_++] = t;
  16     }
  17     void pop() {
  18         size_--;
  19     }
  20     int top() const{
  21         return data_[size_-1];
  22     }
  23     bool empty() const{
  24         return size_ == 0;
  25     }
  26     int size() const {
  27         return size_;
  28     }
  29 };

这个栈只能用来存放int不能存放其他东西，为了让他能够存放其他东西，我们把int参数化

   1 template<class T>
   2 class Stack {
   3     T *data_;
   4     int size_;
   5     int capacity_;
   6 public:
   7     Stack(int capacity) {
   8         capacity_ = capacity;
   9         size_ = 0;
  10         data_ = new T[capacity_];
  11     }
  12     ~Stack() {
  13         delete[] data_;
  14     }
  15     void push(const T &t) {
  16         data_[size_++] = t;
  17     }
  18     void pop() {
  19         size_--;
  20     }
  21     T top() const{
  22         return data_[size_-1];
  23     }
  24     bool empty() const{
  25         return size_ == 0;
  26     }
  27     int size() const {
  28         return size_;
  29     }
  30 };

有了这个模板类以后，我们可以定义存放各种类型元素的栈：

   1 int main() {
   2     Stack<int> s;
   3     Stack<double> t;
   4     Stack<complex> u;
   5 }

练习：写一个Array类，可以存放任何类型元素的数组

3. 系统内置的模板库

线性容器：vector、deque、list，关联容器：set、multiset、map、multimap

适配器：stack、queue、priority_queue

迭代子：类似指针

算法：sort等

   1 #include <vector>
   2 #include <iostream>
   3 using namespace std;
   4 
   5 void print(vector<int> &v) {
   6     for(int i = 0; i < v.size(); i++)
   7         cout << v[i];
   8 }
   9 
  10 int main() {
  11     vector<int> v;
  12     v.push_back(3);
  13     v.push_back(2);
  14     v.push_back(1);
  15     print(v);
  16     v.pop_back();
  17     print(v);
  18     v.insert(v.begin(), 4);
  19     print(v);
  20     v.insert(v.end(), 5);
  21     print(v);
  22     v.erase(v.begin());
  23     print(v);
  24 }

   1 void print(vector<int>::iterator begin, vector<int>::iterator end) {
   2     while(begin != end) {
   3         cout << *begin ;
   4         begin++;
   5     }
   6 }
   7 
   8 int main() {
   9     vector<int> v;
  10     v.push_back(3);
  11     v.push_back(2);
  12     v.push_back(1);
  13     print(v.begin(), v.end());
  14 }

CategoryCpp