为什么 C++11 会从 std::vector 填充构造函数的原型中移除默认值？

Question

在 C++98 中，std::vector 的填充构造函数的原型具有初始值设定项的默认值。

explicit vector (size_type n, const value_type& val = value_type(),
                 const allocator_type& alloc = allocator_type());

C++11 使用两个原型。

explicit vector (size_type n);
         vector (size_type n, const value_type& val,
                 const allocator_type& alloc = allocator_type());

（在 C++14 中，填充构造函数再次更改，但这不是这个问题的重点。）

参考链接是here。

为什么 C++11 弃用了默认初始化值 value_type()？

顺便说一句，我尝试用clang++ -std=c++11编译下面的代码，它发出了一个错误，这意味着值类型仍然需要有一个像S() {}这样的默认构造函数，即可以默认构造。

#include <vector>

struct S {
    int k;
    S(int k) : k(k) {} // intentionally remove the synthesized default constructor
};

int main() {
    std::vector<S> s(5); // error: no matching constructor
}

Answer 1

C++98 取了一个原型对象，然后复制了 n 次。默认情况下，原型是一个默认构造的对象。

C++11 版本构造 n 个默认构造的对象。

这消除了 n 个副本并将其替换为 n 个默认构造。此外，它避免了构建原型。

假设你的班级看起来像这样：

struct bulky {
  std::vector<int> v;
  bulky():v(1000) {} // 1000 ints
  bulky(bulky const&)=default;
  bulky& operator=(bulky const&)=default;

  // in C++11, avoid ever having an empty vector to maintain
  // invariants:
  bulky(bulky&& o):bulky() {
    std::swap(v, o.v);
  }
  bulky& operator=(bulky&& o) {
    std::swap(v,o.v);
    return *this;
  }
};

这是一个总是拥有1000ints缓冲区的类。

如果我们随后创建bulky 的向量：

std::vector<bulky> v(2);

在 C++98 中，这分配了 3 次 1000 个整数。在 C++11 中，这仅分配 2 乘以 1000 个整数。

另外，C++98 版本要求类型是可复制的。 C++11中有不可复制的类型，比如std::unique_ptr<T>，使用C++98签名不能生成默认构造的唯一指针vector。 C++11签名没问题。

std::vector<std::unique_ptr<int>> v(100);

如果我们还有 C++98 版本，上面的方法就行不通了。

Answer 2

构造函数被分成两部分的原因是为了支持“只移动”类型，例如unique_ptr<T>。

这个构造函数：

vector(size_type n, const T& value, const Allocator& = Allocator());

要求T 是可复制构造的，因为必须从value 复制n Ts 才能填充vector。

这个构造函数：

explicit vector(size_type n, const Allocator& = Allocator());

不要求T 是可复制构造的，只有默认可构造的。

后一个构造函数与unique_ptr<T>一起工作：

std::vector<std::unique_ptr<int>> s(5);

而前一个构造函数没有。

这是进行此更改的提案：http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1858.html#23.2.4.1%20-%20vector%20constructors,%20copy,%20and%20assignment

这篇论文有一些基本原理，尽管无可否认有点简洁：http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1771.html

Fwiw，resize：

void resize(size_type sz, T c = T());

被分成：

void resize(size_type sz);
void resize(size_type sz, const T& c);

出于完全相同的原因。第一个需要默认可构造但不可复制构造（以支持默认可构造移动类型），第二个需要可复制构造。

这些更改并非 100% 向后兼容。对于某些类型（例如引用计数的智能指针），从默认构造对象复制构造与默认构造不同。然而，支持仅移动类型的好处被认为值得为这种 API 破坏付出代价。