模板 & 容器（扫盲）

函数模板：

基本的函数模板语法：

template<class T>
void foo(T param)
{
    //do something
}

下面是小甲鱼视频中的例子：

#include <iostream>
#include <string>

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

int main()
{
    int i1 = 100;
    int i2 = 200;

    std::cout << "交换前, i1 = " << i1 << ", i2 = " << i2 << "\n";
    swap(i1, i2);
    std::cout << "交换后, i1 = " << i1 << ", i2 = " << i2 << "\n";

    std::string s1 = "小甲鱼";
    std::string s2 = "小由鱼";

    std::cout << "交换前, s1 = " << s1 << ", s2 = " << s2 << "\n";
    swap(s1, s2);
    std::cout << "交换后, s1 = " << s1 << ", s2 = " << s2 << "\n";

    return 0;
}

运行结果：

交换前, i1 = 100, i2 = 200
交换后, i1 = 200, i2 = 100
交换前, s1 = 小甲鱼, s2 = 小由鱼
交换后, s1 = 小由鱼, s2 = 小甲鱼

代码中，<class T>的class就是一个说明文字，叫什么都行，相当于一个注释，解释说后面的模板类型符，是什么模板干神马用的。

当然，后面的T，也是随便起名，选择一个适合的名字就ok。

类模板：

基本的类模板语法：

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

构造器的实现：

Myclass<T>::Myclass()
{
    //初始化操作
}

下面是小甲鱼视频中的例子：

#include <iostream>
#include <string>

template <class T>
class Stack
{
public:
    Stack(unsigned int size = 100);
    ~Stack();
    void push(T value);
    T pop();

private:
    unsigned int size;
    unsigned int sp;
    T *data;
};

template <class T>
Stack<T>::Stack(unsigned int size)
{
    this -> size = size;
    data = new T[size];
    sp = 0;
}

template <class T>
Stack<T>::~Stack()
{
    delete []data;
}

template <class T>
void Stack<T>::push(T value)
{
    data[sp++] = value;
}

template <class T>
T Stack<T>::pop()
{
    return data[--sp];
}

int main()
{
    Stack<int> intStack(100);

    intStack.push(1);
    intStack.push(2);
    intStack.push(3);

    std::cout << intStack.pop() << "\n";
    std::cout << intStack.pop() << "\n";
    std::cout << intStack.pop() << "\n";
    system("pause");
    return 0;
}

运行结果：

3
2
1

类声明的时候前面要加template<class T>

后面类内声明的函数实现的时候，也要加template<class T>

作用域前面要加<T>，例如，T Stack<T>::pop()、void Stack<T>:: push(T value)

内联模板：

基本的内联模板语法：

class Person
{
    Person(std::string name)
    {
        this->name = name;
    }
}

下面是小甲鱼视频中的例子：

#include <iostream>
#include <string>

template <class T>
class Stack
{
public:
    Stack(unsigned int size = 100)
    {
        this -> size = size;
        data = new T[size];
        sp = 0;
    }

    ~Stack()
    {
        delete []data;
    }

    void push(T value)
    {
        data[sp++] = value;
    }

    T pop()
    {
        return data[--sp];
    }

private:
    unsigned int size;
    unsigned int sp;
    T *data;
};

int main()
{
    Stack<int> intStack(100);

    intStack.push(1);
    intStack.push(2);
    intStack.push(3);

    std::cout << intStack.pop() << "\n";
    std::cout << intStack.pop() << "\n";
    std::cout << intStack.pop() << "\n";

    return 0;
}

运行结果：

3
2
1

其实就是把类函数的实现，放到了类声明里，省得每写一个类函数的实现就要写一遍template<class T>这个东西。

用类模板的时候，一定要给他增加一个拷贝构造函数和一个赋值操作符的重载。

有的时候，在一个结构中需要使用多个模板。声明时只需用逗号隔开，多声明几个就ok了。

如下，声明：

template<class T , class U>
class Myclass
{
    //.......
}

如下，实例化：

Myclass<int,float>myclass;

容器：

能容纳两个或更多值的数据结构通常我们称为容器。

#include <iostream>
#include <string>
#include <vector>

int main()
{
    std::vector<std::string> names;

    names.push_back("小甲鱼");
    names.push_back("小由鱼");

    for( int i=0; i < names.size(); i++ )
    {
        std::cout << names[i] << "\n";
    }

    return 0;
}

运行结果：

小甲鱼
小由鱼

其中，push_back()方法的功能是向容器压入数据。

迭代器：

STL中包含容器和算法，容器是用来存储数据，算法是用来处理数据，而这两者需要有一个桥梁才能结合到一起使用，那就是迭代器。因此，其作用就是用来遍历容器中的数据，用于算法中的处理。

如下，小甲鱼视频代码：

#include <iostream>
#include <string>
#include <vector>

int main()
{
    std::vector<std::string> names;

    names.push_back("小甲鱼");
    names.push_back("小由鱼");

    std::vector<std::string>::iterator iter = names.begin();

    while( iter != names.end() )
    {
        std::cout << *iter << "\n";
        ++iter;
    }

    return 0;
}

运行结果：

小甲鱼
小由鱼

迭代器的声明规则就如上面代码所示，std::vector<std ::string>::iterator iter = names.begin();

通常，初始化赋值给迭代器的都是容器的其实地址

迭代器在有的地方也被称作智能指针

算法：

第二段代码：

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

int main()
{
    std::vector<std::string> names;

    names.push_back("Larry");
    names.push_back("Rola");
    names.push_back("DingDing");
    names.push_back("Joyjoy");
    names.push_back("Michael");
    names.push_back("Lucy");
    names.push_back("Lilei");

    std::sort(names.begin(), names.end());

    std::vector<std::string>::iterator iter = names.begin();

    while( iter != names.end() )
    {
        std::cout << *iter << "\n";
        ++iter;
    }

    return 0;
}

运行结果：

DingDing
Joyjoy
Larry
Lilei
Lucy
Michael
Rola

其中，sort()方法就是STL中的一个用于排序的算法。