c 11 – 使用const-correctness实现可变参数zip函数

发布时间：2020-12-16 07:26:12 所属栏目：百科来源：网络整理

导读：我正在尝试实现zip功能. zip的参数各自包裹 Ti,其中Ti随参数变化. zip采用这些包裹的 Ti并产生包裹的元组 T1,T2,... TN,或者换句话说,包含对其参数的引用元组.引用应该保持常量. 这是我第一次使用一个参数进行zip攻击,但这通常不起作用： #include utility#i

我正在尝试实现zip功能. zip的参数各自包裹< Ti>,其中Ti随参数变化.

zip采用这些包裹的< Ti>并产生包裹的<元组< T1&,T2&,... TN&>>,或者换句话说,包含对其参数的引用元组.引用应该保持常量.

这是我第一次使用一个参数进行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));

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!