¿Por qué C ++ 11 no admite listas de inicializadores designados como C99? [cerrado]

Considerar:

struct Person
{
    int height;
    int weight;
    int age;
};

int main()
{
    Person p { .age = 18 };
}

El código anterior es legal en C99, pero no es legal en C ++ 11.

Cual fue el c ++ 11 ¿Cuál es el fundamento del comité estándar para excluir el soporte para una característica tan útil?

C ++ tiene constructores. Si tiene sentido inicializar solo un miembro, entonces eso se puede expresar en el programa implementando un constructor apropiado. Este es el tipo de abstracción que promueve C ++.

Por otro lado, la función de inicializadores designados se trata más de exponer y facilitar el acceso de los miembros directamente en el código del cliente. Esto lleva a cosas como tener una persona de 18 años (¿años?) Pero con una altura y un peso de cero.

En otras palabras, los inicializadores designados admiten un estilo de programación en el que se exponen los componentes internos y el cliente tiene flexibilidad para decidir cómo desea utilizar el tipo.

C ++ está más interesado en poner la flexibilidad del lado del diseñador de un tipo, por lo que los diseñadores pueden facilitar el uso correcto de un tipo y dificultar el uso incorrecto. Poner al diseñador en control de cómo se puede inicializar un tipo es parte de esto: el diseñador determina los constructores, los inicializadores en clase, etc.

El 15 de julio de 2017 P0329R4 fue aceptado en elc ++ 20estándar: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0329r4.pdf
Esto brinda soporte limitado parac99Inicializadores designados. Esta limitación se describe como sigue en C.1.7 [diff.decl] .4, dado:

struct A { int x, y; };
struct B { struct A a; };

Las siguientes inicializaciones designadas, que son válidas en C, están restringidas en C ++:

• struct A a = { .y = 1, .x = 2 } no es válido en C ++ porque los designadores deben aparecer en el orden de declaración de los miembros de datos
• int arr[3] = { [1] = 5 } no es válido en C ++ porque la inicialización designada por matriz no es compatible
• struct B b = {.a.x = 0} no es válido en C ++ porque los designadores no se pueden anidar
• struct A c = {.x = 1, 2} no es válido en C ++ porque todos o ninguno de los miembros de datos deben ser inicializados por designadores

por c ++ 17y Boost anterior en realidad tiene soporte para Intializadores designados y ha habido numerosas propuestas para agregar soporte a lac ++estándar, por ejemplo: n4172 y la propuesta de Daryle Walker para agregar una designación a los inicializadores . Las propuestas citan la implementación dec99Inicializadores designados en Visual C ++, gcc y Clang que afirman:

Creemos que los cambios serán relativamente sencillos de implementar.

Pero el comité estándar rechaza repetidamente tales propuestas , afirmando:

EWG encontró varios problemas con el enfoque propuesto y no pensó que fuera factible intentar resolver el problema, ya que se ha intentado muchas veces y cada vez ha fallado.

Los comentarios de Ben Voigt me han ayudado a ver los problemas insuperables con este enfoque; dado:

struct X {
    int c;
    char a;
    float b;
};

¿En qué orden se llamarían estas funciones en c99: struct X foo = {.a = (char)f(), .b = g(), .c = h()}? Sorprendentemente, enc99:

El orden de evaluación de las subexpresiones en cualquier inicializador tiene una secuencia indeterminada ^{[ 1 ]}

(Visual C ++, gcc y Clang parecen tener un comportamiento acordado, ya que todos realizarán las llamadas en este orden :)

Pero la naturaleza indeterminada del estándar significa que si estas funciones tuvieran alguna interacción, el estado del programa resultante también sería indeterminado, y el compilador no le advertiría : ¿Hay alguna manera de recibir una advertencia sobre los inicializadores designados que se comportan mal?

c ++ no tienen requisitos estrictos de inicialización de listas 11.6.4 [dcl.init.list] 4:

Dentro de la lista de inicialización de una lista de inicialización entre llaves, las cláusulas de inicialización, incluidas las que resultan de las expansiones de paquetes (17.5.3), se evalúan en el orden en que aparecen. Es decir, cada cálculo de valor y efecto secundario asociado con una cláusula inicializadora dada se secuencia antes de cada cálculo de valor y efecto secundario asociado con cualquier cláusula inicializador que le siga en la lista separada por comas de la lista de inicializadores.

