我正在尝试实现 zip 函数。 zip 的每个参数都是 wrapped<Ti> ,其中 Ti 因参数而异。
zip 接受这些 wrapped<Ti> 并产生一个 wrapped<tuple<T1&,T2&,...TN&>> ,或者换句话说,一个包装的 tuple 对其参数的引用。引用应该保留 const -ness。

这是我第一次使用一个参数对 zip 进行尝试,这通常不起作用:

#include <utility>
#include <tuple>

// implement forward_as_tuple as it is missing on my system
namespace ns
{

template<typename... Types>
  std::tuple<Types&&...>
    forward_as_tuple(Types&&... t)
{
  return std::tuple<Types&&...>(std::forward<Types>(t)...);
}

}

template<typename T>
  struct wrapped
{
  wrapped(T &&x)
    : m_x(std::forward<T>(x))
  {}

  T m_x;
};

template<typename T>
  wrapped<std::tuple<T&&>>
    zip(wrapped<T> &&x)
{
  auto t = ns::forward_as_tuple(std::forward<T>(x.m_x));
  return wrapped<std::tuple<T&&>>(t);
}

int main()
{
  wrapped<int> w1(13);

  wrapped<int> &ref_w1 = w1;

  // OK
  zip(ref_w1);

  const wrapped<int> &cref_w1 = w1;

  // XXX won't compile when passing a const reference
  zip(cref_w1);

  return 0;
}

有没有办法用单一版本的 zip 实现一般的可变情况?

最佳答案

诚然,我没有处理可变参数模板的 C++0x 编译器,因此我无法对其进行测试。但这可能会奏效。

template<typename T>
    struct wrapped
{
    wrapped(T &&x)
    : m_x(std::forward<T>(x))
    {}

    typedef T type;

    T m_x;
};

template<typename... Types>
    wrapped<std::tuple<Types&&...>> zip(wrapped<Types>&&... x)
{
    return wrapped<std::tuple<Types&&...>>(std::tuple<Types&&...>(std::forward<Types>(x.m_x)...));
}

我不完全确定像这样调用 zip 是否合法:
zip(wrapped<T1>(value1), wrapped<T2>(value2));

您可能必须明确限定调用:
zip<T1, T2>(wrapped<T1>(value1), wrapped<T2>(value2));

关于c++11 - 实现具有常量正确性的可变参数 zip 函数,我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/6631782/

10-11 22:48
查看更多