10 泛型库

回调

• 回调的含义是：对一个库，用户希望库能够调用用户自定义的某些函数，这种调用称为回调。C++中用于回调的类型统称为函数对象类型，它们能直接用作函数实参

#include 
#include 

template
void foreach(Iter current, Iter end, Callable op)
{
  while (current != end)
  {
    op(*current);
    ++current;
  }
}

void func(int i)
{
  std::cout << i << '\n';
}

struct FuncObj {
  void operator()(int i) const
  {
    std::cout << i << '\n';
  }
};

int main()
{
  std::vector primes = { 2, 3, 5, 7, 11, 13, 17, 19 };
  foreach(primes.begin(), primes.end(), func);
  foreach(primes.begin(), primes.end(), &func);
  foreach(primes.begin(), primes.end(), FuncObj());
  foreach(primes.begin(), primes.end(), [] (int i) { std::cout << i << '\n'; });
}

处理成员函数和附加实参

• C++17提供了std::invoke

// basics/foreachinvoke.hpp

#include 
#include 
template
void foreach (Iter current, Iter end, Callable op, const Args&... args)
{
  while (current != end)
  {
    std::invoke(op, args..., *current);
    ++current;
  }
}

• 这里除了函数对象，还能接收任意数量的附加参数。如果函数对象是一个类成员指针，使用第一个附加实参作为this对象，其余作为实参传递给函数对象，否则所有附加参数都只传递给函数对象

#include 
#include 
#include 
#include "foreachinvoke.hpp"

class A {
 public:
  void f(int i) const
  {
    std::cout << i << '\n';
  }
};

int main()
{
  std::vector primes = { 2, 3, 5, 7, 11, 13, 17, 19 };
  foreach(primes.begin(), primes.end(), // 范围内的元素是lambda的第二个参数
    [](std::string const& prefix, int i) {
      std::cout << prefix << i << '\n';
    },
    "value: "); // lambda的第一个参数
  
  A obj;
  foreach(primes.begin(), primes.end(), &A::f, obj);
}

包裹函数调用（Wrapping Function Call）

• std::invoke的一个常见应用是包裹单个函数调用，为了支持返回引用（如std::ostream&），这里使用decltype(auto)替代auto

template
decltype(auto) call(Callable&& op, Args&&... args)
{
  return std::invoke(std::forward(op),
    std::forward(args)...);
}

• 如果想临时存储std::invoke返回的值，也必须用decltype(auto)声明临时变量

template
decltype(auto) call(Callable&& op, Args&&... args)
{
  decltype(auto) ret{std::invoke(std::forward(op),
    std::forward(args)...)};
  return ret;
}

• 注意，把ret声明为auto&&是不正确的，auto&&作为一个引用，生命周期不会超出return语句
• 但使用decltype(auto)也有一个问题，如果函数对象返回void类型，把ret初始化为decltype(auto)是不允许的，因为void是一个不完整的类型
• 一个解决方法是在那条语句之前声明一个对象，该对象的析构函数执行希望实现的可观察的行为

struct cleanup {
  ~cleanup()
  {
    ... // code to perform on return
  }
} dummy;

return std::invoke(std::forward(op), std::forward(args)...);

• 另一个方法是使用if constexpr实现不同的分支

template
decltype(auto) call(Callable&& op, Args&&... args)
{
  if constexpr (std::is_same_v, void>)
  {
    std::invoke(std::forward(op), std::forward(args)...);
    return;
  }
  else
  {
    decltype(auto) ret{std::invoke(std::forward(op),
      std::forward(args)...)};
    return ret;
  }
}

实现泛型库的其他工具

• 标准库提供了type traits

#include 

