深入应用C++11：代码优化与工程级应用--note

2022-03-17

深入应用C++11：代码优化与工程级应用这本书的笔记，磨刀不误砍柴工。

auto/decltype

auto

使用

auto不仅可以自动推断变量类型，还能结合decltype来表示函数的返回值，这些新特性可以让我们写出更简洁、更现代的代码。

使用auto声明的变量必须马上初始化，以让编译器推断出它的实际类型，并在编译时将auto占位符替换为真正的类型。

当不声明为指针或引用时，auto的推导结果和初始化表达式抛弃引用和cv限定符后类型一致
当声明为指针或引用时，auto的推导结果将保持初始化表达式的cv属性
auto的推导和函数模板参数的自动推导有相似之处

int x = 1;
const auto e = x;   // e->const int
auto f = e; // f->int
const auto& g = x;  // g->const int&    
auto& h = g;    // h->const int&

auto一般会忽略掉顶层const,同时底层const则会保留下来，顶层const就是本身是常量，底层const就是指向的是常量。

比如若p的类型为const int，那么对于const auto q = p，q的类型是什么呢，q本身本身不是或者&，不保留p的const，但是p的const是个底层const，需要保留，则q类型最后为const int* const。

1 2	// type of p is const int* const auto q = p; // q->const int* const

限制

auto是不能用于函数参数的
void func(auto a = 1) {}
auto不能用于非静态成员变量
struct Foo {auto var_1 = 0;};
auto无法定义数组
auto rr[10] = arr;
无法推导出模版
Bar<int> bar; Bar<auto> bb = bar;

何时用auto?

1）提高迭代器的声明效率

比如resultMap.begin();其实可以明确表示一个迭代器，可以直接用auto,而不是用map<double,double>::iterator it之类的。

直接使用auto it = resultMap.begin()即可。

// 穿插一个euqal_range的用法
/**Template
pair
    equal_range (ForwardIterator first, ForwardIterator last, const T& val);

first: Forward iterator to the first element in the range.
last: Forward iterator to the last element in the range.
val: Value of the subrange to search for in the range.**/
int key = 1;
unordered_multimap<int, int> resultMap;
pair<unordered_multimap<int, int>::iterator,unordered_multimap<int, int>::iterator> range;
range = resultMap.equal_range(key);
// 函数的具体介绍如上，可以看到使用起来，会有很复杂的声明，有了auto就很快乐
auto range2 = resultMap.equal_range(key);

2）简化函数定义

class Foo {
public:
   static int get(void)
   {
      return 0;
   }
};
class Bar {
public:
   static const char* get(void)
   {
      return "0";
   }
};
template <class A>
void func(void)
{
   auto val = A::get();
   // ...
}

template <class A, class B>
void func2(void)
{
   B val = A::get();
   // ...
}
func<Foo>();
func<Bar>();
// 在这个例子里，我们希望定义一个泛型函数func，对所有具有静态get方法的类型A，在得到get的结果后做统一的后续处理。
// 若不使用auto，就不得不对func再增加一个模板参数，并在外部调用时手动指定get的返回值类型。
func2<Foo, int>();

当然不加选择地随意使用auto，会带来代码可读性和维护性的严重下降。

decltype

使用

auto所修饰的变量必须被初始化，编译器需要通过初始化来确定auto所代表的类型，即必须要定义变量。

若仅希望得到类型，而不需要（或不能）定义变量的时候应该怎么办呢？

C++11新增了decltype关键字，用来在编译时推导出一个表达式的类型: decltype(exp) exp表示一个表达式（expression）

int x = 0;
decltype(x) y = 1;            // y -> int
decltype(x + y) z = 0;        // z -> int
const int& i = x;
decltype(i) j = y;            // j -> const int &
const decltype(z) * p = &z;   // *p  -> const int, p  -> const int *
decltype(z) * pi = &z;        // *pi -> int      , pi -> int *
decltype(pi)* pp = &pi;      // *pp -> int *    , pp -> int * *

decltype通过表达式得到的类型，可以保留住表达式的引用及const限定符。

对于decltype和引用（&）结合的推导结果，与C++11中新增的引用折叠规则（Reference Collapsing）有关之后再讨论。

推导规则

exp是标识符、类访问表达式，decltype（exp）和exp的类型一致
exp是函数调用，decltype（exp）和返回值的类型一致
其他情况，若exp是一个左值，则decltype（exp）是exp类型的左值引用，否则和exp类型一致

左值 (lvalue, locator value) 表示了一个占据内存中某个可识别的位置（也就是一个地址）的对象。右值 (rvalue) 则使用排除法来定义。一个表达式不是左值就是右值。那么，右值是一个不表示内存中某个可识别位置的对象的表达式。

对于纯右值而言，只有类类型可以携带cv限定符，此外则一般忽略掉cv限定。

const int func_cint(void);  // 纯右值
decltype(func_cint()) c2 = 0;                // c2 -> int

struct Foo { int x; };
const Foo foo = Foo();
// foo.x是一个左值,且符合规则1
decltype(foo.x)   a = 0;                        // a -> int
// ((foo.x))是一个左值,符合规则3
decltype((foo.x)) b = a;                        // b -> const int &
int n = 0, m = 0;
// n + m 返回一个右值
decltype(n + m) c = 0;                           // c -> int
// n += m 返回一左值
decltype(n += m) d = c;                          // d -> int &

decltype的实际应用

template <class ContainerT>
class Foo2
{
   typename ContainerT::iterator it_; // 类型定义可能有问题
  // decltype(ContainerT().begin()) it_;
public:
   void func(ContainerT& container)
   {
      it_ = container.begin();
   }
   // ...
};
typedef const std::vector<int> container_t;
container_t arr;
Foo2<container_t> foo2;
foo2.func(arr);

Container::iterator不能包括所有迭代器类型，当ContainerT是一个const类型时，要使用const_iterator，所以这段代码会报错。

解决这个问题首先想到的方法肯定是特化template，但是会增加很多冗余的代码，这时候就可以直接这么写: decltype(ContainerT().begin()) it_;。

返回类型后置语法——auto和decltype的结合使用

在泛型编程中，可能需要通过参数的运算来得到返回值的类型。

template <typename R, typename T, typename U>
R add(T t, U u)
{
   return t+u;
}

int a = 1; float b = 2.0;
auto c = add<decltype(a + b)>(a, b);
//我们并不关心a+b的类型是什么，因此，只需要通过decltype（a+b）直接得到返回值类型即可。但是像上面这样使用十分不方便，因为外部其实并不知道参数之间应该如何运算，只有add函数才知道返回值应当如何推导。
template <typename T, typename U>
    decltype(t + u) add(T t, U u) // error: t、u尚未定义

// 可行的写法
template <typename T, typename U>
decltype(T() + U()) add2(T t, U u)
{
   return t + u;
}
// 考虑到T、U可能是没有无参构造函数的类，正确的写法应该是这样：
// 这里其实就是把0的类型变成T
template <typename T, typename U>
decltype((*(T*)0) + (*(U*)0)) add3(T t, U u)
{
   return t + u;
}
// 虽然成功地使用decltype完成了返回值的推导，但写法过于晦涩
//因此，在C++11中增加了返回类型后置（trailing-return-type，又称跟踪返回类型）语法，将decltype和auto结合起来完成返回值类型的推导。
template <typename T, typename U>
auto add4(T t, U u) -> decltype(t + u)
{
   return t + u;
}
// 再给一个例子
int& foo(int& i);
float foo(float& f);
template <typename T>
auto func(T& val) -> decltype(foo(val))
{
   return foo(val);
}

模板的细节改进

重定义一个模板

使用typedef重定义类型是很方便的，但它也有一些限制，比如，无法重定义一个模板。

因此，在C++98/03中往往不得不这样写：

template <typename Val>
struct str_map
{
   typedef std::map<std::string, Val> type;
};
// ...
str_map<int>::type map1;
// ...

一个虽然简单但却略显烦琐的str_map外敷类是必要的。这明显让我们在复用某些泛型代码时非常难受。

现在，在C++11中终于出现了可以重定义一个模板的语法。请看下面的示例：

template <typename Val>
using str_map_t = std::map<std::string, Val>;
// ...
str_map_t<int> map1;

在重定义普通类型上，using，typedef两种使用方法的效果是等价的，唯一不同的是定义语法。

typedef的定义方法和变量的声明类似：像声明一个变量一样，声明一个重定义类型，之后在声明之前加上typedef即可。这种写法凸显了C/C++中的语法一致性， Apple Books. “但有时却会增加代码的阅读难度。比如重定义一个函数指针时：

typedef void (*func_t)(int, int);
与之相比，using后面总是立即跟随新标识符（Identifier），之后使用类似赋值的语法，把现有的类型（type-id）赋给新类型：

using func_t = void (*)(int, int);
从上面的对比中可以发现，C++11的using别名语法比typedef更加清晰。

函数模板的默认模板参数

参数填充顺序是从右往左的。

template <typename R = int, typename U>
R func(U val)
{
   ret val
}
int main(void)
{
   func(123);
   return 0;
}
func<long>(123); // func的返回值类型是long

函数模板func的返回值类型是long，而不是int，因为模版参数的填充顺序从右往左，所以指定的模版参数类型long会作为func的参数类型而不是func的返回类型，最终func的返回类型为long。这个细节虽然简单，但在多个默认模板参数和模板参数自动推导穿插使用时很容易被忽略掉，造成使用时的一些意外。

初始化列表

C++11中的stl容器拥有和未显示指定长度的数组一样的初始化能力，代码如下：

int arr[] { 1, 2, 3 };
map<std::string, int> mm =
{
   { "1", 1 }, { "2", 2 }, { "3", 3 }
};
set<int> ss = { 1, 2, 3 };
vector<int> arr2 = { 1, 2, 3, 4, 5 };

但是自定义的class却不具备这种能力

实际上，stl中的容器是通过使用std::initializer_list这个轻量级的类模版来完成上述功能支持的

同理，我们只需要对自定义的class添加一个std::initializer_list构造函数，也可以拥有任意长度初始化的能力

class FooVector{
private:
    vector<int> content_;
public:
    FooVector(initializer_list<int> list) {
        for (auto it = list.begin(); it != list.end(); it++)
            content_.push_back(*it);
    }
};

FooVector foo_1 = {1,2,3,4,5};

std：：initializer_list不仅可以用来对自定义类型做初始化，还可以用来传递同类型的数据集合，代码如下：

void func(std::initializer_list<int> l)
{
   for (auto it = l.begin(); it != l.end(); ++it)
   {
      std::cout << *it << std::endl;
   }
}

func({});           // 一个空集合
func({ 1, 2, 3 });  // 传递{ 1, 2, 3 }

initializer_list的一些细节

对于std：：initializer_list而言，它可以接收任意长度的初始化列表，但要求元素必须是同种类型T（或可转换为T）。
他有三个成员接口：size(),begin(),end()
它只能被整体初始化或赋值
initializer_list的访问只能通过begin（）和end（）进行循环遍历，遍历时取得的迭代器是只读的，但是可以整体修改

initializer_list<int> list;
size_t n = list.size(); // n == 0
list = { 1, 2, 3, 4, 5 };
n = list.size();        // n == 5
list = { 3, 1, 2, 4 };
n = list.size();        // n == 4

initializer_list是非常高效的。它的内部并不负责保存初始化列表中元素的拷贝，仅仅存储了列表中元素的引用而已

所以，它本身做传递或赋值的时候是十分高效的的，但在处理函数返回值的时候需要小心，代码如下：

