C++ 模板数据类型解读

1、std::shared_ptr
shared_ptr是一种智能指针（smart pointer），作用有如同指针，但会记录有多少个shared_ptrs共同指向一个对象。这便是所谓的引用计数（reference counting）。
一旦最后一个这样的指针被销毁，也就是一旦某个对象的引用计数变为0，这个对象会被自动删除。

要确保用 new 动态分配的内存空间在程序的各条执行路径都能被释放是一件麻烦的事情。C++ 11 模板库的 头文件中定义的智能指针，即 shared _ptr 模板，就是用来部分解决这个问题的。

只要将 new 运算符返回的指针 p 交给一个 shared_ptr 对象“托管”，就不必担心在哪里写delete p语句——实际上根本不需要编写这条语句，托管 p 的 shared_ptr 对象在消亡时会自动执行delete p。而且，该 shared_ptr 对象能像指针 p —样使用，即假设托管 p 的 shared_ptr 对象叫作 ptr，那么 *ptr 就是 p 指向的对象。

通过 shared_ptr 的构造函数，可以让 shared_ptr 对象托管一个 new 运算符返回的指针，写法如下：
shared_ptr ptr(new T); // T 可以是 int、char、类等各种类型

此后，ptr 就可以像 T* 类型的指针一样使用，即 *ptr 就是用 new 动态分配的那个对象。

多个 shared_ptr 对象可以共同托管一个指针 p，当所有曾经托管 p 的 shared_ptr 对象都解除了对其的托管时，就会执行delete p。

2、std::condition_variable 是条件变量，更多有关条件变量的定义参考维基百科。Linux 下使用 Pthread 库中的 pthread_cond_*() 函数提供了与条件变量相关的功能， Windows 则参考 MSDN。

std::condition_variable
当 std::condition_variable 对象的某个 wait 函数被调用的时候，它使用 std::unique_lock(通过 std::mutex) 来锁住当前线程。当前线程会一直被阻塞，直到另外一个线程在相同的 std::condition_variable 对象上调用了 notification 函数来唤醒当前线程。

std::condition_variable 对象通常使用 std::unique_lockstd::mutex 来等待，如果需要使用另外的 lockable 类型，可以使用 std::condition_variable_any 类

3、std::mutex
互斥量是一个可以处于两态之一的变量:解锁和加锁。这样，只需要一个二进制位表示它，不过实际上，常常使用一个整型量，0表示解锁，而其他所有的值则表示加锁。互斥量使用两个过程。当一个线程(或进程)需要访问临界资源的临界区时，它调用mutex_lock。如果该互斥量当前是解锁的(即临界区可用)，此调用成功，调用线程可以自由进入该临界区。

4、std::function()
在C语言的时代，我们可以使用函数指针来吧一个函数作为参数传递，这样我们就可以实现回调函数的机制。到了C++11以后在标准库里引入了std::function模板类，这个模板概括了函数指针的概念
函数指针只能指向一个函数，而std::function对象可以代表任何可以调用的对象，比如说任何可以被当作函数一样调用的对象。
当你创建一个函数指针的时候，你必须定义这个函数签名（表征这个函数的入参，返回值等信息）；同样的，当你创建一个std::function对象的时候，你也必须指定它所代表的可调用对象的函数签名。这一点可以通过std::function的模板参数来实现。
举个例子来说，如果要定义一个std::function对象func，这个对象可以表示任何有如下函数签名的可调用对象的，
5、template

```cpp
#include<iostream>
#include<string>
using namespace std;

//template 关键字告诉C++编译器 下面是个泛型模板  
//数据类型T 参数化数据类型
template <typename T>
void generic_swap(T& a, T& b)
{
    cout << "Initial value: " << a << " : " << b << endl;

    T tmp;
    tmp = b;
    b = a;
    a = tmp;
}

int main()
{
    int a = 100, b = 50;
    generic_swap(a, b);
    cout << "excute the swap():" << a << " : " << b << endl;


    char c = 'A', d = 'B';
    generic_swap(c, d);
    cout << "excute the swap():" << c << " : " << d << endl;
    
    string e = "Jacky", f = "Lucy";
    generic_swap(e, f);
    cout << "excute the swap():" << e << " : " << f << endl;

    double j = 1.314, k = 5.12;
    generic_swap(j, k);
    cout << "excute the swap():" << j << " : " << k << endl;
    
    return 0;
}

6、std::bind 用来将可调用对象与其参数一起进行绑定。绑定后的结果可以使用 std::function进行保存，并延迟调用到任何我们需要的时候。

通俗来讲，它主要有两大作用：

1）将可调用对象与其参数一起绑定成一个仿函数。

2）将多元（参数个数为 n， n>1）可调用对象转成一元或者（ n-1）元可调用对象，即只绑定部分参数。

下面来看看它的实际使用，如代码所示。

#include <iostream> // std::cout
#include <functional> // std::bind

void call_when_even(int x, const std::function<void(int)>& f)
{
    if (!(x & 1)) // x % 2 == 0
    {
        f(x);
    }
}

void output(int x)
{
    std::cout << x << " ";
}

void output_add_2(int x)
{
    std::cout << x + 2 << " ";
}

int main(void)
{
    {
        auto fr = std::bind(output, std::placeholders::_1);
        for(int i = 0; i < 10; ++i)
        {
            call_when_even(i, fr);
        }
        std::cout << std::endl;
    }

    {
        auto fr = std::bind(output_add_2, std::placeholders::_1);
        for(int i = 0; i < 10; ++i)
        {
            call_when_even(i, fr);
        }
        std::cout << std::endl;
    }

    return 0;
}
输出结果如下：

0 2 4 6 8
2 4 6 8 10
同样还是上面 std::function 中最后的一个例子，只是在这里，我们使用了 std::bind，在函数外部通过绑定不同的函数，控制了最后的执行结果。

我们使用 auto fr 保存 std::bind 的返回结果，是因为我们并不关心 std::bind 真正的返回类型（实际上 std::bind 的返回类型是一个 stl 内部定义的仿函数类型），只需要知道它是一个仿函数，可以直接赋值给一个 std::function。当然，这里直接使用 std::function 类型来保存std::bind 的返回值也是可以的。

std::placeholders::_1 是一个占位符，代表这个位置将在函数调用时，被传入的第一个参数所替代。
7、std::enable_shared_from_this
C++11开始时支持 enable_shared_from_this，它一个模板类，定义在头文件 <memory>，其原型为： template< class T > class enable_shared_from_this;

std::enable_shared_from_this 能让其一个对象（假设其名为 t ，且已被一个 std::shared_ptr 对象 pt 管理）安全地生成其他额外的 std::shared_ptr 实例（假设名为 pt1, pt2, … ） ，它们与 pt 共享对象 t 的所有权。

若一个类 T 继承 std::enable_shared_from_this ，则会为该类 T 提供成员函数： shared_from_this 。 当 T 类型对象 t 被一个为名为 pt 的 std::shared_ptr 类对象管理时，调用 T::shared_from_this 成员函数，将会返回一个新的 std::shared_ptr 对象，它与 pt 共享 t 的所有权。