template
class C {
  static_assert(!std::is_same_v,void>,
    "invalid instantiation of class C for void type");
 public:
  template
  void f(V&& v)
  {
    if constexpr(std::is_reference_v)
    {
      ... // 如果T是引用类型
    }
    if constexpr(std::is_convertible_v,T>)
    {
      ... // 如果V能转换为T
    }
    if constexpr(std::has_virtual_destructor_v)
    {
      ... // 如果V有析构函数
    }
  }
};

• 注意type traits可能与预期表现不符

std::remove_const_t // 生成const int&

• 这里是引用不是const，所以调用没有效果。移除引用和const的顺序不同会导致不同的结果

std::remove_const_t> // int
std::remove_reference_t> // const int

• 也可以直接调用std::decay

std::decay_t // int

• type traits也会有不满足要求导致未定义行为的情况

make_unsigned_t // unsigned int
make_unsigned_t // undefined behavior (hopefully error)

• 有时结果可能出乎意料

add_rvalue_reference_t // int&&
add_rvalue_reference_t // const int&&
add_rvalue_reference_t // const int&（由于引用折叠，左值引用仍为左值引用）
is_copy_assignable_v // true（一把可以把int赋给int）
is_assignable_v // false（不能调用42 = 42）

• is_copy_assignable只检查能否把int赋给另一个（检查左值操作），is_assignable则考虑到值类型（这里检查能否把右值赋给右值），因此第一个表达式等价于

is_assignable_v // true

• 同理

is_swappable_v // true（假设是左值）
is_swappable_v // true（等价于上一行）
is_swappable_with_v // false（考虑值类型）

std::addressof

• std::addressof函数模板产生一个函数或对象的地址，即使对象类型重载了&，因此需要一个依赖于模板参数的地址时推荐使用std::addressof

template
void f(T&& x)
{
  auto p = &x; // 如果重载了operator&就可能失败
  auto q = std::addressof(x); // 即使重载了operator&也能工作
  ...
}

std::declval

• std::declval可以获取对象类型，但无需构造对象

struct Default { int foo() const { return 1; } };
 
struct NonDefault
{
  NonDefault(const NonDefault&) {}
  int foo() const { return 1; }
};
 
int main()
{
  decltype(Default().foo()) n1 = 1; // n1类型为int
  decltype(NonDefault().foo()) n2 = n1; // 错误：无默认构造函数
  decltype(std::declval().foo()) n2 = n1; // n2类型为int
}

• 比如下面的声明从T1和T2推断默认返回类型RT，为了避免调用T1和T2的构造函数，使用std::declval获取对应对象但不创建。使用std::declval必须确保默认返回类型不能为引用，它本身产生右值引用

template() : std::declval())>>
RT max(T1 a, T2 b)
{
  return b < a ? a : b;
}

完美转发临时对象

template
void f(T&& x)
{
  g(std::forward(x)); // 完美转发实参x给g()
}

• 然而有时不是直接地完美转发

template
void f(T x)
{
  g(doSomething(x));
}

• 如果想在转发前修改要转发的值，可以用auto&&存储结果，修改后再转发

template
void f(T x)
{
  auto&& res = doSomething(x);
  doSomethingElse(res);
  set(std::forward(res));
}

模板参数为引用的情况

• 尽管不常见，模板类型参数可以变成引用类型

#include 

template
void tmplParamIsReference(T)
{
  std::cout << std::is_reference_v << '\n';
}

int main()
{
  std::cout << std::boolalpha; // 之后打印true将为true而不是1
  int i;
  int& r = i;
  tmplParamIsReference(i); // false
  tmplParamIsReference(r); // false
  tmplParamIsReference(i); // true
  tmplParamIsReference(r); // true
}

• 而显式指定则可以强制T为引用，一些模板设计时没有考虑这个问题，就可能引发错误和未定义行为

template
class RefMem {
 public:
  RefMem() : zero{Z} {}
 private:
  T zero;
};

int null = 0;