initializer_list<int> func(void) {
   int a = 1, b = 2;
   return { a, b }; // a、b在返回时并没有被拷贝
}

vector<int> func2(void)
{
   int a = 1, b = 2;
   return { a, b };
}

使用真正的容器，或具有转移/拷贝语义的物件来替代std：：initializer_list返回需要的结果。我们应当总是把std：：initializer_list看做保存对象的引用，并在它持有对象的生存期结束之前完成传递。

for/range

for : 循环

本身这个知识点原本是不打算介绍的，但是发现了一些有趣的点，所以还是记录一下

vector<int>arr = { 1, 2, 3, 4, 5 };
for(auto val : arr) {
	cout << val << std::endl;  
  arr.push_back(0); // 扩大容器
}

// 这段代码其实没什么，但输出的结果可能会出乎你的意料
/**1
5189584
-17891602
-17891602
-17891602**/

同普通的for循环一样，在迭代时修改容器很可能会引起迭代器失效，导致一些意料之外的结果

原因是对于上面的基于范围的for循环而言，等价的代码如下

vector<int> arr2 = { 1, 2, 3, 4, 5 };
auto && __range = (arr2);
for (auto __begin = __range.begin(), __end = __range.end();
     __begin != __end; ++__begin) {
    auto val = *__begin;
    std::cout << val << std::endl;
    arr.push_back(0); // 扩大容器
}

从这里可以很清晰地看到，和我们平时写的容器遍历不同，基于范围的for循环倾向于在循环开始之前确定好迭代的范围，而不是在每次迭代之前都去调用一次arr.end()

另外一个要点是，大部分关联性容器，比如map,set在遍历时，是不允许修改元素的，因为对应的容器本身的内部元素是只读的，auto获得的类型会带上const

让基于范围的for循环支持自定义类型

对自定义类类型来说，分别实现begin（）、end（）方法即可

例子1:实现一个支持步长的range方法

这个例子其实更重要的倒不是上述的知识点，而是给了如何实现一个通用方法的思路

设计方法的作用，以及使用这个方法的类型需要满足哪些接口
设计对应的类，并实现这个类的对应接口
这个类的底层元素结构该如何实现，通俗的说不通的类型实现相同的接口，但每个底层接口的实现可以不一样，因为方法只需要有对应接口的支持，但不管接口的底层如何实现
设计的顺序从上至下，但是编写的顺序，可以正向或者相反
这个例子充分的表明了，顶层设计的合理远比盲目编写代码要强得多

// 自定义class，支持range方法
// 自定义一个迭代器，负责对一个范围取值
namespace detail_range {
template <typename T>
class my_iterator {
public:
   using value_type = T;
   using size_type = size_t;
private:
   size_type        cursor_;    // 开始的迭代次数
   const value_type step_;  // 迭代的步长
   value_type       value_; // 初始值
public:
    // 这里为何不直接使用iterator当中的值做比较呢？这是因为迭代的步长step并不一定是begin-end的约数。如果我们直接采用iterator中的值做比较，就不能使用！=了
    my_iterator(size_type cur_start, value_type begin_val, value_type step_val)
      : cursor_(cur_start)
      , step_  (step_val)
      , value_ (begin_val) {
          value_ += (step_ * cursor_);
   }
   value_type operator*() const { return value_; }
   bool operator!=(const my_iterator& rhs) const {
      return (cursor_ != rhs.cursor_);
   }
    // prefix ++ operator only
   my_iterator& operator++(void) {
       value_ += step_;
       ++cursor_;
       return (*this);
   }
};
}

// impl是range函数最终返回的一个类似容器的对象,是range类型的具体实现
namespace detail_range {
template <typename T>
class impl
{
public:
    using value_type      = T;
    using reference       = const value_type&;
    using const_reference = const value_type&;
    using const_my_iterator  = const detail_range::my_iterator<value_type>;
    using my_iterator     = const detail_range::my_iterator<value_type>;
    using size_type       = typename my_iterator::size_type;
private:
    const value_type begin_;
    const value_type end_;
    const value_type step_;
    const size_type  max_count_;
    size_type get_adjusted_count(void) const {
        if (step_ > 0 && begin_ >= end_)
            throw std::logic_error("End value must be greater than begin value.");
        else
            if (step_ < 0 && begin_ <= end_)
                throw std::logic_error("End value must be less than begin value.");
        size_type x = static_cast<size_type>((end_ - begin_) / step_);
        if (begin_ + (step_ * x) != end_) ++x;
        return x;
    }
public:
    impl(value_type begin_val, value_type end_val, value_type step_val)
          : begin_(begin_val)
          , end_  (end_val)
          , step_ (step_val)
          , max_count_(get_adjusted_count()) {}
    size_type size(void) const {
        return max_count_;
    }
    const_my_iterator begin(void) const {
        return { 0, begin_, step_ };
    }
    const_my_iterator end(void) const {
        return { max_count_, begin_, step_ };
    }
};
}

// range的外覆函数模板
template <typename T>
detail_range::impl<T> range(T end)
{
   return{ {}, end, 1 };
}
template <typename T>
detail_range::impl<T> range(T begin, T end)
{
   return{ begin, end, 1 };
}
template <typename T, typename U>
auto range(T begin, T end, U step)
   -> detail_range::impl<decltype(begin + step)>
{
   // may be narrowing
   using r_t = detail_range::impl<decltype(begin + step)>;
   return r_t(begin, end, step);
}

关于这个设计思路，我打算自己实现一个能够可以让forward_list和list都是用的insert方法，思路也是从上至下，先设计方法，在设计list，最后设计iterator，可能最终实现的不会特别好，但可以练习这个思路，代码地址：https://github.com/woaixiaoyuyu/Trip-of-learning-C-Plus/tree/main/myList

std::function和bind绑定器

C++中的可调用对象虽然具有比较统一的操作形式（除了类成员指针之外，都是后面加括号进行调用），但定义方法五花八门。这样在我们试图使用统一的方式保存，或传递一个可调用对象时，会十分烦琐。

C++11通过提供std：：function和std：：bind统一了可调用对象的各种操作

可调用对象

可调用对象有如下几种定义：

是一个函数指针。
是一个具有operator（）成员函数的类对象（仿函数）。
是一个可被转换为函数指针的类对象。
是一个类成员函数指针 or 类成员指针。

std::function

std：：function是可调用对象的包装器。它是一个类模板，可以容纳除了类成员（函数）指针之外的所有可调用对象。通过指定它的模板参数，它可以用统一的方式处理函数、函数对象、函数指针，并允许保存和延迟执行它们。

针对以上提出的概念，我们一点一点来实践。

std::function的基本用法

void func3(void)
{
   std::cout << __FUNCTION__ << std::endl;
}
class Foo4
{
public:
   static int foo_func(int a)
   {
      std::cout << __FUNCTION__ << "(" << a << ") ->: ";
      return a;
   }
};
class Bar2 {
public:
   int operator()(int a)
   {
      std::cout << __FUNCTION__ << "(" << a << ") ->: ";
      return a;
   }
};

function<void(void)> fr1 = func3;   // 绑定一个普通函数
function<int(int)> fr2 = Foo4::foo_func;    // 绑定一个类的静态成员函数
Bar2 bar;
fr2 = bar;  // 绑定一个仿函数

当我们给std：：function填入合适的函数签名（即一个函数类型，只需要包括返回值和参数表）之后，它就变成了一个可以容纳所有这一类调用方式的“函数包装器。

function作为回调函数的事例

这个例子的构思非常精巧，相比于function的用法，设计思路更值得学习，这里替代了函数指针的作用。

class A {
   function<void(void)> callback_;
public:
   A(const function<void(void)>& f)
      : callback_(f) {}
   void notify(void) {
      callback_();   // 回调到上层
   }
};
class Foo5 {
public:
   void operator()(void) {
      cout << __FUNCTION__ << endl;
   }
};

Foo5 foo;
A aa(foo);
aa.notify();

function比普通函数指针更灵活和便利，而且用这种写法替换函数指针，可以让别人一眼就看出这里需要的是函数之争，可读性也会大大增强。

std::bind

基础使用

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

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

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

这里可能看得不是很明白，来一个例子。

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

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

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

{
    // placeholders：：_1是一个占位符，代表这个位置将在函数调用时，被传入的第一个参数所替代。
    // 通过使用std：：placeholders，来决定空位参数将会属于调用发生时的第几个参数。
    auto fr = bind(output, placeholders::_1);
    for(int i = 0; i < 10; ++i) {
         call_when_even(i, fr);
      }
      cout << endl;
}
{
      auto fr = bind(output_add_2, placeholders::_1);
      for(int i = 0; i < 10; ++i) {
         call_when_even(i, fr);
      }
      cout << endl;
}

上面只是绑定普通函数，再来看一个绑定类成员函数指针 and 类成员指针的例子。

class A2 {
public:
   int i_ = 0;
   void output(int x, int y)
   {
      std::cout << x << " " << y << std::endl;
   }
};

A2 a;
function<void(int, int)> fr3 = bind(&A2::output, &a, placeholders::_1, placeholders::_2);
fr3(1, 2);                                            // 输出: 1 2
function<int&(void)> fr_i = bind(&A2::i_, &a);
fr_i() = 123;
cout << a.i_ << endl; // 输出    : 123

可以看到涉及到类成员函数指针 or 类成员指针,需要先把已经实例化的成员和对应的类成员绑定，当然如果是静态成员函数，没必要实例化成员，因为编译阶段就有地址了。

使用组合bind函数

bind还有一个强大之处就是可以组合多个函数，结构上有点像函数式编程，但其实并不是。

auto f = bind(logical_and<bool>(),
              bind(greater<int>(), placeholders::_1, 5),
              bind(less_equal<int>(), placeholders::_1, 10));
vector<int> coll = {1,2,3,11,20,6};
int count = (int)std::count_if(coll.begin(), coll.end(), f);
cout << count << endl;

lambda表达式

lambda表达式的优点

lambda表达式有如下优点：

声明式编程风格：就地匿名定义目标函数或函数对象，不需要额外写一个命名函数或者函数对象。以更直接的方式去写程序，好的可读性和可维护性。
简洁：不需要额外再写一个函数或者函数对象，避免了代码膨胀和功能分散，让开发者更加集中精力在手边的问题，同时也获取了更高的生产率。
在需要的时间和地点实现功能闭包，使程序更灵活。

lambda表达式的概念和基本用法

lambda表达式的语法形式可简单归纳如下：

[ capture ] ( params ) opt -> ret { body; };

capture是捕获列表；params是参数表；opt是函数选项；ret是返回值类型；body是函数体。

因此，一个完整的lambda表达式看起来像这样：

1 2	auto f = [](int a) -> int { return a + 1; }; cout << f(1) << endl; // 输出: 2

接下俩介绍一下capture的类别

[]不捕获任何变量。
[&]捕获外部作用域中所有变量，并作为引用在函数体中使用（按引用捕获）。
[=]捕获外部作用域中所有变量，并作为副本在函数体中使用（按值捕获）。
[=，&foo]按值捕获外部作用域中所有变量，并按引用捕获foo变量。
[bar]按值捕获bar变量，同时不捕获其他变量。
[this]捕获当前类中的this指针，让lambda表达式拥有和当前类成员函数同样的访问权限。如果已经使用了&或者=，就默认添加此选项。捕获this的目的是可以在lamda中使用当前类的成员函数和成员变量。

