Est-ce un ancien constructeur de style C ++?

Voici un morceau de code C ++.

Dans cet exemple, de nombreux blocs de code ressemblent à des appels de constructeur. Malheureusement, le code de blocage # 3 ne l'est pas (vous pouvez le vérifier en utilisant https://godbolt.org/z/q3rsxn et https://cppinsights.io ).

Je pense que c'est une ancienne notation C ++ et cela pourrait expliquer l'introduction de la nouvelle notation de construction C ++ 11 en utilisant {} (cf # 4).

Avez-vous une explication du T(i)sens, si proche d'une notation constructeur, mais certainement si différente?

struct T {
   T() { }
   T(int i) { }
};

int main() {
  int i = 42;
  {  // #1
     T t(i);     // new T named t using int ctor
  }
  {  // #2
     T t = T(i); // new T named t using int ctor
  }
  {  // #3
     T(i);       // new T named i using default ctor
  }
  {  // #4
     T{i};       // new T using int ctor (unnamed result)
  }
  {  // #5
     T(2);       // new T using int ctor (unnamed result)
  }
}

NB: ainsi T(i)(# 3) est équivalent à T i = T();

La déclaration:

T(i);

est équivalent à:

T i;

En d'autres termes, il déclare une variable nommée iavec type T. En effet, les parenthèses sont autorisées dans les déclarations à certains endroits (afin de modifier la liaison des déclarants) et puisque cette instruction peut être analysée comme une déclaration, il s'agit d'une déclaration (même si elle peut avoir plus de sens en tant qu'expression).

Vous pouvez utiliser l' Explorateur de compilateur pour voir ce qui se passe dans l'assembleur.

Vous pouvez voir que # 1, # 2 # 4 et # 5 font la même chose mais étrangement # 3 appelle l'autre constructeur (le constructeur de l'objet de base).

Est-ce que quelqu'un a une explication?

Code assembleur:

::T() [base object constructor]:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        nop
        pop     rbp
        ret
T::T(int):
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        mov     DWORD PTR [rbp-12], esi
        nop
        pop     rbp
        ret
main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     DWORD PTR [rbp-4], 42
// #1
        mov     edx, DWORD PTR [rbp-4]
        lea     rax, [rbp-7]
        mov     esi, edx
        mov     rdi, rax
        call    T::T(int)
// #2
        mov     edx, DWORD PTR [rbp-4]
        lea     rax, [rbp-8]
        mov     esi, edx
        mov     rdi, rax
        call    T::T(int)
// #3
        lea     rax, [rbp-9]
        mov     rdi, rax
        call    T::T() [complete object constructor]
// #4
        mov     edx, DWORD PTR [rbp-4]
        lea     rax, [rbp-6]
        mov     esi, edx
        mov     rdi, rax
        call    T::T(int)
// #5
        lea     rax, [rbp-5]
        mov     esi, 2
        mov     rdi, rax
        call    T::T(int)

        mov     eax, 0
        leave
        ret