STL学习笔记

STL六大组件

• 容器（各种数据结构；class template）
• 算法（各种常用算法如排序、查找、增删等；function template）
• 迭代器（扮演容器和算法之间的粘合剂，泛型指针）
• 仿函数（行为类似函数，可作为算法的某种策略）
• 配接器（一种用来修饰容器或仿函数或迭代器的接口）
• 配置器（负责空间配置和管理）

下图是它们之间的关系示意图：

模板的基本使用

• 函数模板

template<class T>
void swap(T& a,T& b){
    T tmp = a;
    a = b;
    b = tmp;
}

函数模板的示例化可以不用特指类型，基于传入的参数类型由编译器自己判断（如果定义的是同一类型，传入的参数是不同类型，会报错）

int main(){
    int num1=1,num2=2;
    swap(num1,num2);
    
}

• 类模板

template<class T,int maxsize=100> class Stack{
    public:
        Stack();
        void push(T t);
        T pop();
    private:
        T *m_p;
        int m_maxsize;
        int m_size;
};

template<class T,int maxsize> Stack<T,maxsize>::Stack(){
    m_maxSize =100;
    m_maxsize = maxsize
    m_size =0;
    m_p = new T[m_maxSize];
}
template<class T,int maxsize> void Stack<T,maxsize>::push(T t){
    m_size++;
    m_p[m_size-1] = t;
}
template<class T,int maxsize> T Stack<T,maxsize>::pop(){
    T t = m_p[m_size-1];
    m_size--;
    return t;
    
int main(){
    //若模板没有maxsize参数
    Stack<int> sk1;
    sk.push(1);
    sk.push(2);
    int res = sk.pop();
    Stack<int,100> sk2;
    
    return 0;
    //Stack<float> sks;
    ...
}

模板可以有类型参数

模板专门化

假设我们swap函数要处理一个情况，我们有两个很多元素的vector,在使用原来的swap函数，执行tmpT = t1要拷贝t1的全部元素，占用大量内存，造成性能下降，于是我们通过vector.swap函数解决这个问题,代码如下:

//method.h
template<class T> void swap(T& t1, T& t2);

#include "method.cpp"

#include <vector>
using namespace std;
template<class T> void swap(T& t1, T& t2) {
    T tmpT;
    tmpT = t1;
    t1 = t2;
    t2 = tmpT;
}

template<> void swap(std::vector<int>& t1, std::vector<int>& t2) {
    t1.swap(t2);
}

template<>前缀表示这是一个专门化,描述时不用模板参数，使用示例如下:

//main.cpp
#include <stdio.h>
#include <vector>
#include <string>
#include "method.h"
int main() {
    using namespace std;
    //模板方法 
    string str1 = "1", str2 = "2";
    swap(str1, str2);
    printf("str1:%s, str2:%s\n", str1.c_str(), str2.c_str());  
    
    vector<int> v1, v2;
    v1.push_back(1);
    v2.push_back(2);
    swap(v1, v2);
    for (int i = 0; i < v1.size(); i++) {
        printf("v1[%d]:%d\n", i, v1[i]);
    }
    for (int i = 0; i < v2.size(); i++) {
        printf("v2[%d]:%d\n", i, v2[i]);
    }
    return 0;
}

vector的swap代码还是比较局限，如果要用模板专门化解决所有vector的swap，该如何做呢，只需要把下面代码

template<> void swap(std::vector<int>& t1, std::vector<int>& t2) {
    t1.swap(t2);
}

//to

template<T> void swap(std::vector<T>& t1, std::vector<T>& t2) {
    t1.swap(t2);
}

类模板专门化

template <class T>
 class compare
 {
  public:
  bool equal(T t1, T t2)
  {
       return t1 == t2;
  }
};

#include <iostream>
#include "compare.h"
 int main()
 {
  using namespace std;
  char str1[] = "Hello";
  char str2[] = "Hello";
  compare<int> c1;
  compare<char *> c2;   
  cout << c1.equal(1, 1) << endl;        //比较两个int类型的参数
  cout << c2.equal(str1, str2) << endl;   //比较两个char *类型的参数,这里不work
  return 0;
 }

在比较两个整数，compare的equal方法是正确的，但是compare的模板参数是char*时，这个模板就不能工作了，于是修改如下:

#include <string.h>
template <class T>
 class compare
 {
  public:
  bool equal(T t1, T t2)
  {
       return t1 == t2;
  }
};
   

template<>class compare<char *>  
{
public:
    bool equal(char* t1, char* t2)
    {
        return strcmp(t1, t2) == 0;
    }
};