Por que o C ++ 11 não oferece suporte a listas de inicializadores designadas como C99? [fechadas]

Considerar:

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

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

O código acima é legal no C99, mas não é legal no C ++ 11.

Como era o c ++ 11 a justificativa do comitê padrão para excluir o suporte para um recurso tão útil?

C ++ possui construtores. Se fizer sentido inicializar apenas um membro, isso pode ser expresso no programa, implementando um construtor apropriado. Esse é o tipo de abstração que o C ++ promove.

Por outro lado, o recurso de inicializadores designados é mais sobre expor e tornar os membros fáceis de acessar diretamente no código do cliente. Isso leva a coisas como ter uma pessoa de 18 (anos?), Mas com altura e peso zero.

Em outras palavras, os inicializadores designados oferecem suporte a um estilo de programação em que os internos são expostos e o cliente tem flexibilidade para decidir como deseja usar o tipo.

Em vez disso, C ++ está mais interessado em colocar a flexibilidade do lado do designer de um tipo, para que os designers possam facilitar o uso correto de um tipo e dificultar o uso incorreto. Colocar o designer no controle de como um tipo pode ser inicializado faz parte disso: o designer determina construtores, inicializadores na classe, etc.

Em 15 de julho de 17, P0329R4 foi aceito noc ++ 20padrão: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0329r4.pdf
Isso traz suporte limitado parac99Inicializadores designados de. Esta limitação é descrita a seguir por C.1.7 [diff.decl] .4, dado:

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

As seguintes inicializações designadas, que são válidas em C, são restritas em C ++:

• struct A a = { .y = 1, .x = 2 } é inválido em C ++ porque os designadores devem aparecer na ordem de declaração dos membros de dados
• int arr[3] = { [1] = 5 } é inválido em C ++ porque a inicialização designada por matriz não é compatível
• struct B b = {.a.x = 0} é inválido em C ++ porque os designadores não podem ser aninhados
• struct A c = {.x = 1, 2} é inválido em C ++ porque todos ou nenhum dos membros de dados devem ser inicializados por designadores

Para c ++ 17e Boost anterior, na verdade, tem suporte para inicializadores designados e houve inúmeras propostas para adicionar suporte aoc ++padrão, por exemplo: n4172 e a proposta de Daryle Walker para adicionar designação aos inicializadores . As propostas citam a implementação dec99Inicializadores designados da em Visual C ++, gcc e Clang, afirmando:

Acreditamos que as mudanças serão relativamente simples de implementar

Mas o comitê padrão rejeita repetidamente tais propostas , afirmando:

O EWG encontrou vários problemas com a abordagem proposta e não achou viável tentar resolver o problema, pois já foi tentado várias vezes e sempre falhou

Os comentários de Ben Voigt me ajudaram a ver os problemas intransponíveis dessa abordagem; dado:

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

Em que ordem essas funções seriam chamadas em c99: struct X foo = {.a = (char)f(), .b = g(), .c = h()}? Surpreendentemente, emc99:

A ordem de avaliação das subexpressões em qualquer inicializador é sequenciada indeterminadamente ^{[ 1 ]}

(Visual C ++, gcc e Clang parecem ter um comportamento acordado, pois todos farão as chamadas nesta ordem :)

Mas a natureza indeterminada do padrão significa que, se essas funções tivessem qualquer interação, o estado do programa resultante também seria indeterminado, e o compilador não o avisaria : Existe uma maneira de ser avisado sobre o mau comportamento de inicializadores designados?

c ++ não têm requisitos de lista de inicializador rigorosas 11.6.4 [dcl.init.list] 4:

Na lista de inicializadores de uma lista de inicializações com chaves, as cláusulas inicializadoras, incluindo qualquer uma que resulte de expansões de pacote (17.5.3), são avaliadas na ordem em que aparecem. Ou seja, cada cálculo de valor e efeito colateral associado a uma determinada cláusula inicializadora é sequenciado antes de cada cálculo de valor e efeito colateral associado a qualquer cláusula inicializadora que o segue na lista separada por vírgulas da lista inicializadora.

assim c ++ o suporte teria exigido que fosse executado na ordem:

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

Quebrando a compatibilidade com o anterior c99implementações.
Conforme discutido acima, este problema foi contornado pelas limitações dos inicializadores designados aceitos emc ++ 20. Eles fornecem um comportamento padronizado, garantindo a ordem de execução dos Inicializadores Designados.

Um pouco de hackeagem, então apenas compartilhar por diversão.

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

E use-o como:

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

que se expande para:

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

O inicializador designado está atualmente incluído no corpo de trabalho do C ++ 20: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0329r4.pdf, então podemos finalmente vê-los!

Dois recursos centrais do C99 que faltam no C ++ 11 mencionam “Inicializadores designados e C ++”.

Acho que o 'inicializador designado' está relacionado com a otimização potencial. Aqui eu uso “gcc / g ++” 5.1 como exemplo.

#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 em tempo de compilação, a_point.xé zero, então poderíamos esperar que foofosse otimizado em um único 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"

fooé otimizado para imprimir x == 0apenas.

Para a versão 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();
}

E esta é a saída do código de montagem otimizado.

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_pointnão é realmente um valor constante de tempo de compilação.