如何在 C 中正確初始化僅移動類型的向量？

僅移動類型的向量初始化

考慮以下程式碼，其目的是使用std::unique_ptr 實例初始化向量：

#include <vector>
#include <memory>

int main() {
  using move_only = std::unique_ptr<int>;
  std::vector<move_only> v{move_only(), move_only(), move_only()};
}</move_only></int></memory></vector>

但是，這段程式碼在GCC中編譯時會觸發錯誤4.7，由於std::unique_ptr 不支援複製，編譯器會在初始化期間嘗試建立指標的副本。

GCC 的行為

GCC 嘗試複製在目前的 C標準下，指標可以被認為是正確的，該標準沒有明確解決僅移動類型的列表初始化場景，例如unique_ptr.

替代初始化方法

要正確初始化僅移動類型的向量，可以採用以下方法：

使用迭代器：

這種方法涉及為初始化列表並將其傳遞給向量的構造函數：

#include <iterator>
#include <vector>
#include <memory>

int main() {
  using move_only = std::unique_ptr<int>;
  move_only init[] = {move_only(), move_only(), move_only()};
  std::vector<move_only> v{std::make_move_iterator(std::begin(init)),
                           std::make_move_iterator(std::end(init))};
}</move_only></int></memory></vector></iterator>

使用rref_wrapper：

此技術採用為行動引用提供暫存的輔助類型：

#include <utility>
#include <type_traits>

template<class t>
struct rref_wrapper
{
  explicit rref_wrapper(T&& v) : _val(std::move(v)) {}
  explicit operator T() const { return T{std::move(_val)}; }

private:
  T&& _val;
};

template<class t>
typename std::enable_if::value,
                         rref_wrapper<t>&>::type
rref(T&& v) {
  return rref_wrapper<t>(std::move(v));
}

template<class t>
void rref(T&) = delete;

int main() {
  using move_only = std::unique_ptr<int>;
  std::initializer_list<rref_wrapper>> il{rref(move_only()),
                                                  rref(move_only()),
                                                  rref(move_only())};
  std::vector<move_only> v(il.begin(), il.end());
}</move_only></rref_wrapper></int></class></t></t></class></class></type_traits></utility>

以上是如何在 C 中正確初始化僅移動類型的向量？的詳細內容。更多資訊請關注PHP中文網其他相關文章！