2

所以我有一个聚合类Foo，它接受可移动和（间接）可复制的参数（一个名为Image_t和 a的类std::unique_ptr<Map>，并且 Map 可以克隆自己）。

我想给最终用户如何创建课程的灵活性。所以我有一个“类复制”构造函数和一个“类移动”构造函数：

  typdef std::unique_ptr<Map> MapPtr;

  ///
  ///@brief Copy build constructor
  ///
  Foo(const Image_t& image, const MapPtr& map_ptr) :
  image_(image),
  geo_locatormap_(map_ptr->clone())
  {

  }

  ///
  ///@brief Move build constructor
  ///
  Foo(Image_t&& image, MapPtr&& map_ptr) :
  image_(std::move(image))
  geo_locatormap_(std::move(map_ptr))
  {

  }

现在理想情况下，我也想拥有Foo(const Image_t& image, MapPtr&& map_ptr)，Foo(Image_t&& image, const MapPtr& map_ptr)但我觉得这是在重复努力。有没有快速的方法来做到这一点？还是这种类型的构造函数不受欢迎？

4

3 回答 3

3

使用类型推导、完美转发和一个小帮手：

static MapPtr&& map_forward( MapPtr&& m ) { return std::move( m ); }
static MapPtr map_forward( const MapPtr& m ) { return m->clone(); }

template<typename I, typename M>
Foo(I&& i, M&& m) :
image_{std::forward<I>(i)},
geo_locatormap_{map_forward(std::forward<M>(m))}
{

}
于 2013-10-22T13:34:14.743 回答
1

在您的情况下，由于您不能完美地转发map_ptr通过（除非您使用 Daniel Frey 的回答中的辅助功能），您需要单独处理这种情况。我能想到的一种将构造函数计数减少到两个的方法是这样的：

// Clone the map.
template <typename Image>
Foo(Image&& img, MapPtr const& map_ptr)
    : image_{ std::forward<Image>(img) },
      geo_locatormap_{ map_ptr->clone() }
{ }

// move the map.
template <typename Image>
Foo(Image&& img, MapPtr&& map_ptr)
    : image_{ std::forward<Image>(img) },
      geo_locatormap_{ std::move(map_ptr) }
{ }

Image&& 语法将绑定到任何左值/右值引用，并且std::forward您将获得该类型的最佳操作。

于 2013-10-22T13:34:10.223 回答
0

只定义一个版本就足够了： Foo(Image_t&& image, MapPtr&& map_ptr)

请查看此链接中的示例以获取更多详细信息。

于 2013-10-22T13:31:40.013 回答