将递归可变参数模板函数转换为迭代

我写了一些疯狂的东西，其中包含模板，索引序列和元组，完全受range-v3的概念约束，这很好。然后我想到，如果直接将参数解压缩到函数调用中，编译器将更容易优化。首先，我们创建一个可以反序列化任何POD类型的类（可以轻松地转换为普通复制）char*：

struct deserializer {
  const std::uint8_t* in_;

  deserializer(const std::uint8_t* in) : in_{in} {}

  template <typename T>
  operator T() {
    static_assert(std::is_pod<T>(), "");
    T t;
    std::memcpy(&t, in_, sizeof(T));
    in_ += sizeof(T);
    return t;
  }
};

然后您通常可以将其实现unpack为：

template <typename...Ts, typename F>
void unpack(F&& f, const std::uint8_t* from) {
  deserializer d{from};
  std::forward<F>(f)(static_cast<Ts>(d)...); // Oops, broken.
}

由于函数参数的顺序未指定，因此它具有未指定的行为。让我们介绍一种将参数转发给函数的类型，以便我们可以使用括号初始化来强制执行从左到右的求值：

struct forwarder {
  template <typename F, typename...Ts>
  forwarder(F&& f, Ts&&...ts) {
    std::forward<F>(f)(std::forward<Ts>(ts)...);
  }
};

// Requires explicit specification of argument types.
template <typename...Ts, typename F>
void unpack(F&& f, const std::uint8_t* from) {
  deserializer d{from};
  forwarder{std::forward<F>(f), static_cast<Ts>(d)...};
}

并投入了一些专门知识来从函数指针推断出参数类型，std::function因此我们不必总是指定它们：

// Deduce argument types from std::function
template <typename R, typename...Args>
void unpack(std::function<R(Args...)> f, const std::uint8_t* from) {
  unpack<Args...>(std::move(f), from);
}

// Deduce argument types from function pointer
template <typename R, typename...Args>
void unpack(R (*f)(Args...), const std::uint8_t* from) {
  unpack<Args...>(f, from);
}

所有这些都很好地暴露给了编译器并且非常可优化。在单次调用和两次调用之间，二进制大小的变化很小（窃取了TC的框架）：

使用函数指针：-O0为〜2K，-O3为64B。

std::function在-O0使用〜3K，在-O3使用216B。

要解压和调用的代码是几十个汇编指令。例如，在x64上的gcc 4.9.2使用-Os进行显式优化，以优化大小

template void unpack(decltype(foo1), const std::uint8_t*);

组装成：

pushq   %rax
movq    %rsi, %rax
movswl  4(%rsi), %ecx
movzwl  2(%rsi), %edx
movq    %rdi, %r10
movsbl  1(%rsi), %esi
movzbl  (%rax), %edi
pushq   22(%rax)
pushq   14(%rax)
movl    10(%rax), %r9d
movl    6(%rax), %r8d
movsd   34(%rax), %xmm1
movss   30(%rax), %xmm0
call    *(%r10)
addq    $24, %rsp
ret

代码大小足够小，可以有效地内联，因此生成的模板数量不是一个因素。

编辑：泛化到非PODs。

打包输入迭代器deserializer并使用转换运算符执行实际的拆包是“聪明的”（使用“聪明”的正负含义），但它不可扩展。客户端代码无法添加operator blahblah成员函数重载，并且控制转换运算符重载的唯一方法是使用SFINAE堆。呸。因此，让我们放弃这个deserializer想法，并使用可扩展的调度机制。

首先，使用元函数剥离引用和​​cv限定词，以便例如std::vector<double>在参数签名为时解包const std::vector<double>&：

template <typename T>
using uncvref =
  typename std::remove_cv<
    typename std::remove_reference<T>::type
  >::type;

我是标签分发的忠实拥护者，因此请设计一个可以容纳任何类型的标签包装器：

template <typename T> struct arg_tag {};

然后我们可以有一个通用的参数unpack函数来执行标签分配：

