เหตุใด C ++ 11 จึงไม่รองรับรายการ initializer ที่กำหนดเป็น C99 [ปิด]

พิจารณา:

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

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

รหัสด้านบนถูกต้องตามกฎหมายใน C99 แต่ไม่ถูกกฎหมายใน C ++ 11

สิ่งที่เป็น C ++ 11 เหตุผลของคณะกรรมการมาตรฐานในการยกเว้นการสนับสนุนคุณลักษณะที่มีประโยชน์เช่นนี้หรือไม่?

C ++ มีตัวสร้าง หากเหมาะสมที่จะเริ่มต้นสมาชิกเพียงคนเดียวก็สามารถแสดงในโปรแกรมได้โดยใช้ตัวสร้างที่เหมาะสม นี่คือประเภทของการส่งเสริม C ++ ที่เป็นนามธรรม

ในทางกลับกันคุณลักษณะ initializers ที่กำหนดนั้นเป็นข้อมูลเพิ่มเติมเกี่ยวกับการเปิดเผยและทำให้สมาชิกเข้าถึงได้ง่ายโดยตรงในรหัสไคลเอนต์ สิ่งนี้นำไปสู่สิ่งต่างๆเช่นการมีคนอายุ 18 ปี (ปี?) แต่มีส่วนสูงและน้ำหนักเป็นศูนย์

กล่าวอีกนัยหนึ่งโปรแกรมเริ่มต้นที่กำหนดไว้รองรับรูปแบบการเขียนโปรแกรมที่มีการเปิดเผยภายในและลูกค้าจะได้รับความยืดหยุ่นในการตัดสินใจว่าพวกเขาต้องการใช้ประเภทอย่างไร

C ++ สนใจที่จะวางความยืดหยุ่นไว้ที่ด้านข้างของนักออกแบบประเภทหนึ่งแทนดังนั้นนักออกแบบจึงสามารถใช้ประเภทได้อย่างถูกต้องและยากที่จะใช้อย่างไม่ถูกต้อง การกำหนดให้นักออกแบบสามารถควบคุมวิธีการเตรียมใช้งานประเภทได้เป็นส่วนหนึ่งของสิ่งนี้: นักออกแบบกำหนดตัวสร้างตัวเริ่มต้นในคลาส ฯลฯ

วันที่ 15 กรกฎาคม2560 P0329R4ได้รับการยอมรับในC ++ 20มาตรฐาน: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0329r4.pdf
สิ่งนี้นำมาซึ่งการสนับสนุนที่ จำกัด สำหรับc99Initializers ที่กำหนดไว้ ข้อ จำกัด นี้อธิบายไว้ดังต่อไปนี้โดย C.1.7 [diff.decl] .4 กำหนด:

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

การเริ่มต้นที่กำหนดไว้ต่อไปนี้ซึ่งใช้ได้ใน C ถูก จำกัด ใน C ++:

• struct A a = { .y = 1, .x = 2 } ไม่ถูกต้องใน C ++ เนื่องจากตัวกำหนดต้องปรากฏในลำดับการประกาศของสมาชิกข้อมูล
• int arr[3] = { [1] = 5 } ไม่ถูกต้องใน C ++ เนื่องจากไม่รองรับการกำหนดค่าเริ่มต้นของอาร์เรย์
• struct B b = {.a.x = 0} ไม่ถูกต้องใน C ++ เนื่องจากตัวกำหนดไม่สามารถซ้อนกันได้
• struct A c = {.x = 1, 2} ไม่ถูกต้องใน C ++ เนื่องจากสมาชิกข้อมูลทั้งหมดหรือทั้งหมดต้องได้รับการเตรียมใช้งานโดยผู้ออกแบบ

สำหรับ C ++ 17และก่อนหน้านี้ Boost ได้รองรับ Designated Intializersและมีข้อเสนอมากมายเพื่อเพิ่มการสนับสนุนให้กับC ++มาตรฐานตัวอย่างเช่น: n4172และข้อเสนอ Daryle วอล์คเกอร์ที่จะเพิ่มการกำหนดที่จะ Initializers ข้อเสนออ้างถึงการนำไปใช้c99ตัวเริ่มต้นที่กำหนดไว้ใน Visual C ++, gcc และ Clang โดยอ้างว่า:

เราเชื่อว่าการเปลี่ยนแปลงจะค่อนข้างตรงไปตรงมาในการนำไปใช้

แต่คณะกรรมการมาตรฐานปฏิเสธข้อเสนอดังกล่าวซ้ำแล้วซ้ำอีกโดยระบุว่า:

EWG พบปัญหาต่างๆเกี่ยวกับแนวทางที่เสนอและไม่คิดว่าจะเป็นไปได้ที่จะลองแก้ปัญหาเนื่องจากมีการพยายามหลายครั้งและทุกครั้งที่ล้มเหลว

ความคิดเห็นของ Ben Voigtช่วยให้ฉันเห็นปัญหาที่ผ่านไม่ได้ด้วยวิธีนี้ ได้รับ:

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

ฟังก์ชันเหล่านี้จะถูกเรียกในลำดับใด c99: struct X foo = {.a = (char)f(), .b = g(), .c = h()}? น่าแปลกที่ในc99:

ลำดับของการประเมินนิพจน์ย่อยในตัวเริ่มต้นใด ๆ จะเรียงตามลำดับอย่างไม่แน่นอน^{[ 1 ]}

(Visual C ++, gccและ Clang ดูเหมือนจะเห็นด้วยกับพฤติกรรมเนื่องจากพวกเขาทั้งหมดจะทำการโทรตามลำดับนี้ :)

แต่ลักษณะที่ไม่แน่นอนของมาตรฐานหมายความว่าหากฟังก์ชันเหล่านี้มีปฏิสัมพันธ์ใด ๆ สถานะของโปรแกรมที่เป็นผลลัพธ์ก็จะไม่แน่นอนและคอมไพเลอร์จะไม่เตือนคุณ : มีวิธีรับคำเตือนเกี่ยวกับการทำงานที่ไม่ถูกต้องของตัวเริ่มต้นที่กำหนดไว้หรือไม่?

C ++ ไม่ได้มีความต้องการที่เข้มงวด initializer รายการ 11.6.4 [dcl.init.list] 4:

ภายใน initializer-list ของ braced-init-list, initializer-clauses รวมถึงผลลัพธ์จากการขยายแพ็ก (17.5.3) จะได้รับการประเมินตามลำดับที่ปรากฏ นั่นคือทุกการคำนวณค่าและด้าน e ff ect ที่เกี่ยวข้องกับ initializer-clause ที่กำหนดจะถูกจัดลำดับก่อนการคำนวณค่าและผลข้างเคียงที่เกี่ยวข้องกับ initializer-clause ใด ๆ ที่ตามมาในรายการที่คั่นด้วยเครื่องหมายจุลภาคของ initializer-list

ดังนั้น C ++ การสนับสนุนจะต้องดำเนินการตามลำดับ:

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

ทำลายความเข้ากันได้กับรุ่นก่อนหน้า c99การใช้งาน
ตามที่กล่าวไว้ข้างต้นปัญหานี้ได้รับการหลีกเลี่ยงโดยข้อ จำกัด ของ Designated Initializers ที่ยอมรับในC ++ 20. มีลักษณะการทำงานที่เป็นมาตรฐานซึ่งรับประกันลำดับการดำเนินการของตัวเริ่มต้นที่กำหนด

แฮกเกอร์นิดหน่อยดังนั้นแค่แบ่งปันเพื่อความสนุกสนาน

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

และใช้มันเช่น:

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

ซึ่งขยายเป็น:

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

ขณะนี้เครื่องมือเริ่มต้นที่กำหนดไว้จะรวมอยู่ในเนื้องาน C ++ 20: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0329r4.pdfดังนั้นในที่สุดเราก็อาจจะเห็นมัน!

คุณสมบัติหลักของ C99 สองประการที่ C ++ 11 ขาดกล่าวถึง“ ตัวเริ่มต้นที่กำหนดและ C ++”

ฉันคิดว่า 'ตัวเริ่มต้นที่กำหนด' เกี่ยวข้องกับการเพิ่มประสิทธิภาพที่เป็นไปได้ ที่นี่ฉันใช้“ 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();
}

เรารู้ว่าในเวลารวบรวมa_point.xเป็นศูนย์เพื่อให้เราสามารถคาดหวังว่ามีการเพิ่มประสิทธิภาพเป็นหนึ่งfooprintf

$ 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ได้รับการปรับให้เหมาะกับการพิมพ์x == 0เท่านั้น

สำหรับเวอร์ชัน 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();
}

และนี่คือผลลัพธ์ของโค้ดแอสเซมบลีที่ปรับให้เหมาะสม

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   

เราจะเห็นได้ว่านั่นa_pointไม่ใช่ค่าคงที่ของเวลาคอมไพล์