class A3 {
public:
    int i_ = 0;
    void func(int x, int y) {
        // auto x1 = []{ return i_; };                    // error，没有捕获外部变量
        auto x2 = [=]{ return i_ + x + y; };           // OK，捕获所有外部变量
        auto x3 = [&]{ return i_ + x + y; };           // OK，捕获所有外部变量
        auto x4 = [this]{ return i_; };                // OK，捕获this指针
        // auto x5 = [this]{ return i_ + x + y; };        // error，没有捕获x、y
        auto x6 = [this, x, y]{ return i_ + x + y; };  // OK，捕获
        auto x7 = [this]{ return i_++; };              // OK，捕获this指针，并修改成员的值
    }
};

延迟调用

int a = 0;
auto f2 = [=]{ return a; };                                  // 按值捕获外部变量
a += 1;                                                     // a被修改了
cout << f2() << std::endl;                                    // 输出0
// 在捕获的一瞬间，a的值就已经被复制到f中了,a被修改，但此时f中存储的a仍然还是捕获时的值，因此，最终输出结果是0。如果希望lambda表达式在调用时能够即时访问外部变量，我们应当使用引用方式捕获。

// 如果打算修改按值捕获的外部变量，需要显式指明lambda表达式为mutable，当然了，这是值传递，表达式内再怎么修改，也不会影响到实际的外部变量。

auto f3 = [=]() mutable { return a++; }; // OK，mutable

lambda表达式的类型

lambda表达式的类型在C++11中被称为“闭包类型（Closure Type）”。它是一个特殊的，匿名的非nunion的类类型。

因此，我们可以认为它是一个带有operator（）的类，即仿函数。因此，我们可以使用std：：function和std：：bind来存储和操作lambda表达式：

1 2	function<int(int)> f4 = [](int a){ return a; }; function<int(void)> f5 = bind([](int a){ return a; },123);

另外，对于没有捕获任何变量的lambda表达式，还可以被转换成一个普通的函数指针。而被捕获的lambda表达式则不能转换为函数指针：

1
2
3

using func_t = int(*)(int);
func_t f6 = [](int a){ return a; };
f6(123);

lambda表达式可以说是就地定义仿函数闭包的“语法糖”。它的捕获列表捕获住的任何外部变量，最终均会变为闭包类型的成员变量。而一个使用了成员变量的类的operator（），如果能直接被转换为普通的函数指针，那么lambda表达式本身的this指针就丢失掉了。而没有捕获任何外部变量的lambda表达式则不存在这个问题。

这里也可以很自然地解释为何按值捕获无法修改捕获的外部变量。因为按照C++标准，lambda表达式的operator（）默认是const的。一个const成员函数是无法修改成员变量的值的。而mutable的作用，就在于取消operator（）的const。

tuple元组

tuple元组是一个固定大小的不同类型值的集合，是泛化的std：：pair

tuple的基本使用

tuple<const char*, int> tp = make_tuple("hello",3);
// 这个tuple等价于一个结构体：

struct A {
  char* p;           
  int len;
};

用tuple<const char*，int>tp就可以不用创建这个结构体了，而作用是一样的，更简洁直观了。

用std::tie，它会创建一个元组的左值引用。

int a = 1;
string b = "bb";
auto tp2 = tie(a,b,a);  // “tp2的类型实际是：std::tuple<int&,string&, int&>
int len = get<0>(tp2); // 获取第二个值
int x,y;
tie(x,ignore,y) = tp2;    // 还可以用tie解包，会自动复制给变量，ignore可以用来当占位符

tuple虽然可以用来代替简单的结构体，但不要滥用，如果用tuple来替代3个以上字段的结构体时就不太合适了，因为使用tuple可能会导致代码的易读性降低。

tuple<int, string, float> t1(10, "Test", 3.14);

int n = 7;

// 还可以通过tuple_cat连接多个tupe
auto t2 = tuple_cat(t1, make_pair("Foo", "bar"), t1, tie(n));

右值引用

C++11增加了一个新的类型，称为右值引用（R-value reference），标记为T&&。在介绍右值引用类型之前先要了解什么是左值和右值。左值是指表达式结束后依然存在的持久对象，右值是指表达式结束时就不再存在的临时对象。一个区分左值与右值的便捷方法是：看能不能对表达式取地址，如果能，则为左值，否则为右值。所有的具名变量或对象都是左值，而右值不具名。

来看一个例子

int g_constructCount=0;
int g_copyConstructCount=0;
int g_destructCount=0;

struct A {
    A() {
        cout<<"construct: "<<++g_constructCount<<endl;
    }
    A(const A& a) {
        cout<<"copy construct: "<<++g_copyConstructCount <<endl;
    }
    ~A() {
        cout<<"destruct: "<<++g_destructCount<<endl;
    }
};
A GetA()
{
    return A();
}

A a = GetA();

/**construct: 1     由最里层的A()调用
copy construct: 1   return A()调用，生成一个临时变量
destruct: 1         A()自身创建的局部变量销毁
copy construct: 2   将临时变量copy给a
destruct: 2         销毁临时变量
destruct: 3         销毁a */

// 如果通过右值引用来绑定含糊返回值，结果如下
A&& a2 = GetA();
/**construct: 1     由最里层的A()调用
copy construct: 1   return A()调用，生成一个临时变量
destruct: 1         A()自身创建的局部变量销毁
destruct: 2         销毁a和临时变量    */

通过右值引用，比之前少了一次拷贝构造和一次析构，原因在于右值引用绑定了右值，让临时右值的生命周期延长了，我们可以利用这个特点做一些性能优化，即避免临时对象的拷贝构造和析构。

再来一个例子

如果&&被一个左值初始化，它就是一个左值；如果它被一个右值初始化，它就是一个右值

int w1, w2; // w1,w2都是左值
auto&& v1 = w1; // v1的类型在没初始化前，不能确定是左值还是右值引用，所以类型是universal reference    
// v1初始化时，w1是左值，即v1也为左值，类型为int&
// decltype(w1)&& v2 = w2; // v2类型再初始化前就确定为int&&，为右值引用，所以用左值初始化会报错

// 如果希望把左值赋给一个右值引用类型，需要要是用std::move
decltype(w1)&& v2 = move(w2);  // move可以将一个左值转换成右值

编译器会将已命名的右值引用视为左值，而将未命名的右值引用视为右值

void PrintValue(int& i) {
    std::cout<<"lvalue : "<<i<<std::endl;
}
void PrintValue(int&& i) {
    std::cout<<"rvalue : "<<i<<std::endl;
}
void Forward(int&& i) {
    PrintValue(i);
}

int i = 0;
PrintValue(i); // i是左值，lvalue 0
PrintValue(1); // 1是右值，rvalue 1
Forward (2);  // 2是右值,forward接受右值引用，传递给printvalue时传递的是左值，lvalue 2

&&的总结如下：

左值和右值是独立于它们的类型的，右值引用类型可能是左值也可能是右值。
auto&&或函数参数类型自动推导的T&&是一个未定的引用类型，被称为universal references，它可能是左值引用也可能是右值引用类型，取决于初始化的值类型。
所有的右值引用叠加到右值引用上仍然是一个右值引用，其他引用折叠都为左值引用。当T&&为模板参数时，输入左值，它会变成左值引用，而输入右值时则变为具名的右值引用。
编译器会将已命名的右值引用视为左值，而将未命名的右值引用视为右值。

用来支持移动语义

右值引用的一个重要目的是用来支持移动语义的。

移动语义可以将资源（堆、系统对象等）通过浅拷贝方式从一个对象转移到另一个对象，这样能够减少不必要的临时对象的创建、拷贝以及销毁，可以大幅度提高C++应用程序的性能，消除临时对象的维护（创建和销毁）对性能的影响。

class A2 {
public:
    A2() :m_ptr(new int(0)) {
        cout << "construct" << endl;
    }
    // 深拷贝
    A2(const A2& a):m_ptr(new int(*a.m_ptr)) {
        cout << "copy construct" << endl;
    }
    A2(A2&& a) :m_ptr(a.m_ptr) {
        a.m_ptr = nullptr;
        cout << "move construct: " << endl;
    }
    ~A2() {
        cout << "destruct" << endl;
        delete m_ptr;
    }
private:
    int* m_ptr;
};

A2 Get2(bool flag) {
    A2 a;
    A2 b;
    if (flag)
        return a;
    else
        return b;
}

A2 a3 = Get2(false);
/**construct
construct
move construct
destruct
destruct
destruct*/

上面的代码中没有了拷贝构造，取而代之的是移动构造（Move Construct）。从移动构造函数的实现中可以看到，它的参数是一个右值引用类型的参数A&&，这里没有深拷贝，只有浅拷贝，避免了深拷贝，提高了性能。

需要注意的一个细节是，我们提供移动构造函数的同时也会提供一个拷贝构造函数，以防止移动不成功的时候还能拷贝构造，使我们的代码更安全。

move语义

移动语义是用过右值引用来匹配临时值，c++11提供了std::move方法来将左值转换为右值。
move是将对象的状态或者所从权从一个对象转移到另一个对象，只是转移，没有拷贝。

在图2-1中，对象SourceObject中有一个Source资源对象，如果是深拷贝，要将SourceObject拷贝到DestObject对象中，需要将Source拷贝到DestObject中；如果是move语义，要将SourceObject移动到DestObject中，只需要将Source资源的控制权从SourceObject转移到DestObject中，无须拷贝。

move实际上并不能移动任何东西，它唯一的功能是将一个左值强制转换为一个右值引用 [1] ，使我们可以通过右值引用使用该值，以用于移动语义。


A& A::operator=(const A& rhs) {
  // 销毁m_ptr指向的资
  // 复制rhs.m_ptr所指的资源，并使m_ptr指向它
}
    
A foo();
A a;
a = foo();
    
/**最后一行将会发生如下操作：

·销毁a所持有的资源。

·复制foo返回的临时对象所拥有的资源。

·销毁临时对象，释放其资源。*/

A& A::operator=(const A&& rhs) {
    // 转移资源的控制权，无需复制
}

这里也要注意对move语义的误解，move只是转移了资源的控制权，本质上是将左值强制转换为右值引用，以用于move语义，避免含有资源的对象发生无谓的拷贝。move对于拥有形如对内存、文件句柄等资源的成员的对象有效。如果是一些基本类型，比如int和char[10]数组等，如果使用move，仍然会发生拷贝（因为没有对应的移动构造函数），所以说move对于含资源的对象来说更有意义。

forward和完美转发

之前提到过，一个右值引用参数作为函数的形参，在函数内部再转发该参数的时候它已经变成一个左值了，并不是它原来的类型了。

所谓完美转发（Perfect Forwarding），是指在函数模板中，完全依照模板的参数的类型（即保持参数的左值、右值特征），将参数传递给函数模板中调用的另外一个函数。

C++11中提供了这样的一个函数std：：forward，它是为转发而生的，不管参数是T&&这种未定的引用还是明确的左值引用或者右值引用，它会按照参数本来的类型转发。

举个例子

template<typename T>
void PrintT(T& t)
{
   cout <<"lvaue"<< endl;
}
template<typename T>
void PrintT(T && t)
{
   cout <<"rvalue"<< endl;
}
template<typename T>
void TestForward(T && v)
{
   PrintT(v);
   PrintT(std::forward<T>(v));
   PrintT(std::move(v));
}

TestForward(1);
int x = 1;
TestForward(x);
TestForward(std::forward<int>(x));

// 结果如下
// lvaue
// rvalue
// rvalue

// lvalue
// lvalue
// rvalue

// lvalue
// lvalue   // 这里我思考错了，其实应该是rvalue
// rvalue

// 分析一下为什么这里是rvalue，因为这里搞错了一个细节，保留的参数类型是保留模版的参数类型，不是实参的参数类型

函数包装器

