什么是初始化的子表达式

struct B {
  B() throw();
  B(const B&) = default;        // implicit exception specification is noexcept(true)
  B(B&&, int = (throw Y(), 0)) noexcept;
  ~B() noexcept(false);
};
int n = 7;
struct D : public A, public B {
    int * p = new int[n];
    // D​::​D() potentially-throwing, as the new operator may throw bad_­alloc or bad_­array_­new_­length
    // D​::​D(const D&) non-throwing
    // D​::​D(D&&) potentially-throwing, as the default argument for B's constructor may throw
    // D​::​ D() potentially-throwing
};

考虑上面引用的代码 except.spec#11 我对D的所有构造函数的例外规范毫无疑问,除了 D::D(D&&) ,遵循以下规则:

类X的隐式声明构造函数,或在其第一个声明中默认的没有noexcept说明符的构造函数,如果且仅当以下任何构造可能引发异常时,才具有潜在的引发异常规范:

• 通过重载解析在类X的构造函数隐式定义中选择的构造函数,用于初始化潜在构造的子对象,或
• 这种初始化的子表达式 ,例如默认参数表达式,或者,
• 对于默认构造函数,默认成员初始化器。

显然,制定规则 D​::​D(D&&) 具有潜在抛出异常的规范既不是第一个项目符号,也不是第三个项目符号。对于第一条规则,所选构造函数用于初始化类型为的基子对象 B 是 B(B&&, int = (throw Y(), 0)) noexcept ,声明其具有非抛出异常规范。第三条规则适用于默认构造函数。因此,只有第二条规则适用于这种情况。

然而, D: :D(D&) 除了表达式 throw Y() 被认为是 D: :D(D&) .

定义直接子表达式的规则如下:

表达式e的直接子表达式是

1. e操作数的组成表达式
2. e隐式调用的任何函数调用 ,
3. 如果e是lambda表达式,则由copy捕获的实体的初始化和init初始化器的组成表达式被捕获,
4. 如果e是函数调用或隐式调用函数, 每个默认参数的组成表达式 在通话中使用,或
5. 如果e创建了一个聚合对象,则初始化中使用的每个默认成员初始化器([class.mem])的组成表达式。

表达式e的子表达式是e的直接子表达式,或者是e的立即子表达式的子表达式。

理解子表达式规则的简单方法是它递归工作,即,

immediate subexpression of immediate subexpression... of immediate subexpression of e 是以下的子表达式 e .

我同意这个表达 投掷Y() 是函数的子表达式 B(B&,int=(throw Y(),0))除此之外 由于第四颗子弹。然而,我不知道是否 B(B&,int=(throw Y(),0))除此之外 被视为 隐式调用函数 由表达式调用 D: :D(D&) ,这似乎服从了第二颗子弹。如果是这样,请考虑以下代码:

class Test{
  Test(){}
  ~Test(){}
};
void func(){
  Test t{} // implicitly invoke the defautl constructor of `Test`
  // would implicitly  invoke the destructor of `Test`
}
int main(){
  func();
}

所以,正如我在注释中写的那样,构造函数和析构函数是 Test 被视为表达的子表达 func() ?如果不是,如何解释措辞 a subexpression of such an initialization 那么,我的问题是:

Q1:

在第二个示例中,隐式调用的构造函数或析构函数是否被视为表达式的子表达式 func() ?

问题2:

如果第一个问题的答案是否定的,那么如何解释 这种初始化的子表达式 ?