C++ 11中的new keyword = default

Question

我不明白为什么我会这样做:

struct S { 
    int a; 
    S(int aa) : a(aa) {} 
    S() = default; 
};

为什么不说:

S() {} // instead of S() = default;

为什么要为此引入一个新关键字？

Answer 1

默认的默认构造函数具体定义为与没有初始化列表和空复合语句的用户定义的默认构造函数相同.

§12.1/ 6 [class.ctor]当默认构造函数用于创建其类类型的对象或在第一次声明后显式默认时,默认构造函数被默认定义并且未定义为已删除.隐式定义的默认构造函数执行该类的初始化集,该初始化集将由该用户编写的默认构造函数执行,该类没有ctor-initializer(12.6.2)和空复合语句.[...]

但是,虽然两个构造函数的行为相同,但提供空实现确实会影响类的某些属性.给用户定义的构造函数,即使它什么也不做,使得类型不是聚合,也不是微不足道的.如果您希望您的类是聚合类型或普通类型(或通过传递性,POD类型),那么您需要使用= default.

§8.5.1/ 1 [dcl.init.aggr]聚合是一个没有用户提供的构造函数的数组或类,[和...]

§12.1/ 5 [class.ctor]默认构造函数如果不是用户提供的则是微不足道的[...]

§9/ 6 [class]一个普通的类是一个具有普通默认构造函数和[...]的类.

展示:

#include <type_traits>

struct X {
    X() = default;
};

struct Y {
    Y() { };
};

int main() {
    static_assert(std::is_trivial<X>::value, "X should be trivial");
    static_assert(std::is_pod<X>::value, "X should be POD");

    static_assert(!std::is_trivial<Y>::value, "Y should not be trivial");
    static_assert(!std::is_pod<Y>::value, "Y should not be POD");
}

另外,constexpr如果隐式构造函数已经存在,那么明确地默认构造函数将使它成为默认构造函数,并且也会给它与隐式构造函数所具有的相同的异常规范.在你给出的情况下,隐式构造函数不会constexpr(因为它会使数据成员保持未初始化)并且它也会有一个空的异常规范,所以没有区别.但是,是的,在一般情况下,您可以手动指定constexpr和异常规范以匹配隐式构造函数.

使用= default确实带来了一些统一性,因为它也可以与复制/移动构造函数和析构函数一起使用.例如,空复制构造函数与默认复制构造函数(将执行其成员的成员复制副本)不同.对每个特殊成员函数统一使用= default(或= delete)语法,通过明确说明您的意图,使代码更易于阅读.

Answer 2

n2210提供了一些理由:

默认管理有几个问题:

• 构造函数定义是耦合的; 声明任何构造函数都会抑制默认构造函数.
• 析构函数默认值不适合多态类,需要显式定义.
• 一旦默认被抑制,就没有办法复活它.
• 默认实现通常比手动指定的实现更有效.
• 非默认实现是非平凡的,它会影响类型语义,例如,使类型为非POD.
• 没有声明(非平凡的)替代品,没有办法禁止特殊成员函数或全局运算符.

type::type() = default;
type::type() { x = 3; }

在某些情况下,类主体可以在不需要更改成员函数定义的情况下进行更改,因为默认值随附加成员的声明而更改.

见规则- -三成为与C++ 11条-的五？:

请注意,不会为显式声明任何其他特殊成员函数的类生成移动构造函数和移动赋值运算符,不会为显式声明移动构造函数或移动的类生成复制构造函数和复制赋值运算符赋值运算符,并且具有显式声明的析构函数和隐式定义的复制构造函数或隐式定义的复制赋值运算符的类被视为已弃用

Answer 3

在某些情况下,这是语义问题.使用默认构造函数并不是很明显,但是对于其他编译器生成的成员函数,这一点很明显.

对于默认构造函数,可以使任何具有空体的默认构造函数被认为是一个简单的构造函数的候选者,与使用相同=default.毕竟,旧的空默认构造函数是合法的C++.

struct S { 
  int a; 
  S() {} // legal C++ 
};

在大多数情况下,编译器是否理解这个构造函数是微不足道的,在优化之外(手动或编译器)是无关紧要的.

但是,这种将空函数体视为"默认"的尝试完全打破了其他类型的成员函数.考虑复制构造函数:

struct S { 
  int a; 
  S() {}
  S(const S&) {} // legal, but semantically wrong
};

在上面的例子中,用空体写的复制构造函数现在是错误的.它不再真正复制任何东西.这是一组与默认复制构造函数语义完全不同的语义.所需的行为要求您编写一些代码:

struct S { 
  int a; 
  S() {}
  S(const S& src) : a(src.a) {} // fixed
};