右值引用、完美转发再结合可变模板参数，我们可以写一个万能的函数包装器，带返回值的、不带返回值的、带参数的和不带参数的函数都可以委托这个万能的函数包装器执行。下面看看这个万能的函数包装器。

template<class Function, class... Args>
inline auto FuncWrapper(Function && f, Args && ... args) -> decltype(f(std::forward<Args>(args)...)) {
         return f(std::forward<Args>(args)...);
}

void test0() {
    cout <<"void"<< endl;
}

int test1() {
    return 1;
}

int test2(int x) {
    return x;
}

string test3(string s1, string s2) {
    return s1 + s2;
}

FuncWrapper(test0); // void
cout << FuncWrapper(test1) << endl; // 1
cout << FuncWrapper(test2,1) << endl;   // 1
cout << FuncWrapper(test3,"aa","bb") << endl;   // aabb

emplace_back减少内存拷贝和移动

emplace_back能就地通过参数构造对象，不需要拷贝或者移动内存，相比push_back能更好地避免内存的拷贝与移动，使容器插入元素的性能得到进一步提升。在大多数情况下应该优先使用emplace_back来代替push_back。

emplace_back的用法比较简单，直接通过构造函数的参数就可以构造对象，因此，也要求对象有对应的构造函数，如果没有对应的构造函数，编译器会报错。

emplace_back和push_back的比较

struct Complicated {
    int year;
    double country;
    std::string name;
    Complicated(int a, double b, string c):year(a),country(b),name(c) {
        cout<<"is constucted"<<endl;
    }
    Complicated(const Complicated&other):year(other.year),country(other.country),name(std::move(other.name)) {
        cout<<"is moved"<<endl;
    }
};

std::map<int, Complicated> m;
int anInt = 4;
double aDouble = 5.0;
std::string aString = "C++";
cout<<"—insert--"<<endl;
m.insert(std::make_pair(4, Complicated(anInt, aDouble, aString)));
/**
 -insert-
 is constructed
 is moved
 is moved*/
cout<<"—emplace--"<<endl;
// should be easier for the optimizer
m.emplace(4, Complicated(anInt, aDouble, aString));
/**
 -emplace-
 is constructed
 is moved
 */
cout<<"--emplace_back--"<<endl;
vector<Complicated> v;
v.emplace_back(anInt, aDouble, aString);
/**
-emplace_back-
is constructed
*/
cout<<"--push_back--"<<endl;
v.push_back(Complicated(anInt, aDouble, aString));
/**
-push_back-
is constructed
is moved
is moved*/

emplace/emplace_back的性能比之前的insert和push_back的性能要提高很多，我们应该尽量用emplace/emplace_back来代替原来的插入元素的接口以提高性能。

需要注意的是，我们还不能完全用emplace_back来取代push_back等老接口，因为在某些场景下并不能直接使用emplace来进行就地构造，比如，当结构体中没有提供相应的构造函数时就不能用emplace了，这时就只能用push_back。

unordered container无序容器

C++11增加了无序容器unordered_map/unordered_multimap和unordered_set/unordered_multiset，由于这些容器中的元素是不排序的，因此，比有序容器map/multimap和set/multiset效率更高。map和set内部是红黑树，在插入元素时会自动排序，而无序容器内部是散列表（Hash Table），通过哈希（Hash），而不是排序来快速操作元素，使得效率更高。由于无序容器内部是散列表，因此无序容器的key需要提供hash_value函数，其他用法和map/set的用法是一样的。

不过对于自定义的key，需要提供Hash函数和比较函数。

基本用法

struct Key {
    std::string first;
    std::string second;
};

struct KeyHash {
    std::size_t operator()(const Key& k) const {
        return std::hash<std::string>()(k.first) ^ (std::hash<std::string>()(k.second) << 1);
    }
};

struct KeyEqual {
    bool operator()(const Key& lhs, const Key& rhs) const {
        return lhs.first == rhs.first && lhs.second == rhs.second;
    }
};

// default constructor: empty map
std::unordered_map<std::string, std::string> m1;
// list constructor
std::unordered_map<int, std::string> m2 = {
    {1, "foo"},
    {3, "bar"},
    {2, "baz"},
};
// copy constructor
std::unordered_map<int, std::string> m3 = m2;
// move constructor
std::unordered_map<int, std::string> m4 = std::move(m2);
// range constructor
std::vector<std::pair<std::bitset<8>, int>> v = { {0x12, 1}, {0x01,-1} };
std::unordered_map<std::bitset<8>, double> m5(v.begin(), v.end());
// constructor for a custom type
// 对于自定义的结构体，就稍微复杂一些，需要提供函数和比较函数。
std::unordered_map<Key, std::string, KeyHash, KeyEqual> m6 = {
    { {"John", "Doe"}, "example"},
    { {"Mary", "Sue"}, "another"}
};

type_traits – 类型萃取

基本的type_traits

简单的type_traits

先看看在C++11之前，在一个类中定义编译期常量的一些方法，可以直接定义一个static成员变量来实现。

template<typename Type>
struct GetLeftSize {
  static const int value = 1;
};

当然也可以直接如下面这般定义，同样可以根据GetLeftSize::value来获得常量1。

1 2	template<typename Type> struct GetLeftSize : std::integral_constant<int, 1> {};

为什么可以用第二种方法来实现，来看看将编译期常量包装为一个类型的type_trait——integral_constant，代码如下

template <class T, T v>
struct integral_constant {
    static const T value = v;
    typedef T value_type;
    typedef integral_constant<T,v> type;
    operator value_type() {return value;}
};

相当于直接public继承了integral_constant这个struct，而integral_constant的value又是个public成员变量，子类可以直接调用

类型判断type_traits

有些type_traits从std::integral_constant派生，用来检查模版类型会否为某种类型，通过这些trait可以获取编译器检查的bool值结果。

因此可以通过std：：is_xxx：：value是否为true来判断模板类型是否为目标类型，用法如下

std::cout << "is_const:" << std::endl;
std::cout << "int: " << std::is_const<int>::value << std::endl; // false
std::cout << "const int: " << std::is_const<const int>::value << std::endl; // true
std::cout << "const int&: " << std::is_const<const int&>::value << std::endl;   // false
std::cout << "const int*: " << std::is_const<const int*>::value << std::endl;   // false
std::cout << "int* const: " << std::is_const<int* const>::value << std::endl;   // true

这里判断一个类型是否为const，判断的是顶层是否为const，所以这里const int*判断为false，因为虽然指向的内容是const，但是指针本身不为const。同理const int& 也返回false，int& const返回的就是true。

判断两个类型之间的关系traits

上一小节的traits是检查某一个模板的类型，有时需要检查两个模板类型之间的关系，比如两个类型是否相同或是否为继承关系等。

class A {};
class B : public A {};
class C {};

std::cout<< std::is_same<int, int>::value<<"\n";             // true
std::cout<< std::is_same<int, unsigned int>::value<<"\n";     // false
std::cout<< std::is_same<int, signed int>::value<<"\n";       // true

std::cout<<std::is_base_of<A, B>::value<<'\n';  // 1
std::cout<<std::is_base_of<B, A>::value<<'\n';  // 0
std::cout<<std::is_base_of<C, B>::value<<'\n';  // 0

bool b2a = std::is_convertible<B*, A*>::value;
bool a2b = std::is_convertible<A*, B*>::value;
bool b2c = std::is_convertible<B*, C*>::value;
std::cout<<std::boolalpha;
std::cout<< b2a <<'\n'; // true
std::cout<< a2b <<'\n'; // false
std::cout<< b2c <<'\n'; // false

std：：is_convertible<B，A*>：：value，由于A是B的基类指针，是可以隐式转换的，所以判断的结果为true。

类型的转换traits

常用的类型的转换traits包括对const的修改——const的移除和添加，引用的修改——引用的移除和添加，数组的修改和指针的修改.

// 添加和移除 const、reference
cout << std::is_same<const int, add_const<int>::type>::value << endl;   // true
cout << std::is_same<int, remove_const<const int>::type>::value << endl;    // true
cout << std::is_same<int&, add_lvalue_reference<int>::type>::value << endl; //true
cout << std::is_same<int&&, add_rvalue_reference<int>::type>::value << endl;    // true
cout << std::is_same<int, remove_reference<int&>::type>::value << endl; // true
cout << std::is_same<int, remove_reference<int&&>::type>::value << endl;    // true
cout << std::is_same<int*, add_pointer<int>::type>::value << endl;  // true
// 移除数组的顶层维度
cout << std::is_same<int, std::remove_extent<int[]>::type>::value << endl;  // true
cout << std::is_same<int[2], std::remove_extent<int[][2]>::type>::value << endl;    // true
cout << std::is_same<int[2][3], std::remove_extent<int[][2][3]>::type>::value<< endl;   // true
// 移除数组的所有维度
cout << std::is_same<int, std::remove_all_extents<int[][2][3]>::type>::value <<endl;    // true
// 取公共类型
typedef std::common_type<unsigned char, short, int>::type NumericType;
cout << std::is_same<int, NumericType>::value << endl;  // true

根据模版参数类型创建对象时，需要注意移除引用，代码如下：

template<typename T>
typename std::remove_reference<T>::type* Create() {
    typedef typename std::remove_reference<T>::type U;
    return new U();
}

在上述例子中，模板参数T可能是引用类型，而创建对象时，需要原始的类型，不能用引用类型，所以需要将可能的引用移除。

有时需要添加引用类型，比如从智能指针中获取对象的引用时，代码如下：

template <class T>
struct Construct {
    typedef typename std::remove_reference<T>::type U;       // 移除可能的引用
    Construct() : m_ptr(new U) {}
         
    typename std::add_lvalue_reference<U>::type              // 添加左值引用
    Get() const {
        return * m_ptr.get();
    }
private:
    std::unique_ptr<U> m_ptr;
};

创建智能指针时需要获取T的原始类型，我们通过std：：remove_reference来移除T可能的引用，后面，需要获取智能向的对象时又要对原始类型U添加左值引用。

再看一个带cv符类型的例子，假如类型是const x&，要新建一个对象，不得不先移除&，再移除const，代码如下：

template<typename T>
typename std::remove_cv<typename std::remove_reference<T>::type>::type* Create() {
    typedef typename std::remove_cv<typename std::remove_reference<T>::type>::type U;
    return new U();
}

这样虽然能解决问题，但是代码比较长，可读性也不好。这时就可以用decay来简化代码，简化后的代码如下：

template<typename T>
typename std::decay<T>::type* Create() {
    typedef typename std::decay<T>::type U;
    return new U();
}

对于普通类型来说，std：：decay是移除引用和cv符，大大简化了我们的书写。除了普通类型之外，std：：decay还可以用于数组和函数，具体的转换规则如下：

先移除T类型的引用，得到类型U，U定义为remove_reference<T>：：type。
如果is_array：：value为true，修改类型type为remove_extent：：type*。
否则，如果is_function：：value为true，修改类型type将为add_pointer：：type。
否则，修改类型type为remove_cv：：type。

typedef std::decay<int>::type A;            // int
typedef std::decay<int&>::type B;           // int
typedef std::decay<int&&>::type C;          // int
typedef std::decay<const int&>::type D;     // int
typedef std::decay<int[2]>::type E;         // int*
typedef std::decay<int(int)>::type F;       // int(*)(int)

由于std：：decay对于函数来说是添加指针，利用这一点，我们可以将函数变成函数指针类型，从而将函数指针变量保存起来，以便在后面延迟执行，比如下面的例子。