template <typename T>
uncvref<T> unpack_arg(const std::uint8_t*& from) {
  return unpack_arg(arg_tag<uncvref<T>>{}, from);

多亏了参数依赖查找的魔力，只要在使用前unpack_arg声明了重载，就可以发现在调度程序的定义之后声明的重载。即，调度系统很容易扩展。我们将提供POD解包器：

template <typename T, typename std::enable_if<std::is_trivial<T>::value, int>::type = 0>
T unpack_arg(arg_tag<T>, const std::uint8_t*& from) {
  T t;
  std::memcpy(&t, from, sizeof(T));
  from += sizeof(T);
  return t;
}

从技术上讲，它与any 匹配arg_tag，但是如果匹配的类型很重要，则SFINAE将其从重载解析中删除。（是的，我知道我之前说过POD。我改变了主意；琐碎的类型更加通用并且仍然memcpy可以使用。）这种调度机制的前端并没有太大变化：

struct forwarder {
  template <typename F, typename...Args>
  forwarder(F&& f, Args&&...args) {
    std::forward<F>(f)(std::forward<Args>(args)...);
  }
};

// Requires explicit specification of argument types.
template <typename...Ts, typename F>
void unpack(F&& f, const std::uint8_t* from) {
  forwarder{std::forward<F>(f), unpack_arg<Ts>(from)...};
}

forwarder保持不变，unpack<Types...>()API用来unpack_arg<Ts>(from)...代替static_cast<Ts>(d)...但显然仍然具有相同的结构。推导类型的重载：

template <typename R, typename...Args>
void unpack(std::function<R(Args...)> f, const std::uint8_t* from) {
  unpack<Args...>(std::move(f), from);
}

template <typename R, typename...Args>
void unpack(R (*f)(Args...), const std::uint8_t* from) {
  unpack<Args...>(f, from);
}

正常工作不变。现在，我们可以通过重载unpack_arg以下内容来提供解压缩向量的扩展arg_tag<std::vector<T>>：

using vec_size_t = int;

template <typename T>
std::vector<T> unpack_arg(arg_tag<std::vector<T>>, const std::uint8_t*& from) {
  std::vector<T> vec;
  auto n = unpack_arg<vec_size_t>(from);
  vec.reserve(n);
  std::generate_n(std::back_inserter(vec), n, [&from]{
    return unpack_arg<T>(from);
  });
  return vec;
}

请注意向量解包重载如何通过分派器解压缩其组件：unpack_arg<vec_size_t>(from)对于大小和unpack_arg<T>(from)每个元素。

再次编辑： std::function<void()>

现在的代码有一个问题：如果f是std::function<void()>，void(*)(void)则unpack推论参数类型的重载f将调用它们并无限递归。最简单的解决方法是命名该函数来完成解压缩不同内容的实际工作-我将选择unpack_explicit-并使用各种unpack前端对其进行调用：

template <typename...Ts, typename F>
void unpack_explicit(F&& f, const std::uint8_t* from) {
  forwarder{std::forward<F>(f), unpack_arg<Ts>(from)...};
}

// Requires explicit specification of argument types.
template <typename...Ts, typename F>
void unpack(F&& f, const std::uint8_t* from) {
  unpack_explicit<Ts...>(std::forward<F>(f), from);
}

// Deduce argument types from std::function
template <typename R, typename...Args>
void unpack(std::function<R(Args...)> f, const std::uint8_t* from) {
  unpack_explicit<Args...>(std::move(f), from);
}

// Deduce argument types from function pointer
template <typename R, typename...Args>
void unpack(R (*f)(Args...), const std::uint8_t* from) {
  unpack_explicit<Args...>(f, from);
}

在这里，所有这些都放在一起。如果您更喜欢返回类型为以外的函数的编译错误，请从推论重载中void删除R用于推导返回类型的参数，并简单地使用void：

// Deduce argument types from std::function
template <typename...Args>
void unpack(std::function<void(Args...)> f, const std::uint8_t* from) {
  unpack_explicit<Args...>(std::move(f), from);
}

// Deduce argument types from function pointer
template <typename...Args>
void unpack(void (*f)(Args...), const std::uint8_t* from) {
  unpack_explicit<Args...>(f, from);
}