然而,即使使用这种简单的情况,编译器验证复制构造函数与它自己生成的复制构造函数是否完全相同,或者看到复制构造函数是微不足道的(相当于a memcpy,基本上是).编译器必须检查每个成员初始化程序表达式,并确保它与访问源的相应成员的表达式相同,而不是其他任何内容,确保没有成员留下非平凡的默认构造等.它以过程的方式向后编译器将用于验证它自己生成的此函数版本是微不足道的.

然后考虑复制赋值运算符,它可以变得更加毛茸茸,特别是在非平凡的情况下.这是一堆锅炉板,你不想为很多课程写,但你无论如何都要被迫在C++ 03中:

struct T { 
  std::shared_ptr<int> b; 
  T(); // the usual definitions
  T(const T&);
  T& operator=(const T& src) {
    if (this != &src) // not actually needed for this simple example
      b = src.b; // non-trivial operation
    return *this;
};

这是一个简单的例子,但它已经有了比你想要被迫为这样一个简单类型编写的代码T(特别是一旦我们将操作转移到混合中).我们不能依赖一个空体,意思是"填写默认值",因为空体已经完全有效且具有明确的含义.事实上,如果空体被用来表示"填写默认值",那么就没有办法明确地制作一个无操作的复制构造函数等.

这又是一致性的问题.空体意味着"什么都不做",但对于复制构造函数这样的东西,你真的不想"什么都不做",而是"做所有你通常做的事情,如果不被压制的话".因此=default.有必要克服压缩编译器生成的成员函数,如复制/移动构造函数和赋值运算符.然后,使其适用于默认构造函数也是"显而易见的".

=default如果只是为了使旧代码在某些情况下更优化,但是大多数低级代码依赖于琐碎的事情,那么使用空实体制作默认构造函数并且简单的成员/基本构造函数也可能被认为是微不足道的.用于优化的默认构造函数也依赖于普通的复制构造函数.如果你将不得不去"修复"所有旧的拷贝构造函数,那么必须修复所有旧的默认构造函数并不是一件容易的事.使用明确=default表示您的意图,它也更清晰,更明显.

编译器生成的成员函数还会执行一些其他操作,您必须明确地进行更改以支持.支持constexpr默认构造函数就是一个例子.精神上使用它=default比使用所有其他特殊关键字标记函数更容易,这些关键字是隐含的=default,这是C++ 11的主题之一:使语言更容易.它仍然有很多瑕疵和反击的妥协,但很明显,从易用性开始,它是C++ 03的一大进步.

Answer 4

由于std::is_pod及其替代方案的弃用std::is_trivial && std::is_standard_layout，@JosephMansfield 的答案中的片段变为：

#include <type_traits>

struct X {
    X() = default;
};

struct Y {
    Y() {}
};

int main() {
    static_assert(std::is_trivial_v<X>, "X should be trivial");
    static_assert(std::is_standard_layout_v<X>, "X should be standard layout");

    static_assert(!std::is_trivial_v<Y>, "Y should not be trivial");
    static_assert(std::is_standard_layout_v<Y>, "Y should be standard layout");
}

请注意，Y仍然是标准布局。

Answer 5

通过创建对象时存在显着差异new T()。在默认构造函数的情况下，将进行聚合初始化，将所有成员值初始化为默认值。如果构造函数为空，则不会发生这种情况。（两者都不会发生new T）

考虑下面的类：

struct T {
    T() = default;
    T(int x, int c) : s(c) {
        for (int i = 0; i < s; i++) {
            d[i] = x;
        }
    }
    T(const T& o) {
        s = o.s;
        for (int i = 0; i < s; i++) {
            d[i] = o.d[i];
        }
    }
    void push(int x) { d[s++] = x; }
    int pop() { return d[--s]; }

private:
    int s = 0;
    int d[1<<20];
};

new T()将所有成员初始化为零，包括 4 MiB 数组（memset在 gcc 的情况下初始化为 0）。在这种情况下，这显然是不希望的，定义一个空的构造函数T() {}可以防止这种情况发生。

事实上，当 CLion 建议替换T() {}为T() = default. 它导致性能显着下降并需要数小时的调试/基准测试。

所以我毕竟更喜欢使用空构造函数，除非我真的希望能够使用聚合初始化。

Answer 6

我有一个例子，将显示差异：

#include <iostream>

using namespace std;
class A 
{
public:
    int x;
    A(){}
};

class B 
{
public:
    int x;
    B()=default;
};


int main() 
{ 
    int x = 5;
    new(&x)A(); // Call for empty constructor, which does nothing
    cout << x << endl;
    new(&x)B; // Call for default constructor
    cout << x << endl;
    new(&x)B(); // Call for default constructor + Value initialization
    cout << x << endl;
    return 0; 
} 

输出：

5
5
0

如我们所见，对空A（）构造函数的调用不会初始化成员，而B（）会初始化成员。