template<typename F>
struct SimpFunction {
    using FnType = typename std::decay<F>::type;
    SimpFunction(F& f) : m_fn(f) {}
    void Run() {
        m_fn();
    }
    FnType m_fn;
};

根据条件选择的traits

std：：conditional在编译期根据一个判断式选择两个类型中的一个，和条件表达式的语义类似，类似于一个三元表达式。

1 2	template< bool B, class T, class F > struct conditional;

typedef std::conditional<true,int,float>::type A;                       // int
typedef std::conditional<false,int,float>::type B;                      // float
typedef std::conditional<std::is_integral<A>::value,long,int>::type C;  // long
typedef std::conditional<std::is_integral<B>::value,long,int>::type D;  // int

获取可调用对象返回类型的traits

有时要获取函数的返回类型是一件比较困难的事情

当然我们首先想到可以使用decltype结合auto太清晰的表明，代码如下：

template <typename F, typename Arg>
auto Func(F f, Arg arg)->decltype(f(arg)) {
    return f(arg);
}

上面的写法比之前的写法更简洁，在一般情况下也是没问题的，但是在某个类型没有模板参数时，就不能通过decltype来获取类型了

class A2 {
    A2()=delete;
public:
    int operator()(int i) {
        return i;
    }
};

decltype(A2()(0)) i = 4; // error

上面的代码将会编译报错，因为A没有默认构造函数。对于这种没有默认构造函数的类型，我们如果希望能推导其成员函数的返回类型，则需要借助std：：declval。

decltype(declval<A2>()(declval<int>())) i = 4;

declval获取的临时值引用不能用于求值，因此，我们需要用decltype来推断出最终的返回类型。

但显得不够简洁，C++11提供了另外一个trait——std：：result_of，用来在编译期获取一个可调用对象（关于可调用对象，读者可以参考1.5.1节）的返回类型。

std::result_of<A2(int)>::type i2 = 4;

上面的std::result_of<A2(int)>::type实际上等价于decltype(std::declval<A2>()(std::declval<int>()))

1
2
3

template< class F, class... ArgTypes >
class result_of<F(ArgTypes...)>;
// 第一个模板参数为可调用对象的类型，第二个模板参数为参数的类型

一个例子

如果要对某个函数使用std：：result_of，要先将函数转换为可调用对象

int fn(int) {return int();}                            // function
typedef int(&fn_ref)(int);                             // function reference
typedef int(*fn_ptr)(int);                             // function pointer
struct fn_class { int operator()(int i){return i;} };  // function-like class

typedef std::result_of<decltype(fn)*(int)>::type A3;
// typedef std::result_of<decltype(fn)&(int)>::type A3; 结果与上一行代码相同
typedef std::result_of<fn_ref(int)>::type B3;
typedef std::result_of<fn_ptr(int)>::type C3;
typedef std::result_of<fn_class(int)>::type D3;
std::cout << std::boolalpha;
std::cout << "typedefs of int:" << std::endl;
std::cout << "A3: " << std::is_same<int,A3>::value << std::endl;
std::cout << "B3: " << std::is_same<int,B3>::value << std::endl;
std::cout << "C3: " << std::is_same<int,C3>::value << std::endl;
std::cout << "D3: " << std::is_same<int,D3>::value << std::endl;

再来一个例子

template<typename Fn>
auto GroupBy(const vector<Person>&vt, const Fn& keySlector)->multimap<decltype(keySlector((Person&)nullptr)),Person> {
    // 推断出keySlector的返回值类型
    typedef decltype(keySlector(*(Person*) nullptr)) key_type;
    multimap<key_type, Person> map;
    std::for_each(vt.begin(), vt.end(), [&](const Person& person) {
        map.insert(make_pair(keySlector(person), person));
    });
    return map;
}

// 有了result_of就可以轻松很多了
template<typename Fn>
multimap<typename std::result_of<Fn(Person)>::type, Person> GroupBy(const vector<Person>& vt,Fn&& keySlector) {
    // 推断出keySlector的返回值类型
    typedef std::result_of<Fn(Person)>::type key_type;
    multimap<key_type, Person> map;
    std::for_each(vt.begin(), vt.end(), [&](const Person& person) {
        map.insert(make_pair(keySlector(person), person));
    });
    return map;
}

根据条件禁用或启用某种或某些类型traits

编译器在匹配重载函数时会匹配所有的重载函数，找到一个最精确匹配的函数，在匹配过程中可能会有一些失败的尝试，当匹配失败时会再尝试匹配其他的重载函数。

std：：enable_if利用SFINAE实现根据条件选择重载函数，std：：enable_if的原型如下:

1 2	emplate< bool B, class T = void > struct enable_if;

若 B 为 true ，则 std::enable_if 拥有等同于 T 的公开成员 typedef type ；否则，无该成员 typedef 。

可以通过判断式和非判断式来将入参分为两大类，从而满足所有的入参类型，代码如下：

template <class T>
typename std::enable_if<std::is_arithmetic<T>::value, int>::type foo1(T t) {
    cout << t << endl;
    return 0;
}

template <class T>
typename std::enable_if<!std::is_arithmetic<T>::value, int>::type foo1(T &t) {
    cout << typeid(T).name() << endl;
    return 1;
}

对于arithmetic类型的入参则返回0，对于非arithmetic的类型则返回1，通过arithmetic将所有的入参类型分成了两大类进行处理

std：：enable_if的第二个模板参数是默认模板参数void类型，因此，在函数没有返回值时，后面的模板参数可以省略。

可变参数模版

可变参数模版函数

现在C++11中的新特性可变参数模板允许模板定义中包含0到任意个模板参数。可变参数模板和普通模板的语义是一样的，只是写法上稍有区别，声明可变参数模板时需要在typename或class后面带上省略号“…”。

省略号的作用有两个：

声明一个参数包，这个参数包中可以包含0到任意个模板参数。
在模板定义的右边，可以将参数包展开成一个一个独立的参数。

一个可变参数模版函数定义如下：

template <class... T>
void f(T... args)
{
        cout << sizeof...(args) << endl;        //打印变参的个数
}

如果需要使用参数包中的函数，有两种展开参数包的方法：

一种方法是通过递归的模板函数来将参数包展开
另外一种是通过逗号表达式和初始化列表方式展开参数包。

递归函数方式展开参数包

void print() {
  cout << "empty" << endl;
}
// 展开函数
template <class T, class ...Args>
void print(T head, Args... rest) {
  cout << "parameter " << head << endl;
  print(rest...);
}

print(1,2,3,4);
/**
调用规则如下：
print(1,2,3,4);
print(2,3,4);
print(3,4);
print(4);
print();
*/

可以通过type_traits来展开并打印参数包，思路同样是递归。

// 这里enable_if<bool, T>的T省略了，所以使用默认值void，即要是判断成功，获得void的type
template<std::size_t I = 0, typename Tuple>
typename std::enable_if<I == std::tuple_size<Tuple>::value>::type printtp(Tuple t) {}

template<std::size_t I = 0, typename Tuple>
typename std::enable_if<I < std::tuple_size<Tuple>::value>::type printtp(Tuple t) {
    std::cout << std::get<I>(t) << std::endl;
    printtp<I + 1>(t);
}

template<typename... Args>
void print(Args... args) {
        printtp(std::make_tuple(args...));
}

逗号表达式和初始化列表方式展开参数包

递归函数展开参数包是一种标准做法，也比较好理解，但也有一个缺点，就是必须有一个重载的递归终止函数，即必须有一个同名的终止函数来终止递归，这样会感觉稍有不便。

之前的print可以改成如下代码：

template <class T>
void printarg(T t) {
    cout << t << endl;
}

template <class ...Args>
void expand(Args... args) {
    int arr[] = {(printarg(args),0)...};
}

这种就地展开参数包的方式实现的关键是逗号表达式。逗号表达式会按顺序执行逗号前面的表达式，比如：

d = (a = b, c);

这个表达式会按如下顺序执行：b会先赋值给a，接着括号中的逗号表达式返回c的值，因此d将等于c。

expand函数中的逗号表达式：（printarg（args），0），也是按照这个执行顺序，先执行printarg（args），再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组，{（printarg（args），0）…}将会展开成（（printarg（arg1），0），（printarg（arg2），0），（printarg（arg3），0），etc…），最终会创建一个元素值都为0的数组int arr[sizeof…（Args）]。

我们还可以对上面的expand方法做一点改进，通过std：：initializer_list来代替原来的int arr[]数组。改进之后的代码如下：

template <class ...Args>
void expand2(Args... args) {
    std::initializer_list<int>{(printarg(args), 0)...};
}

事实上，还可以进一步做改进，上面代码中的printarg函数也可以改为lambda表达式。改进之后的代码如下：

template<typename... Args>
void expand3(Args... args) {
    std::initializer_list<int>{([&]() -> void {cout << args << endl;}(), 0)...};
}

可变参数模版类

可变参数模板类的参数包展开的方式和可变参数模板函数的展开方式不同，可变参数模板类的参数包需要通过模板特化或继承方式去展开，展开方式比可变参数模板函数要复杂。

模版递归和特化方式展开参数包

可变参数模板类的展开一般需要定义2~3个类，包括类声明和特化的模板类。如下方式定义了一个基本的可变参数模板类。

// 这个前向声明限制了sum的模板参数至少有一个，当然此处的前向声明可以参略
template<typename... Args>
struct Sum;
template<typename First, typename... Rest>
struct Sum<First, Rest...> {
    enum {value = Sum<First>::value + Sum<Rest...>::value};
};
template<typename Last>
struct Sum<Last> {
    enum {value = sizeof(Last)};
};

// 之前学习了integral_constant的小妙招，改写一下
template<typename... Args>
struct Sum2;
template<typename First, typename... Rest>
struct Sum2<First, Rest...> : std::integral_constant<int, Sum2<First>::value + Sum2<Rest...>::value> {};
template<typename Last>
struct Sum2<Last> : std::integral_constant<int, sizeof(Last)> {};

可以看到一个基本的可变参数模板应用类由三部分组成:

前向声明
类的定义
特化的递归终止类

继承方式展开参数包

通过模板递归和模板特化的方式展开。还有另外一种方式：通过继承和特化的方式展开。

// 整型序列的定义
template<int...>
struct IndexSeq{};
// 继承方式，开始展开参数包
template<int N, int... Indexes>
struct MakeIndexes : MakeIndexes<N - 1, N - 1, Indexes...> {};
// 模板特化，终止展开参数包的条件
template<int... Indexes>
struct MakeIndexes<0, Indexes...> {
    typedef IndexSeq<Indexes...> type;
};

// 这里还可以用using来替代继承递归
template<int N, int... Indexes>
struct MakeIndexes2{
    using type = typename MakeIndexes2<N - 1, N - 1, Indexes...>::type;
};
template<int... Indexes>
struct MakeIndexes2<0, Indexes...> {
    using type = IndexSeq<Indexes...>;
};

using T = MakeIndexes<3>::type;

/**
 展开过程如下:
 MakeIndexes<3,indexSeq<>> : MakeIndexes<2,indexSeq<2>> :
 MakeIndexes<1,indexSeq<1,2>> : MakeIndexes<0,indexSeq<0,1,2>>
 最后由特化的模版类返回indesSeq<0,1,2>的type
 */

/**
 如果想让indexSeq中的元素逆序，只需要使用MakeIndexes<N-1,index..., N-1>{};
 MakeIndexes<3,indexSeq<>> : MakeIndexes<2,indexSeq<2>> :
 MakeIndexes<1,indexSeq<2,1>> : MakeIndexes<0,indexSeq<2,1,0>>
 */

再来一个例子收尾

