¿Es este un antiguo constructor de estilo C ++?

Aquí una pieza de código C ++.

En este ejemplo, muchos bloques de código parecen llamadas de constructor. Desafortunadamente, el código de bloqueo n. ° 3 no lo es (puede verificarlo usando https://godbolt.org/z/q3rsxn y https://cppinsights.io ).

Creo que es una notación antigua de C ++ y podría explicar la introducción de la nueva notación de construcción C ++ 11 usando {} (cf # 4).

¿Tiene una explicación para el T(i)significado, tan cerca de una notación de constructor, pero definitivamente tan diferente?

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: por lo tanto, T(i)(# 3) es equivalente a T i = T();

c++ c++11

— Pascal H.
fuente

Creo que todas tus declaraciones son correctas.

— Arne J

en.wikipedia.org/wiki/Most_vexing_parse

— QuentinUK

Tenga en cuenta que el compilador le dirá casi todo lo que necesita saber si solo lo pregunta: agregue -Wally obtenga "

warning: parentheses were disambiguated as redundant parentheses around declaration of variable named 'i' [-Wvexing-parse]

" de clang, o " warning: unnecessary parentheses in declaration of 'i' [-Wparentheses]" un poco menos motivado " de gcc .

— Max Langhof

@QuentinUK gracias por este enlace. Estaba al tanto de las funciones (por ejemplo T t()), pero no de expresiones de declaración tan simples. Por supuesto, esto podría ser irritante .

— Pascal H.

Respuestas:

La declaración:

T(i);

es equivalente a:

T i;

En otras palabras, declara una variable denominada icon tipo T. Esto se debe a que los paréntesis están permitidos en las declaraciones en algunos lugares (para cambiar el enlace de los declaradores) y dado que esta declaración se puede analizar como una declaración, es una declaración (aunque podría tener más sentido como expresión).

— Brian
fuente

Entonces, ¿es esto solo una elección de interpretación heredada de las especificaciones C donde int(i)también se declara un intnombre i?

— Pascal H.

@PascalH. Desde cierto punto de vista, eso podría ser cierto. Stroustrup escribió en D&E que había considerado una sintaxis de declaración alternativa más intuitiva para C ++. Si C ++ no hubiera tenido que ser retrocompatible con C, entonces quizás tendría la sintaxis alternativa, y así evitaría la posible ambigüedad con las expresiones.

— Brian

-1

Puede usar Compiler Explorer para ver qué sucede en el ensamblador.

Puede ver que # 1, # 2 # 4 y # 5 hacen lo mismo pero estranguladamente # 3 llaman al otro constructor (el constructor de objetos base).

¿Alguien tiene una explicación?

Código de ensamblador:

::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

— Matthieu H
fuente