Warum unterstützt C ++ 11 bestimmte Initialisierungslisten nicht als C99? [geschlossen]

Erwägen:

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

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

Der obige Code ist in C99 legal, in C ++ 11 jedoch nicht.

Was war der c ++ 11 Begründung des Standardausschusses, die Unterstützung für eine solche praktische Funktion auszuschließen?

C ++ hat Konstruktoren. Wenn es sinnvoll ist, nur ein Mitglied zu initialisieren, kann dies im Programm durch Implementierung eines geeigneten Konstruktors ausgedrückt werden. Dies ist die Art von Abstraktion, die C ++ fördert.

Auf der anderen Seite geht es bei der Funktion für bestimmte Initialisierer eher darum, Mitglieder direkt im Client-Code verfügbar zu machen und ihnen den Zugriff zu erleichtern. Dies führt zu Dingen wie einer Person im Alter von 18 (Jahren?), Aber mit einer Größe und einem Gewicht von Null.

Mit anderen Worten, bestimmte Initialisierer unterstützen einen Programmierstil, bei dem Interna verfügbar gemacht werden, und der Client erhält die Flexibilität, zu entscheiden, wie er den Typ verwenden möchte.

C ++ ist mehr daran interessiert, die Flexibilität auf die Seite des Designers eines Typs zu legen, damit Designer es einfach machen können, einen Typ richtig und falsch zu verwenden. Dazu gehört, dass der Designer die Kontrolle darüber hat, wie ein Typ initialisiert werden kann: Der Designer bestimmt Konstruktoren, Initialisierer in der Klasse usw.

Am 15. Juli 17 wurde P0329R4 in die aufgenommenc ++ 20Standard: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0329r4.pdf
Dies bringt begrenzte Unterstützung fürc99Designated Initializers. Diese Einschränkung wird in C.1.7 [diff.decl] .4 wie folgt beschrieben:

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

Die folgenden designierten Initialisierungen, die in C gültig sind, sind in C ++ eingeschränkt:

• struct A a = { .y = 1, .x = 2 } ist in C ++ ungültig, da Bezeichner in der Deklarationsreihenfolge der Datenelemente erscheinen müssen
• int arr[3] = { [1] = 5 } ist in C ++ ungültig, da die vom Array festgelegte Initialisierung nicht unterstützt wird
• struct B b = {.a.x = 0} ist in C ++ ungültig, da Bezeichner nicht verschachtelt werden können
• struct A c = {.x = 1, 2} ist in C ++ ungültig, da entweder alle oder keine der Datenelemente von Bezeichnern initialisiert werden müssen

Zum c ++ 17und früher hat Boost tatsächlich Unterstützung für Designated Intializers und es gab zahlreiche Vorschläge, um die Unterstützung für die hinzuzufügenc ++Standard, zum Beispiel: n4172 und Daryle Walkers Vorschlag, Initialisierern eine Bezeichnung hinzuzufügen . Die Vorschläge zitieren die Umsetzung vonc99Designated Initializers in Visual C ++, gcc und Clang behaupten:

Wir glauben, dass die Änderungen relativ einfach umzusetzen sein werden

Das Standardkomitee lehnt solche Vorschläge jedoch wiederholt ab und erklärt:

Die EWG stellte verschiedene Probleme mit dem vorgeschlagenen Ansatz fest und hielt es nicht für möglich, das Problem zu lösen, da es viele Male versucht wurde und jedes Mal fehlschlug

Die Kommentare von Ben Voigt haben mir geholfen, die unüberwindlichen Probleme mit diesem Ansatz zu erkennen. gegeben:

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

In welcher Reihenfolge würden diese Funktionen aufgerufen? c99: struct X foo = {.a = (char)f(), .b = g(), .c = h()}? Überraschenderweise inc99::

Die Reihenfolge der Auswertung der Unterausdrücke in einem Initialisierer ist unbestimmt geordnet ^{[ 1 ]}

(Visual C ++, gcc und Clang scheinen ein vereinbartes Verhalten zu haben, da sie alle die Anrufe in dieser Reihenfolge tätigen werden :)

Die Unbestimmtheit des Standards bedeutet jedoch, dass bei einer Interaktion dieser Funktionen auch der resultierende Programmstatus unbestimmt wäre und der Compiler Sie nicht warnen würde : Gibt es eine Möglichkeit, sich vor schlecht benommenen designierten Initialisierern zu warnen ?

c ++ hat strenge Anforderungen an die Initialisierungsliste 11.6.4 [dcl.init.list] 4:

Innerhalb der Initialisiererliste einer Klammer-Init-Liste werden die Initialisierer-Klauseln, einschließlich aller Klauseln, die sich aus Pack-Erweiterungen (17.5.3) ergeben, in der Reihenfolge ausgewertet, in der sie erscheinen. Das heißt, jede Wertberechnung und jeder Nebeneffekt, die einer bestimmten Initialisierungsklausel zugeordnet sind, wird vor jeder Wertberechnung und jedem Nebeneffekt, der einer Initialisierungsklausel zugeordnet ist, die darauf folgt, in der durch Kommas getrennten Liste der Initialisierungsliste sequenziert.

So c ++ Für den Support wäre dies in der folgenden Reihenfolge erforderlich gewesen:

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

Kompatibilität mit früheren brechen c99Implementierungen.
Wie oben erläutert, wurde dieses Problem durch die Einschränkungen für Designated Initializers umgangen, die in akzeptiert wurdenc ++ 20. Sie bieten ein standardisiertes Verhalten und garantieren die Ausführungsreihenfolge der Designated Initializers.

Ein bisschen Hackery, also nur zum Spaß teilen.

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

Und benutze es wie:

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

was erweitert zu:

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

Bestimmte Initialisierer sind derzeit in C ++ 20 enthalten: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0329r4.pdf, damit wir sie endlich sehen können!

Zwei Kernfunktionen von C99 , die in C ++ 11 fehlen, erwähnen „Designated Initializers and C ++“.

Ich denke, der "designierte Initialisierer" bezog sich auf eine mögliche Optimierung. Hier verwende ich als Beispiel "gcc / g ++" 5.1.

#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();
}

Wir wussten zur Kompilierungszeit, dass a_point.xNull ist, also konnten wir erwarten, dass dies foozu einer einzigen optimiert wird 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"

fooist x == 0nur für den Druck optimiert .

Für die C ++ - Version

#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();
}

Und dies wird vom optimierten Assemble-Code ausgegeben.

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   

Wir können sehen, dass dies a_pointnicht wirklich ein Wert für die Kompilierungszeitkonstante ist.