C++11 对和元组的piecewise_construct 用例？

Question

在 N3059 中，我找到了分段构造的描述 对（和元组）（它在新标准中）。

但我不知道什么时候应该使用它。我发现了关于emplace和不可复制实体的讨论，但是当我尝试时，我无法创建一个我需要piecewiese_construct或可以看到性能优势。

例子。我认为我需要一个不可复制的类，但是movebale（转发所需）：

struct NoCopy {
  NoCopy(int, int) {};
  NoCopy(const NoCopy&) = delete; // no copy
  NoCopy& operator=(const NoCopy&) = delete; // no assign
  NoCopy(NoCopy&&) {}; // please move
  NoCopy& operator=(NoCopy&&) {}; // please move-assign
};

然后我有点期望标准对构造会失败：

pair<NoCopy,NoCopy> x{ NoCopy{1,2}, NoCopy{2,3} }; // fine!

但是它没有。实际上，这正是我所期望的，因为“移动东西”而不是在 stdlib 中的任何地方复制它，这是应该的。

因此，我认为没有理由这样做，或者说：

pair<NoCopy,NoCopy> y(
    piecewise_construct,
    forward_as_tuple(1,2),
    forward_as_tuple(2,3)
); // also fine

• 那么，什么是用例？
• 如何以及何时使用piecewise_construct？

Answer 1

并非所有类型的移动都比复制更有效，对于某些类型，甚至显式禁用复制和移动可能是有意义的。将 std::array 作为前一种类型的示例。

emplace 函数和 piecewise_construct 的要点是，可以就地构造这样的类，而无需创建要移动的临时实例或复制的。

struct big {
    int data[100];
    big(int first, int second) : data{first, second} {
        // the rest of the array is presumably filled somehow as well
    }
};

std::pair<big, big> pair(piecewise_construct, {1,2}, {3,4});

将上面的内容与 pair(big(1,2), big(3,4)) 进行比较，其中必须创建两个临时 big 对象，然后复制 - 并移动在这里根本没有帮助！类似地：

std::vector<big> vec;
vec.emplace_back(1,2);

分段构造对的主要用例是将元素放入 map 或 unordered_map 中：

std::map<int, big> map;
map.emplace(std::piecewise_construct, /*key*/1, /*value*/{2,3});

Answer 2

piecewise_construct 的一项功能是在执行重载解析来构造对象时避免错误的转换。

考虑一个具有一组奇怪的构造函数重载的 Foo：

struct Foo {
    Foo(std::tuple<float, float>) { /* ... */ }
    Foo(int, double) { /* ... */ }
};

int main() {
    std::map<std::string, Foo> m1;
    std::pair<int, double> p1{1, 3.14};

    m1.emplace("Will call Foo(std::tuple<float, float>)",
               p1);

    m1.emplace("Will still call Foo(std::tuple<float, float>)",
               std::forward_as_tuple(2, 3.14));

    m1.emplace(std::piecewise_construct,
               std::forward_as_tuple("Will call Foo(int, double)"),
               std::forward_as_tuple(3, 3.14));

    // Some care is required, though...
    m1.emplace(std::piecewise_construct,
               std::forward_as_tuple("Will call Foo(std::tuple<float, float>)!"),
               std::forward_as_tuple(p1));
}