10-泛型库

回调

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

template<typename Iter, typename Callable>
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<int> 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'; });
}

处理成员函数和附加实参

// basics/foreachinvoke.hpp

#include <utility>
#include <functional>
template<typename Iter, typename Callable, typename... Args>
void foreach (Iter current, Iter end, Callable op, const Args&... args)
{
  while (current != end)
  {
    std::invoke(op, args..., *current);
    ++current;
  }
}
  • 这里除了函数对象,还能接收任意数量的附加参数。如果函数对象是一个类成员指针,使用第一个附加实参作为this对象,其余作为实参传递给函数对象,否则所有附加参数都只传递给函数对象
#include <iostream>
#include <vector>
#include <string>
#include "foreachinvoke.hpp"

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

int main()
{
  std::vector<int> 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<typename Callable, typename... Args>
decltype(auto) call(Callable&& op, Args&&... args)
{
  return std::invoke(std::forward<Callable>(op),
    std::forward<Args>(args)...);
}
  • 如果想临时存储std::invoke返回的值,也必须用decltype(auto)声明临时变量
template<typename Callable, typename... Args>
decltype(auto) call(Callable&& op, Args&&... args)
{
  decltype(auto) ret{std::invoke(std::forward<Callable>(op),
    std::forward<Args>(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<Callable>(op), std::forward<Args>(args)...);
  • 另一个方法是使用if constexpr实现不同的分支
template<typename Callable, typename... Args>
decltype(auto) call(Callable&& op, Args&&... args)
{
  if constexpr (std::is_same_v<std::invoke_result_t<Callable, Args...>, void>)
  {
    std::invoke(std::forward<Callable>(op), std::forward<Args>(args)...);
    return;
  }
  else
  {
    decltype(auto) ret{std::invoke(std::forward<Callable>(op),
      std::forward<Args>(args)...)};
    return ret;
  }
}

实现泛型库的其他工具

#include <type_traits>

template<typename T>
class C {
  static_assert(!std::is_same_v<std::remove_cv_t<T>,void>,
    "invalid instantiation of class C for void type");
 public:
  template<typename V>
  void f(V&& v)
  {
    if constexpr(std::is_reference_v<T>)
    {
      ... // 如果T是引用类型
    }
    if constexpr(std::is_convertible_v<std::decay_t<V>,T>)
    {
      ... // 如果V能转换为T
    }
    if constexpr(std::has_virtual_destructor_v<V>)
    {
      ... // 如果V有析构函数
    }
  }
};
std::remove_const_t<const int&> // 生成const int&
  • 这里是引用不是const,所以调用没有效果。移除引用和const的顺序不同会导致不同的结果
std::remove_const_t<std::remove_reference_t<const int&>> // int
std::remove_reference_t<std::remove_const_t<const int&>> // const int
std::decay_t<const int&> // int
  • type traits也会有不满足要求导致未定义行为的情况
make_unsigned_t<int> // unsigned int
make_unsigned_t<const int&> // undefined behavior (hopefully error)
  • 有时结果可能出乎意料
add_rvalue_reference_t<int> // int&&
add_rvalue_reference_t<const int> // const int&&
add_rvalue_reference_t<const int&> // const int&(由于引用折叠,左值引用仍为左值引用)
is_copy_assignable_v<int> // true(一把可以把int赋给int)
is_assignable_v<int, int> // false(不能调用42 = 42)
  • is_copy_assignable只检查能否把int赋给另一个(检查左值操作),is_assignable则考虑到值类型(这里检查能否把右值赋给右值),因此第一个表达式等价于
is_assignable_v<int&, int&> // true
  • 同理
is_swappable_v<int> // true(假设是左值)
is_swappable_v<int&, int&> // true(等价于上一行)
is_swappable_with_v<int, int> // false(考虑值类型)

std::addressof

  • std::addressof函数模板产生一个函数或对象的地址,即使对象类型重载了&,因此需要一个依赖于模板参数的地址时推荐使用std::addressof
template<typename T>
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<NonDefault>().foo()) n2 = n1; // n2类型为int
}
  • 比如下面的声明从T1和T2推断默认返回类型RT,为了避免调用T1和T2的构造函数,使用std::declval获取对应对象但不创建。使用std::declval必须确保默认返回类型不能为引用,它本身产生右值引用
template<typename T1, typename T2,
  typename RT = std::decay_t<decltype(true ?
    std::declval<T1>() : std::declval<T2>())>>
RT max(T1 a, T2 b)
{
  return b < a ? a : b;
}

完美转发临时对象

template<typename T>
void f(T&& x)
{
  g(std::forward<T>(x)); // 完美转发实参x给g()
}
  • 然而有时不是直接地完美转发
template<typename T>
void f(T x)
{
  g(doSomething(x));
}
  • 如果想在转发前修改要转发的值,可以用auto&&存储结果,修改后再转发
template<typename T>
void f(T x)
{
  auto&& res = doSomething(x);
  doSomethingElse(res);
  set(std::forward<decltype(res)>(res));
}

模板参数为引用的情况

  • 尽管不常见,模板类型参数可以变成引用类型
#include <iostream>

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

int main()
{
  std::cout << std::boolalpha; // 之后打印true将为true而不是1
  int i;
  int& r = i;
  tmplParamIsReference(i); // false
  tmplParamIsReference(r); // false
  tmplParamIsReference<int&>(i); // true
  tmplParamIsReference<int&>(r); // true
}
  • 而显式指定则可以强制T为引用,一些模板设计时没有考虑这个问题,就可能引发错误和未定义行为
template<typename T, T Z = T{}>
class RefMem {
 public:
  RefMem() : zero{Z} {}
 private:
  T zero;
};

int null = 0;

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

  RefMem<int&> rm3;    // ERROR: invalid default value for N
  RefMem<int&, 0> rm4;   // ERROR: invalid default value for N

  extern int null;
  RefMem<int&,null> rm5, rm6;
  rm5 = rm6;       // ERROR: operator= is deleted due to reference member
}
  • 对非类型模板参数使用引用类型也很危险
#include <vector>
#include <iostream>

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

int size = 10;

int main()
{
  Arr<int&, size> y; // compile-time ERROR deep in the code of class std::vector<>
  Arr<int, size> 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<typename T, decltype(auto) SZ>
class Arr;
  • 使用decltype(auto)很容易产生引用类型。因此通常在这里会默认使用auto,标准库因此也有一些令人惊讶的规约限制,比如即使模板参数初始化为引用,为了仍然有赋值运算符,std::pairstd::tuple实现了赋值运算符,而不是使用默认行为
namespace std {
template<typename T1, typename T2>
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::optionalstd::variant对引用是非法的
  • 只需要使用简单的static断言就可以禁用引用
template<typename T>
class optional {
  static_assert(!std::is_reference<T>::value,
    "Invalid instantiation of optional<T> for references");
  ...
};

延迟计算(Defer Evaluation)

  • 实现模板时,有时代码是否能处理不完整类型也会引发问题
template<typename T>
class Cont {
 private:
  T* elems;
 public:
  ...
};
  • 目前这个类能用于不完整类型
struct Node {
  std::string value;
  Cont<Node> next; // 只有Cont能接受不完整类型时可行
};
  • 然而如果使用一些type traits,可能就会失去处理不完整类型的能力
template<typename T>
class Cont {
 public:
  std::conditional_t<std::is_move_constructible_v<T>, T&&, T&> foo();
 private:
  T* elems;
};
  • 这里用std::conditional决定返回类型为T&&还是T&,这依赖于T是否支持移动语义。问题在于is_move_constructible要求实参是完整类型(且不是void或一个数组的未知绑定),于是带有这个声明的struct node声明也会失败
  • 可以用一个成员模板替代成员函数解决此问题,这样is_move_constructible的计算会延迟到成员模板的实例化点
template<typename T>
class Cont {
 public:
  template<typename U = T>
  std::conditional_t<std::is_move_constructible_v<U>, T&&, T&> foo();
 private:
  T* elems;
};

编写泛型库的考虑事项

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

文章作者: 张小飞
版权声明: 本博客所有文章除特別声明外,均采用 CC BY-NC-ND 4.0 许可协议。转载请注明来源 张小飞 !
 上一篇
11-深入模板基础 11-深入模板基础
参数化声明 C++现在支持四种原始模板:函数模板、类模板、C++14引入的变量模板(variable template)和别名模板(alias template) template<typename T> // 类模板 class
下一篇 
09-模板实战 09-模板实战
链接错误 不同于一般代码的是,对模板使用头文件声明、源文件定义的组织方式,编译器会接受,但链接器会产生无法找到函数定义的错误 // basics/myfirst.hpp #ifndef MYFIRST_HPP #define MYFIR
  目录