int main()
{
  RefMem rm1, rm2;
  rm1 = rm2;       // OK

  RefMem rm3;    // ERROR: invalid default value for N
  RefMem rm4;   // ERROR: invalid default value for N

  extern int null;
  RefMem rm5, rm6;
  rm5 = rm6;       // ERROR: operator= is deleted due to reference member
}

• 对非类型模板参数使用引用类型也很危险

#include 
#include 

template // 注意：SZ是引用
class Arr {
 public:
  Arr() : elems(SZ) {}
  void print() const
  {
    for (int i = 0; i < SZ; ++i)
    {
      std::cout << elems[i] << ' ';  
    }
  }
 private:
  std::vector elems;
};

int size = 10;

int main()
{
  Arr y; // compile-time ERROR deep in the code of class std::vector<>
  Arr x;  // initializes internal vector with 10 elements
  x.print();    // OK
  size += 100;    // OOPS: modifies SZ in Arr<>
  x.print();    // run-time ERROR: invalid memory access: loops over 120 elements
}

• 上面这个例子有些牵强，但在更复杂的情况下确实可能发生，在C++17中非类型参数可以被推断，比如

template
class Arr;

• 使用decltype(auto)很容易产生引用类型。因此通常在这里会默认使用auto，标准库因此也有一些令人惊讶的规约限制，比如即使模板参数初始化为引用，为了仍然有赋值运算符，std::pair和std::tuple实现了赋值运算符，而不是使用默认行为

namespace std {
template
struct pair {
  T1 first;
  T2 second;
  ...
  // default copy/move constructors are OK even with references:
  pair(pair const&) = default;
  pair(pair&&) = default;
  ...
  // but assignment operator have to be defined to be available with references:
  pair& operator=(pair const& p);
  pair& operator=(pair&& p) noexcept(...);
  ...
};
}

• 又比如为了避免可能造成的副作用的复杂性，C++17的类模板std::optional和std::variant对引用是非法的
• 只需要使用简单的static断言就可以禁用引用

template
class optional {
  static_assert(!std::is_reference::value,
    "Invalid instantiation of optional for references");
  ...
};

延迟计算（Defer Evaluation）

• 实现模板时，有时代码是否能处理不完整类型也会引发问题

template
class Cont {
 private:
  T* elems;
 public:
  ...
};

• 目前这个类能用于不完整类型

struct Node {
  std::string value;
  Cont next; // 只有Cont能接受不完整类型时可行
};

• 然而如果使用一些type traits，可能就会失去处理不完整类型的能力

template
class Cont {
 public:
  std::conditional_t, T&&, T&> foo();
 private:
  T* elems;
};

• 这里用std::conditional决定返回类型为T&&还是T&，这依赖于T是否支持移动语义。问题在于is_move_constructible要求实参是完整类型（且不是void或一个数组的未知绑定），于是带有这个声明的struct node声明也会失败
• 可以用一个成员模板替代成员函数解决此问题，这样is_move_constructible的计算会延迟到成员模板的实例化点

template
class Cont {
 public:
  template
  std::conditional_t, T&&, T&> foo();
 private:
  T* elems;
};

编写泛型库的考虑事项

• 使用转发引用完美转发模板中的值。如果值需要改动，使用auto&&存储值
• 当参数被声明为转发引用，传递左值时，模板参数会被推断为引用类型
• 需要一个依赖于模板参数的地址时，使用std::addressof以防参数被绑定到一个重载了operator&的类型
• 确保成员函数模板不是比默认的拷贝/移动构造函数或赋值运算符更好的匹配
• 当模板参数可能是字符串字面值并且不是按值传递时，考虑使用std::decay
• 如果需要一个输入输出参数，它返回一个新对象或允许修改实参，传non-const引用（也可以按指针传递），但注意要考虑意外接收const对象的情况
• 考虑模板参数为引用的情况，尤其是想确保返回类型不能变成一个引用时
• 考虑对不完整类型的支持，比如递归的数据结构
• 对所有数组类型重载，而不只是T[SZ]