Entonces c ++ El soporte habría requerido que esto se ejecutara en el orden:

1. f()
2. g()
3. h()

Rompiendo la compatibilidad con anteriores c99implementaciones.
Como se discutió anteriormente, este problema ha sido eludido por las limitaciones en Inicializadores Designados aceptados enc ++ 20. Proporcionan un comportamiento estandarizado, garantizando el orden de ejecución de los Inicializadores Designados.

Un poco de piratería, así que solo comparte por diversión.

#define with(T, ...)\
    ([&]{ T ${}; __VA_ARGS__; return $; }())

Y utilícelo como:

MyFunction(with(Params,
    $.Name = "Foo Bar",
    $.Age  = 18
));

que se expande a:

MyFunction(([&] {
 Params ${};
 $.Name = "Foo Bar", $.Age = 18;
 return $;
}()));

Los inicializadores designados se incluyen actualmente en el cuerpo de trabajo de C ++ 20: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0329r4.pdf ¡ así que finalmente podríamos verlos!

Dos características principales de C99 de las que C ++ 11 carece menciona "Inicializadores designados y C ++".

Creo que el 'inicializador designado' relacionado con la optimización potencial. Aquí utilizo “gcc / g ++” 5.1 como ejemplo.

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>    
struct point {
    int x;
    int y;
};
const struct point a_point = {.x = 0, .y = 0};
int foo() {
    if(a_point.x == 0){
        printf("x == 0");
        return 0;
    }else{
        printf("x == 1");
        return 1;
    }
}
int main(int argc, char *argv[])
{
    return foo();
}

Sabíamos que en el momento de la compilación a_point.xes cero, por lo que podríamos esperar que fooesté optimizado en uno printf.

$ gcc -O3 a.c
$ gdb a.out
(gdb) disassemble foo
Dump of assembler code for function foo:
   0x00000000004004f0 <+0>: sub    $0x8,%rsp
   0x00000000004004f4 <+4>: mov    $0x4005bc,%edi
   0x00000000004004f9 <+9>: xor    %eax,%eax
   0x00000000004004fb <+11>:    callq  0x4003a0 <printf@plt>
   0x0000000000400500 <+16>:    xor    %eax,%eax
   0x0000000000400502 <+18>:    add    $0x8,%rsp
   0x0000000000400506 <+22>:    retq   
End of assembler dump.
(gdb) x /s 0x4005bc
0x4005bc:   "x == 0"

fooestá optimizado para imprimir x == 0únicamente.

Para la versión C ++,

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
struct point {
    point(int _x,int _y):x(_x),y(_y){}
    int x;
    int y;
};
const struct point a_point(0,0);
int foo() {
    if(a_point.x == 0){
        printf("x == 0");
        return 0;
    }else{
        printf("x == 1");
        return 1;
    }
}
int main(int argc, char *argv[])
{
    return foo();
}

Y esta es la salida del código ensamblado optimizado.

g++ -O3 a.cc
$ gdb a.out
(gdb) disassemble foo
Dump of assembler code for function _Z3foov:
0x00000000004005c0 <+0>:    push   %rbx
0x00000000004005c1 <+1>:    mov    0x200489(%rip),%ebx        # 0x600a50 <_ZL7a_point>
0x00000000004005c7 <+7>:    test   %ebx,%ebx
0x00000000004005c9 <+9>:    je     0x4005e0 <_Z3foov+32>
0x00000000004005cb <+11>:   mov    $0x1,%ebx
0x00000000004005d0 <+16>:   mov    $0x4006a3,%edi
0x00000000004005d5 <+21>:   xor    %eax,%eax
0x00000000004005d7 <+23>:   callq  0x400460 <printf@plt>
0x00000000004005dc <+28>:   mov    %ebx,%eax
0x00000000004005de <+30>:   pop    %rbx
0x00000000004005df <+31>:   retq   
0x00000000004005e0 <+32>:   mov    $0x40069c,%edi
0x00000000004005e5 <+37>:   xor    %eax,%eax
0x00000000004005e7 <+39>:   callq  0x400460 <printf@plt>
0x00000000004005ec <+44>:   mov    %ebx,%eax
0x00000000004005ee <+46>:   pop    %rbx
0x00000000004005ef <+47>:   retq   

Podemos ver que a_pointrealmente no es un valor constante de tiempo de compilación.