template<int...>
struct IndexSeq2{};
template<int N, int... Indexes>
struct MakeIndexes3{
using type = typename MakeIndexes3<N - 1, N - 1, Indexes...>::type;
};
template<int... Indexes>
struct MakeIndexes3<0, Indexes...> {
    using type = IndexSeq2<Indexes...>;
};
template<int ... Indexes, typename ... Args>
void print_helper(IndexSeq2<Indexes...>, std::tuple<Args...>&& tup){
    print2(std::get<Indexes>(tup)...); // 将tuple转换为函数参数，再调用方法1
}
template<typename ... Args>
void print2(Args... args){
    print_helper(typename MakeIndexes3<sizeof... (Args)>::type(),std::make_tuple(args...));
}

其实最后的目的就是给print_helper函数传递两个参数，第一个参数是tuple个元素对应的序列，第二个元素就是实际存放数值的tuple。

可变参数模版和type_taits的综合应用

optional的实现

尝试实现一个optional，optional之前接触过scala，所以大概什么作用还是知道的，和这里的作用类似，不了解的可以去额外搜一下。

这里额外介绍一个概念:placement_new

Placement new

Placement new is a variation new operator in C++. Normal new operator does two things : (1) Allocates memory (2) Constructs an object in allocated memory.

Placement new allows us to separate above two things. In placement new, we can pass a preallocated memory and construct an object in the passed memory.

new (address) (type) initializer

As we can see, we can specify an address

where we want a new object of given type

to be constructed.

主要就是两步，第一步是开辟空间，第二步是执行对应的构造函数。

只不过我们提前准备好了对象存放的空间，好处是it allows to construct an object on memory that is already allocated, it is required for optimizations as it is faster not to re-allocate all the time.

思路

那就可以设想到一个场景，因为optional本身最初是不知道T的类型，但是还是需要有地方可以保存这个T。这里为什么需要容纳T的值，一开始可能还不了解，不过既然他要使用placement new，那就需要提供。

假设确实需要提供T的值，那么就需要一个存储空间，这里我们叫它缓冲区。一般性考虑到通用性，可能会想到用char[]来作为缓冲区的类型，但是这里就涉及到了一个内存对齐的问题，char是一字节对齐的，可是T大概率不是，不能对齐可能会引发效率问题或者错误，这里如果用gdb进行一下debug一下可能会了解更多，包括c语言也需要你自己处理对齐。

这里就需要使用内存对齐缓冲区 std::aligned_storage，原型如下:

template< std::size_t Len, std::size_t Align = /*default-alignment*/ >
// std::aligned_storage的声明如下:
std::aligned_storage<sizeof(T), alignof(T)>
// 通过sizeof(T)可以获取T的size，通过alignof(T)可以获取T内存对齐大小

代码

template<typename T>
class Optional {
    // 定义内存对齐的缓冲区类型
    using data_t=typename std::aligned_storage<sizeof(T),std::alignment_of<T>::value>::type;
public:
    Optional(){}
    Optional(const T& v) {
        Create(v);                      // 内部通过placement new创建对象
    }
        
    Optional(const Optional& other) {
        if (other.IsInit())
            Assign(other);
        }
    
    ~Optional() {
        Destroy();                       // 删除缓冲区中创建的对象
    }
    
    // 根据参数创建
    template<class... Args>
    void Emplace(Args&&... args) {
        Destroy();
        Create(std::forward<Args>(args)...);
    }
    
    bool IsInit() const { return m_hasInit; } // 是否已经初始化
    // 一开始m_hasInit是false
    explicit operator bool() const {
        // 判断是否已经初始化
        return IsInit();
    }
    T& operator*() const {
        // 从optional中取出对象
        if (IsInit()) {
            return *((T*)(&m_data));
        } throw std::logic_error("is not init");
    }
    
private:
    template<class... Args>
    void Create(Args&&... args) {
        new (&m_data) T(std::forward<Args>(args)...);
        m_hasInit = true;
    }
    
    // 销毁缓冲区的对象
    void Destroy() {
        if (m_hasInit) {
            m_hasInit = false;
            ((T*)(&m_data))->~T();
        }
    }
    
    void Assign(const Optional& other) {
        if (other.IsInit()) {
            Copy(other.m_data);
            m_hasInit = true;
        }
        else {
            Destroy();
        }
    }
    
    void Copy(const data_t& val) {
        Destroy();
        new (&m_data) T(*((T*)(&val)));
    }

private:
    bool m_hasInit=false;   // 是否已经初始化
    data_t m_data;          // 内存对齐的缓冲区
};

struct MyStruct {
    MyStruct() {};
    MyStruct(int a, int b):m_a(a),m_b(b){}
    int m_a;
    int m_b;
};

void TestOptional() {
    Optional<string> a("ok");
    Optional<string> b("ok");
    Optional<string> c("aa");
    c = a;
    Optional<MyStruct> op;
    // op.Emplace(1, 2);
    MyStruct t;
    if(op) {
        // 判断optional是否被初始化
        t = *op;
        cout << t.m_a << " " << t.m_b << endl;
    }
    
    op.Emplace(3, 4);
    t = *op;
    cout << t.m_a << " " << t.m_b << endl;
}

这一个小单元其实最大的收获，对自己而言其实是再一次了解了placement new，之后才是了解了std::aligned_storage<sizeof(T), alignof(T)>这个操作。

惰性求值类lazy的实现

思路

先用一个例子介绍什么是lazy实现。

一个典型的应用场景是这样的：当初始化某个对象时，该对象引用了一个大对象，这个对象的创建需要较长的时间，同时也需要在托管堆上分配较多的空间，这样可能会在初始化时变得很慢，尤其是UI应用时会导致用户体验很差。其实很多时候并不需要马上就获取大数据，只是在需要时获取，这种场景就很适合延迟加载。

目前C++中还没有类似的Lazy惰性求值类，实现思路比较简单，借助lamda表达式，将函数封装到lamda表达式中，而不是马上求值，是在需要的时候再调用lamda表达式去求值。

之前提到过lambda表达式可以实现延迟调用，在定义完的一瞬间可以捕获当时的外部变量，然后再之后合适的时机再调用。

代码

// Lazy内部的std：：function<T（）>用来保存传入的函数，以便在后面延迟执行
template <typename T>
struct Lazy {
    Lazy(){}
    // 保存需要延迟执行的函数
    template <typename Func, typename... Args>
    Lazy(Func&& f, Args && ... args) {
        m_func = [&f, &args...]() -> T { return f(args...); };
    }
    // 延迟执行，将结果放到optionl中缓存起来，下次不用重新计算可以直接返回结果
    
    T& Value() {
        if (!m_value.IsInit()) {
            m_value = m_func();
            
        }
        return *m_value;
    }
    
    bool IsValueCreated() const {
        return m_value.IsInit();
    }
    
private:
    std::function<T()> m_func;
    Optional<T> m_value;
};
    
/**
 这个模版函数需要两个参数，一个是Func类型的右值引用，另一个参数是一组可变参数
 result_of<Func(Args...)>::type返回Func.operator(Args...)返回的对象的type，这个类型传递给了Lazy
 所以返回值的类型其实就是Lazy<type>
 */
template<class Func, typename... Args>
Lazy<typename std::result_of<Func(Args...)>::type>
lazy(Func && fun, Args && ... args) {
    return Lazy<typename result_of<Func(Args...)>::type>(forward<Func>(fun),forward<Args>(args)...);
}

struct BigObject {
    BigObject() {
        cout <<"lazy load big object"<< endl;
    }
};

struct MyStruct2 {
    MyStruct2() {
        m_obj = lazy([]{return std::make_shared<BigObject>(); });
    }

    void Load() {
        m_obj.Value();
    }
    
    Lazy< std::shared_ptr<BigObject>> m_obj;
};

int Foo(int x) {
  return x * 2;
}

void TestLazy() {
    // 带参数的普通函数
    int y = 4;
    auto lazyer1 = lazy(Foo, y);
    cout << lazyer1.Value() << endl;
    // 不带参数的lamda
    Lazy<int> lazyer2 = lazy([]{return 12; });
    cout << lazyer2.Value() << endl;
    // 带参数的fucntion
    std::function <int(int) > f = [](int x){return x + 3; };
    auto lazyer3 = lazy(f, 3);
    cout << lazyer3.Value() << endl;
    // 延迟加载大对象
    MyStruct2 t;
    t.Load();
}

dll帮助类

本身对dll不是很熟悉，但是win上经常有一些dll文件，你可以像程序注入一些dll来辅助完成任务，暂时当作外部存放的工具类。

在C++中调用dll中的函数有点烦琐，调用过程如下：在加载dll后还要定义一个对应的函数指针类型，接着调用GetProcAddress获取函数地址，再转成函数指针，最后调用该函数，代码如下：

void TestDll() {
   // 定一个对应的函数指针类型
   typedef int(*pMax)(int a,int b);
   typedef int(*pGet)(int a);
   // 加载整个dll库
   HINSTANCE hDLL = LoadLibrary("MyDll.dll");
   if(hDLL == nullptr)
       return;
   // 获取需要调用的函数地址，并转换成对应的函数指针
   pMax Max = (pMax)GetProcAddress(hDLL,"Max");
   if(Max == nullptr)
       return;
   int ret = Max(5,8);      // 8
   pGet Get = (pGet)GetProcAddress(hDLL,"Get");
   if(Get == nullptr)
       return;
   ret = Get(5);                // 5
   FreeLibrary(hDLL);
}

每用一个函数就需要先定义一个函数指针，然后再根据名称获取函数地址，最后调用。如果一个dll中有上百个函数，这种烦琐的定义会让人不胜其烦。

我们希望调用dll中的函数就像调用普通的函数一样，即传入一个函数名称和函数的参数就可以实现函数的调用了，就类似于：

Ret CallDllFunc(const string& funName, T arg)

如果我们希望实现一个通用的function，有两个问题需要解决：

函数的返回值可能是不同类型
函数的入参数目的个数是人任意的

这两点其实结合之前学过的模版和可变参数已经可以很好的解决的，一点点来推进。

先封装一下GetProcAddress:

template <typename T>
function<T> GetFunction(const string& funcName) {
   FARPROC funAddress = GetProcAddress(m_hMod, funcName.c_str());
   return function<T>((T*)(funAddress));
}

auto fmax = GetFunction<int(int, int)>("Max");
auto fget = GetFunction<int(int)>("Get");

函数返回值和入参不统一的问题，通过result_of和可变参数模板来解决，最终的调用函数如下：

template <typename T, typename... Args>
typename std::result_of<std::function<T>(Args...)>::type ExcecuteFunc(const string& funcName,Args&&... args) {
  return GetFunction<T>(funcName)(args...);
}
auto max = ExcecuteFunc<int(int, int)>("Max", 5, 8);
auto ret = ExcecuteFunc<int(int)>("Get", 5);

实现的关键是如何将一个FARPROC变成一个函数指针复制给std::function，然后再调用可变参数执行。函数的返回值通过std::result_of来泛化，使得不同返回值的dll函数都可以用相同的方式来调用。

lambda链式调用

直接看代码实现，不多啰嗦，代码如下：

