Mengapa C ++ 11 tidak mendukung daftar penginisialisasi yang ditetapkan sebagai C99? [Tutup]

Mempertimbangkan:

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

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

Kode di atas legal di C99, tetapi tidak legal di C ++ 11.

Apa itu c ++ 11 alasan komite standar untuk mengecualikan dukungan untuk fitur praktis seperti itu?

C ++ memiliki konstruktor. Jika masuk akal untuk menginisialisasi hanya satu anggota maka itu dapat diekspresikan dalam program dengan menerapkan konstruktor yang sesuai. Ini adalah jenis abstraksi yang dipromosikan C ++.

Di sisi lain, fitur penginisialisasi yang ditunjuk lebih tentang mengekspos dan membuat anggota mudah diakses secara langsung dalam kode klien. Ini mengarah pada hal-hal seperti memiliki seseorang yang berusia 18 (tahun?) Tetapi dengan tinggi dan berat badan nol.

Dengan kata lain, penginisialisasi yang ditunjuk mendukung gaya pemrograman di mana internal diekspos, dan klien diberikan fleksibilitas untuk memutuskan bagaimana mereka ingin menggunakan tipe tersebut.

C ++ lebih tertarik untuk menempatkan fleksibilitas di sisi desainer dari suatu tipe, sehingga desainer dapat membuatnya mudah untuk menggunakan tipe dengan benar dan sulit untuk digunakan secara tidak benar. Menempatkan desainer untuk mengontrol bagaimana sebuah tipe dapat diinisialisasi adalah bagian dari ini: desainer menentukan konstruktor, inisialisasi dalam kelas, dll.

Pada tanggal 15 Juli '17 P0329R4 diterima dic ++ 20standar: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0329r4.pdf
Ini membawa dukungan terbatas untukc99Inisialisasi yang Ditunjuk. Batasan ini dijelaskan sebagai berikut oleh C.1.7 [diff.decl] .4, diberikan:

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

Inisialisasi yang Ditunjuk berikut ini, yang valid di C, dibatasi di C ++:

• struct A a = { .y = 1, .x = 2 } tidak valid di C ++ karena penunjuk harus muncul dalam urutan deklarasi anggota data
• int arr[3] = { [1] = 5 } tidak valid di C ++ karena inisialisasi yang ditunjuk larik tidak didukung
• struct B b = {.a.x = 0} tidak valid di C ++ karena penunjuk tidak dapat bertingkat
• struct A c = {.x = 1, 2} tidak valid di C ++ karena semua atau tidak satu pun anggota data harus diinisialisasi oleh penunjuk

Untuk c ++ 17dan Boost sebelumnya sebenarnya memiliki dukungan untuk Intializers yang Ditunjuk dan ada banyak proposal untuk menambahkan dukungan kec ++standar, misalnya: n4172 dan Proposal Daryle Walker untuk Menambahkan Penunjukan ke Penginisialisasi . Proposal mengutip implementasic99Penginisialisasi yang Ditunjuk dalam Visual C ++, gcc, dan Clang mengklaim:

Kami yakin perubahan akan relatif mudah diterapkan

Tetapi komite standar berulang kali menolak proposal tersebut , dengan menyatakan:

EWG menemukan berbagai masalah dengan pendekatan yang diusulkan, dan merasa tidak layak untuk mencoba menyelesaikan masalah tersebut, karena telah dicoba berkali-kali dan setiap kali gagal.

Komentar Ben Voigt telah membantu saya melihat masalah yang tidak dapat diatasi dengan pendekatan ini; diberikan:

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

Dalam urutan apa fungsi-fungsi ini dipanggil c99: struct X foo = {.a = (char)f(), .b = g(), .c = h()}? Anehnya, dic99:

Urutan evaluasi subekspresi di penginisialisasi apa pun diurutkan secara tidak pasti ^{[ 1 ]}

(Visual C ++, gcc , dan Clang tampaknya memiliki perilaku yang disepakati karena mereka semua akan melakukan panggilan dalam urutan ini :)

Tetapi sifat standar yang tidak dapat ditentukan berarti bahwa jika fungsi-fungsi ini memiliki interaksi apa pun, status program yang dihasilkan juga akan tidak dapat ditentukan, dan kompilator tidak akan memperingatkan Anda : Adakah Cara untuk Memperingatkan tentang Penginisialisasi yang Ditunjuk yang Tidak Beraturan?

c ++ memang memiliki persyaratan daftar penginisialisasi yang ketat 11.6.4 [dcl.init.list] 4:

Dalam daftar penginisialisasi dari daftar braced-init, klausa penginisialisasi, termasuk hasil dari perluasan paket (17.5.3), dievaluasi dalam urutan kemunculannya. Artinya, setiap penghitungan nilai dan efek samping yang terkait dengan klausa penginisialisasi tertentu diurutkan sebelum setiap penghitungan nilai dan efek samping yang terkait dengan klausa penginisialisasi apa pun yang mengikutinya dalam daftar daftar penginisialisasi yang dipisahkan koma.

Begitu c ++ dukungan akan meminta ini untuk dieksekusi dalam urutan:

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

Memecah kompatibilitas dengan sebelumnya c99implementasi.
Seperti dibahas di atas, masalah ini telah dielakkan oleh batasan pada Penginisialisasi yang Ditunjuk yang diterimac ++ 20. Mereka menyediakan perilaku standar, menjamin urutan eksekusi Penginisialisasi yang Ditunjuk.

Sedikit peretasan, jadi berbagi untuk kesenangan saja.

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

Dan gunakan seperti:

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

yang berkembang menjadi:

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

Penginisialisasi yang ditunjuk saat ini disertakan dalam badan kerja C ++ 20: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0329r4.pdf jadi kami mungkin akhirnya melihatnya!

Dua Fitur Core C99 yang C ++ 11 Lacks menyebutkan "Designated Initializers dan C ++".

Saya pikir 'penginisialisasi yang ditunjuk' terkait dengan pengoptimalan potensial. Di sini saya menggunakan “gcc / g ++” 5.1 sebagai contoh.

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

Kami tahu pada saat kompilasi, a_point.xadalah nol, jadi kami bisa berharap bahwa foodioptimalkan menjadi satu 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"

foodioptimalkan untuk mencetak x == 0saja.

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

Dan ini adalah keluaran dari kode assemble yang dioptimalkan.

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   

Kita dapat melihat bahwa a_pointsebenarnya bukan nilai konstanta waktu kompilasi.