template<typename T>
class Task;
template<typename R, typename...Args>
class Task<R(Args...)> {
public:
  // 传入的参数是个function<R(Args...)>
  Task(std::function<R(Args...)>&& f) : m_fn(std::move(f)){}
  Task(std::function<R(Args...)>& f) : m_fn(f){}
  R Run(Args&&...args) {
      return m_fn(std::forward<Args>(args)...); // 完美转发
  }
  // 连续调用新的函数，将函数不断地串联起来
  template<typename F>
  // m_fn的返回值是then中class的参数，起到链式调用的作用
  auto Then(F&& f) -> Task<typename std::result_of<F(R)>::type(Args...)> {
      using return_type = typename std::result_of<F(R)>::type;
      // result_of获取F的返回类型
      auto func = std::move(m_fn);
      return Task<return_type(Args...)>([func, &f](Args&&... args) {
          //将前一个函数的输出作为后一个函数的输入
          return f(func(std::forward<Args>(args)...));
      });
  }
private:
  std::function<R(Args...)> m_fn;
};

void TestTask() {
  Task<int(int)> task([](int i){return i;});
  auto result = task.Then([](int i){return i + 1;}).Then([](int i){return i + 2;}).Then([](int i){return i + 3;}).Run(1);
  cout << result << endl;
}

非常棒的工程思维，值得学习！

any类的实现

是一个特殊的只能容纳一个元素的容器，它可以擦除类型，可以赋给它任何类型的值，不过在使用的时候需要根据实际类型将any对象转换为实际的对象，和scala中的any类似。

思路

接下来重点介绍any的关键技术，要细品他的工程思维。

any能容纳所有类型的数据，因此，当赋值给any时，需要将值的类型擦除，即以一种通用的方式保存所有类型的数据。这里可以通过继承去擦除类型，基类是不含模板参数的，派生类中才有模板参数，这个模板参数类型正是赋值的类型。在赋值时，将创建的派生类对象赋值给基类指针，基类的派生类携带了数据类型，基类只是原始数据的一个占位符，通过多态的隐式转换擦除了原始数据类型，因此，任何数据类型都可以赋值给它，从而实现能存放所有类型数据的目标。当取数据时需要向下转换成派生类型来获取原始数据，当转换失败时打印详情，并抛出异常。由于向any赋值时需要创建一个派生类对象，所以还需要管理该对象的生命周期，这里用unique_ptr智能指针去管理对象的生命周期。

以上都是书中的原文，几个关键点很值得学习：擦出类型可以考虑集成；当有连带关系自动创建的新对象是，可以考虑unique_ptr。

代码

struct Any {
  Any(void) : m_tpIndex(std::type_index(typeid(void))){}
  Any(Any& that) : m_ptr(that.Clone()), m_tpIndex(that.m_tpIndex) {}
  Any(Any && that) : m_ptr(std::move(that.m_ptr)),
      m_tpIndex(that.m_tpIndex) {}

  // 创建智能指针时，对于一般的类型，通过std::decay来移除引用和cv符，从而获取原始类型
  template<typename U, class = typename std::enable_if<!std::is_same<typename std::decay<U>::type, Any>::value, U>::type>
  Any(U && value):m_ptr(new Derived < typename std::decay<U>::type>(forward<U>(value))),m_tpIndex(type_index(typeid(typename std::decay<U>::type))){}

  bool IsNull() const { return !bool(m_ptr); }

  template<class U> bool Is() const {
      return m_tpIndex == type_index(typeid(U));
  }

  // 将Any转换为实际的类型
  template<class U>
  U& AnyCast() {
      if (!Is<U>()) {
          cout << "can not cast " << typeid(U).name() << " to " << m_tpIndex.name() << endl;
          throw bad_cast();
      }
      auto derived = dynamic_cast<Derived<U>*> (m_ptr.get());
      return derived->m_value;
  }

  Any& operator=(const Any& a) {
      if (m_ptr == a.m_ptr)
          return *this;
      m_ptr = a.Clone();
      m_tpIndex = a.m_tpIndex;
      return *this;
  }

private:
  struct Base;
  typedef std::unique_ptr<Base> BasePtr;
  struct Base {
      virtual ~Base() {}
      virtual BasePtr Clone() const = 0;
  };

  template<typename T>
  struct Derived : Base {
      template<typename U>
      Derived(U && value) : m_value(forward<U>(value)) { }
      BasePtr Clone() const {
          return BasePtr(new Derived<T>(m_value));
      }
      T m_value;
  };

  BasePtr Clone() const {
      if (m_ptr != nullptr)
          return m_ptr->Clone();
      return nullptr;
  }

  BasePtr m_ptr;  // 维护一个基类指针
  std::type_index m_tpIndex;
};

void TestAny() {
 Any n;
 auto r = n.IsNull(); // true
 string s1 = "hello";
 n = s1;
 n.AnyCast<int>();   // 转换失败将抛异常
 Any n1 = 1;
 n1.Is<int>();      // true
}

又是需要细品的一段代码，这里 enable_if 的作用是干预重载决议。因为你这个模板构造函数只有一个形参，且类型是模板形参，主要是为了防止和你的复制构造和移动构造函数产生冲突。

function_traits

在C++编程中，有时候需要获取函数的实际类型，返回类型，参数个数和参数具体类型。

C++提供了function_traits来获取这些信息，可以获取普通函数、函数指针、std：：function、函数对象和成员函数的函数类型、返回类型、参数个数和参数的具体类型。

boost库里有提供function_traits这个功能，但是原始的library里没有。

代码

//转换为std::function和函数指针.
template<typename T>
struct function_traits;

//普通函数.
template<typename Ret, typename... Args>
struct function_traits<Ret(Args...)> {
public:
    enum {arity = sizeof...(Args)};
    using function_type = Ret(Args...);
    using return_type = Ret;
    using stl_function_type = function<function_type>;
    using pointer = Ret(*)(Args...);
    
    template<size_t I>
    struct args {
        // 如果I < arity，会返回index is out of range
        static_assert(I < arity, "index is out of range.");
        // tuple_elemt获取指定tuple的第I个type
        using arg_type = typename tuple_element<I, tuple<Args...>>::type;
    };
    
    typedef std::tuple<std::remove_cv_t<std::remove_reference_t<Args>>...> tuple_type;
    typedef std::tuple<std::remove_const_t<std::remove_reference_t<Args>>...> bare_tuple_type;
};

//函数指针.
template<typename Ret, typename... Args>
struct function_traits<Ret(*)(Args...)> : function_traits<Ret(Args...)>{};

//std::function.
template <typename Ret, typename... Args>
struct function_traits<std::function<Ret(Args...)>> : function_traits<Ret(Args...)>{};

//member function.
#define FUNCTION_TRAITS(...)\
template <typename ReturnType, typename ClassType, typename... Args>\
struct function_traits<ReturnType(ClassType::*)(Args...) __VA_ARGS__> : function_traits<ReturnType(Args...)>{};\

FUNCTION_TRAITS()
FUNCTION_TRAITS(const)
FUNCTION_TRAITS(volatile)
FUNCTION_TRAITS(const volatile)

//函数对象.
template<typename Callable>
struct function_traits : function_traits<decltype(&Callable::operator())>{};

template <typename Function>
typename function_traits<Function>::stl_function_type to_function(const Function& lambda) {
    return static_cast<typename function_traits<Function>::stl_function_type>(lambda);
}

template <typename Function>
typename function_traits<Function>::stl_function_type to_function(Function&& lambda) {
    return static_cast<typename function_traits<Function>::stl_function_type>(std::forward<Function>(lambda));
}

template <typename Function>
typename function_traits<Function>::pointer to_function_pointer(const Function& lambda) {
    return static_cast<typename function_traits<Function>::pointer>(lambda);
}

template<typename T>
void PrintType() {
    cout << typeid(T).name() << endl;
}

float(*castfunc)(string, int);
 
float free_function(const std::string& a, int b) { return (float) a.size() / b; }

struct AA {
    int f(int a, int b)volatile{ return a + b; }
    int operator()(int)const{ return 0; }
};

void TestFunctionTraits()   {
    std::function<int(int)> f = [](int a){return a; };
    PrintType<function_traits<std::function<int(int)>>::function_type>();
    PrintType<function_traits<std::function<int(int)>>::args<0>::arg_type>();
    PrintType<function_traits<decltype(f)>::function_type>();
    PrintType<function_traits<decltype(free_function)>::function_type>();
    PrintType<function_traits<decltype(castfunc)>::function_type>();
    PrintType<function_traits<AA>::function_type>();
    using T = decltype(&AA::f);
    PrintType<T>();
    PrintType<function_traits<decltype(&AA::f)>::function_type>();
    static_assert(std::is_same<function_traits<decltype(f)>::return_type, int>::value, "");
}

解析

这段代码给我的震撼是巨大的，让我有了等看完深入应用c++11后，直接去看template编程的冲动，这是值得铭记的一天哈哈哈。

这段代码有几个知识点可以帮作为新手的我进一步巩固：

template的特化，T*，const T等等
学到了一招tuple_element
再次接触了remove_reference等等，这些的实际作用进一步理解了

至于define那段其实我也没有细看，一是我本身并不喜欢define，其次是我能清晰的感觉的他暂时对我没用，只有在打开define的大门。

Variant

这玩意实现起来对于新手而言是有些复杂的，是3.3到现在我自认为从设计的角度而言最复杂的，以学习书本上的原始代码为主了解一下。

基本作用

variant类似于union，它能代表定义的多种类型，允许赋不同类型的值给它。它的具体类型是在初始化赋值时确定的。boost库中有variant，这个variant的基本用法如下：

typedef variant<int,char, double> vt;
vt v = 1;
v = '2';
v = 12.32;

和union是比较像的。

思路

我们自己思考一下如何实现，之后直接看代码，初学者多看标准代码不容易走弯路。

首先和option一样，肯定要实现类型擦除，同时要用到placement new，就业需要aligend_storage，原始代码如下，分析一下。

代码

这段就暂时不具体说了，我给书上的代码加了很多注释，对于初学者的我来说还是比较复杂的，但是收获非常大。

/** 获取最大的整数 */
// 基础定义
// 传捡来的参数是sizeof(type),sizeof(type)...
template <size_t arg, size_t... rest>
struct IntegerMax;

// 当只有一个参数，直接传给integral_constant类型和value
template <size_t arg>
struct IntegerMax<arg> : std::integral_constant<size_t, arg>
{
};

// 直接用一个三目运算符，递归处理，找出size最大的类型
template <size_t arg1, size_t arg2, size_t... rest>
struct IntegerMax<arg1, arg2, rest...> : std::integral_constant<size_t, arg1 >= arg2 ? IntegerMax<arg1, rest...>::value
    : IntegerMax<arg2, rest...>::value>
{
};

/** 获取最大的align */
// 直接传进来的就是varient的typename... T
/**
 template< class T >
 struct alignment_of : std::integral_constant<std::size_t,alignof(T)> {};
 可以看到value其实就是某个类型的对齐大小，那MaxAlign，其实就是利用已经实现的IntegerMax搭配aligment找出最大的对齐大小
 */
template<typename... Args>
struct MaxAlign : std::integral_constant<int, IntegerMax<std::alignment_of<Args>::value...>::value>
{
};

/** 是否包含某个类型 */
template <typename T, typename... List>
struct Contains;

template <typename T, typename Head, typename... Rest>
struct Contains<T, Head, Rest...>
    : std::conditional<std::is_same<T, Head>::value, std::true_type, Contains<T, Rest... >> ::type
{
};

template <typename T>
struct Contains<T> : std::false_type
{
};

template <typename T, typename... List>
struct IndexOf;

template <typename T, typename Head, typename... Rest>
struct IndexOf<T, Head, Rest...>
{
    enum { value = IndexOf<T, Rest...>::value + 1 };
};

template <typename T, typename... Rest>
struct IndexOf<T, T, Rest...>
{
    enum { value = 0 };
};

template <typename T>
struct IndexOf<T>
{
    enum{value = -1};
};

// 第一个参数是index，第二个参数就是传给Varient的Type...
// 其实就是从传入的Type...中，然会index对应的type
template<int index, typename... Types>
struct At;

template<int index, typename First, typename... Types>
struct At<index, First, Types...>
{
    // 这里还是一个递归调用，最后index一定会变成0，到0之后执行特殊化的模版类At
    using type = typename At<index - 1, Types...>::type;
};

// 当index为0的时候，其实就拿到了第index个type，很巧妙的思路
template<typename T, typename... Types>
struct At<0, T, Types...>
{
    using type = T;
};

// varient本身的主类
// 传进模版类的参数是... Types，因为varient能存放的数据类型是不定的
template<typename... Types>
class Variant
{
    enum
    {
        data_size = IntegerMax<sizeof(Types)...>::value,    // 结构大小
        align_size = MaxAlign<Types...>::value  // 对齐大小
    };
    // 利用aligned提前确定data_size，align_size，以便于placement new，option的时候有介绍
    using data_t = typename std::aligned_storage<data_size, align_size>::type;
public:
    template<int index>
    using IndexType = typename At<index, Types...>::type;   // 返回index对应的type，也用到了递归

    // type_index_是一个type_index类型，默认给void的typeid
    Variant(void) :type_index_(typeid(void))
    {
    }

    ~Variant()
    {
        destroy(type_index_, &data_);
    }

    // 移动构造，传入的参数是右值引用
    Variant(Variant<Types...>&& old) : type_index_(old.type_index_)
    {
        // 将左值转换为右值
        move(old.type_index_, &old.data_, &data_);
    }

    //拷贝构造
    Variant(const Variant<Types...>& old) : type_index_(old.type_index_)
    {
        copy(old.type_index_, &old.data_, &data_);
    }

    // 赋值操作，内部也采取了拷贝构造
    Variant& operator=(const Variant& old)
    {
        copy(old.type_index_, &old.data_, &data_);
        type_index_ = old.type_index_;
        return *this;
    }

    // 赋值操作，内部采用移动构造
    Variant& operator=(Variant&& old)
    {
        move(old.type_index_, &old.data_, &data_);
        type_index_ = old.type_index_;
        return *this;
    }

    // Contains底层是一个conditional，判断传入的T类型是否在Types中存在
    template <class T,
    class = typename std::enable_if<Contains<typename std::decay<T>::type, Types...>::value>::type>
        Variant(T&& value) : type_index_(typeid(void))
    {
            destroy(type_index_, &data_);
            typedef typename std::decay<T>::type U;
            new(&data_) U(std::forward<T>(value));
            type_index_ = std::type_index(typeid(U));
    }

    template<typename T>
    bool is() const
    {
        return (type_index_ == std::type_index(typeid(T)));
    }

    bool Empty() const
    {
        return type_index_ == std::type_index(typeid(void));
    }

    std::type_index type() const
    {
        return type_index_;
    }

    template<typename T>
    typename std::decay<T>::type& get()
    {
        using U = typename std::decay<T>::type;
        if (!is<U>())
        {
            std::cout << typeid(U).name() << " is not defined. "
                << "current type is " << type_index_.name() << std::endl;
            throw std::bad_cast{};
        }

        return *(U*)(&data_);
    }

    template <typename T>
    int indexOf()
    {
        return IndexOf<T, Types...>::value;
    }

    bool operator==(const Variant& rhs) const
    {
        return type_index_ == rhs.type_index_;
    }

    bool operator<(const Variant& rhs) const
    {
        return type_index_ < rhs.type_index_;
    }

private:
    void destroy(const std::type_index& index, void *buf)
    {
        [](Types&&...){}((destroy0<Types>(index, buf), 0)...);
    }

    template<typename T>
    void destroy0(const std::type_index& id, void *data)
    {
        if (id == std::type_index(typeid(T)))
            reinterpret_cast<T*>(data)->~T();
    }

    /**
     Variant(Variant<Types...>&& old) : type_index_(old.type_index_)
     {
         // 将左值转换为右值
         move(old.type_index_, &old.data_, &data_);
     }
     */
    
    // 我把上面调用移动构造的函数拉下来了
    void move(const std::type_index& old_t, void *old_v, void *new_v)
    {
        // 一个lambda函数的调用
        // 传入的实参是(move0<Types>(old_t, old_v, new_v), 0)...
        // 其实就是对每个type调用move0<Type>(old_t, old_v, new_v)
        [](Types&&...){}((move0<Types>(old_t, old_v, new_v), 0)...);
    }

    template<typename T>
    void move0(const std::type_index& old_t, void *old_v, void *new_v)
    {
        // 判断需要move的type是否和要赋值的old_t相同，其实就是在Types中找出适合的那个type，然后构造并返回
        // reinterpret_cast是对指针的强制转换
        if (old_t == std::type_index(typeid(T)))
            new (new_v) T(std::move(*reinterpret_cast<T*>(old_v)));
    }

    void copy(const std::type_index& old_t, const void *old_v, void *new_v)
    {
        [](Types&&...){}((copy0<Types>(old_t, old_v, new_v), 0)...);
    }

    template<typename T>
    void copy0(const std::type_index& old_t, const void *old_v, void *new_v)
    {
        if (old_t == std::type_index(typeid(T)))
            new (new_v)T(*reinterpret_cast<const T*>(old_v));
    }

private:
    data_t data_;
    std::type_index type_index_;
};

ScopeGuard

ScopeGuard的作用是确保资源面对非正常返回（比如，函数在中途提前返回了，或者中途抛异常了，导致不能执行后面的释放资源的代码）时总能被成功释放。它利用C++的RAII机制，在构造函数中获取资源，在析构函数中释放资源。当非正常返回时，ScopeGuard就会析构，这时会自动释放资源。如果没有发生异常，则正常结束，只有在异常发生或者没有正常退出时释放资源。

这里的RAII的全称是Resource Aqucisition is Initialization，资源取得时机就是初始化时机，这里可以进步看一下effective c++的条款14。

注释已加好，直接来看一下书上的代码:

template <typename F>
class ScopeGuard
{
public:
    // 基础的构造函数都禁止了隐式转换
    explicit ScopeGuard(F && f) : m_func(std::move(f)), m_dismiss(false){}  // 形参f是universal reference，但最终都会把f转换成右值引用
    explicit ScopeGuard(const F& f) : m_func(f), m_dismiss(false){}

    ~ScopeGuard()   // 在析构时，满足条件的情况下，会执行m_func，如果已经释放了资源(dimiss之后)，则不会再调用
    {
        if (!m_dismiss && m_func != nullptr)
            m_func();
    }
    
    ScopeGuard(ScopeGuard && rhs) : m_func(std::move(rhs.m_func)), m_dismiss(rhs.m_dismiss) // 移动构造函数
    {
        rhs.Dismiss();
    }

    void Dismiss()  // 把dismiss改成true，这样析构时就不会调用m_func了，也算是一种变相的释放
    {
        m_dismiss = true;
    }

private:
    F m_func;
    bool m_dismiss;

    ScopeGuard();   // 默认构造函数也禁止，去的资源时必须初始化
    ScopeGuard(const ScopeGuard&);  // 拷贝构造函数被禁止了，在RAII中是合理的一种情况，当前设计下资源只能有一份
    ScopeGuard&operator=(const ScopeGuard&);    // 同理赋值操作也被禁止了
};

// 先调用decay的规则可以在上文看到，这里的F大概率会传进来一个函数，如果is_function<F>：：value为true，修改类型type将为add_pointer<F>：：type
// 所以模版函数的返回值的类型大概率是一个函数指针
template <typename F>
ScopeGuard<typename std::decay<F>::type> MakeGuard(F && f)
{
    return ScopeGuard<typename std::decay<F>::type>(std::forward<F>(f));
}

void TestScopeGuard() {
   std::function <void()> f = [] { cout <<"cleanup from unnormal exit"<< endl; };
   // 正常退出
    {
        auto gd = MakeGuard(f);
        // ...
        gd.Dismiss();   // 释放了，析构时不会再调用了
    }
   
    // 异常退出
    {
        auto gd = MakeGuard(f);
        // ...
        // throw std::exception("exception");
    }
   
    // 非正常退出
    {
        auto gd = MakeGuard(f);
        return;
        // ...
   }
}

tuple_helper

这里主要写一些关于tuple的工具类。

打印tuple的每个元素

template<class Tuple, size_t N>
struct TuplePrinter {
    static void print(const Tuple& t) {
        TuplePrinter<Tuple, N - 1>::print(t);
        cout << get<N - 1>(t) << endl;
    }
};

template<class Tuple>
struct TuplePrinter<Tuple, 1> {
    static void print(const Tuple& t) {
        cout << get<0>(t) << endl;
    }
};

template<typename... Args>
void PrintTuple(const tuple<Args...>& t) {
    TuplePrinter<decltype(t), sizeof...(Args)>::print(t);
}

void TestPrint() {
    tuple<int, short, double, char> t = make_tuple(1,2,3,'a');
    PrintTuple(t);
}

根据索引序列打印元素

template<typename T>
void Print(T t) {
    cout << t << endl;
}

template<typename T, typename... Args>
void Print(T t, Args... args) {
    cout << t << endl;
    Print(args...);
}

template<int...>
struct IndexTuple{};

template<typename Tuple, int... index>
void Transform(IndexTuple<index...>& in, Tuple& t) {
    Print(get<index>(t)...);
}

void TestPrint2() {
    tuple<int,double> tp = make_tuple<int,double>(1,2);
    IndexTuple<0,1> in; // 1, 2, 3, a
    Transform(in, tp);  // 1, 2
}

遍历，对tuple中每个元素都应用相同的动作

其实就是个递归，和之前的差不多

template<typename Func, typename Last>
void for_each_impl(Func&& f, Last&& last)
{
    f(std::forward<Last>(last));
}

template<typename Func, typename First, typename ... Rest>
void for_each_impl(Func&& f, First&& first, Rest&&...rest)
{
    f(std::forward<First>(first));
    for_each_impl(std::forward<Func>(f), rest...);
}

template<typename Func, int ... Indexes, typename ... Args>
void for_each_helper(Func&& f, IndexTuple<Indexes...>, std::tuple<Args...>&& tup)
{
    for_each_impl(std::forward<Func>(f), std::forward<Args>(std::get<Indexes>(tup))...);
}

合并tuple

总体上也不难理解

namespace details
{
    template<std::size_t N, typename T1, typename T2>
    using pair_type = std::pair<typename std::tuple_element<N, T1>::type, typename std::tuple_element<N, T2>::type>;

    template<std::size_t N, typename T1, typename T2>
    pair_type<N, T1, T2> pair(const T1& tup1, const T2& tup2)
    {
        //
        return std::make_pair(std::get<N>(tup1), std::get<N>(tup2));
    }

    template<int... Indexes, typename T1, typename T2>
    auto pairs_helper(IndexTuple<Indexes...>, const T1& tup1, const T2& tup2) -> decltype(std::make_tuple(pair<Indexes>(tup1, tup2)...))
    {
        return std::make_tuple(pair<Indexes>(tup1, tup2)...);
    }

}

本文作者： xiaoyuyu
本文链接： http://woaixiaoyuyu.github.io/2022/03/17/%E6%B7%B1%E5%85%A5%E5%BA%94%E7%94%A8C++11%EF%BC%9A%E4%BB%A3%E7%A0%81%E4%BC%98%E5%8C%96%E4%B8%8E%E5%B7%A5%E7%A8%8B%E7%BA%A7%E5%BA%94%E7%94%A8--note/
版权声明： 本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。转载请注明出处！