Tại sao C ++ 11 không hỗ trợ danh sách bộ khởi tạo được chỉ định là C99? [đóng cửa]

Xem xét:

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

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

Mã trên là hợp pháp trong C99, nhưng không hợp pháp trong C ++ 11.

Cái gì là c ++ 11 cơ sở lý luận của ủy ban tiêu chuẩn để loại trừ hỗ trợ cho một tính năng tiện dụng như vậy?

C ++ có các hàm tạo. Nếu chỉ khởi tạo một thành viên là hợp lý thì điều đó có thể được thể hiện trong chương trình bằng cách triển khai một phương thức khởi tạo thích hợp. Đây là kiểu trừu tượng mà C ++ khuyến khích.

Mặt khác, tính năng khởi tạo được chỉ định thiên về việc hiển thị và giúp các thành viên dễ dàng truy cập trực tiếp bằng mã khách hàng. Điều này dẫn đến những điều như có một người 18 tuổi (năm?) Nhưng với chiều cao và cân nặng bằng không.

Nói cách khác, các trình khởi tạo được chỉ định hỗ trợ một kiểu lập trình mà các phần tử bên trong được hiển thị và khách hàng được cung cấp sự linh hoạt để quyết định cách họ muốn sử dụng kiểu.

Thay vào đó, C ++ quan tâm nhiều hơn đến việc đặt tính linh hoạt về phía người thiết kế một kiểu, vì vậy các nhà thiết kế có thể dễ dàng sử dụng một kiểu một cách chính xác và khó sử dụng sai. Đặt trình thiết kế kiểm soát cách một kiểu có thể được khởi tạo là một phần của việc này: trình thiết kế xác định các hàm tạo, trình khởi tạo trong lớp, v.v.

Vào ngày 15 tháng 7 năm 17, P0329R4 đã được chấp nhận vàoc ++ 20standard: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0329r4.pdf
Điều này mang lại hỗ trợ hạn chế choc99Bộ khởi tạo được chỉ định. Hạn chế này được mô tả như sau trong C.1.7 [diff.decl] .4, đưa ra:

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

Các khởi tạo được chỉ định sau đây, hợp lệ trong C, bị hạn chế trong C ++:

• struct A a = { .y = 1, .x = 2 } không hợp lệ trong C ++ vì người chỉ định phải xuất hiện trong thứ tự khai báo của các thành viên dữ liệu
• int arr[3] = { [1] = 5 } không hợp lệ trong C ++ vì không hỗ trợ khởi tạo mảng được chỉ định
• struct B b = {.a.x = 0} không hợp lệ trong C ++ vì không thể lồng ghép các ký hiệu chỉ định
• struct A c = {.x = 1, 2} không hợp lệ trong C ++ vì tất cả hoặc không có thành viên dữ liệu nào phải được khởi tạo bởi người chỉ định

Đối với c ++ 17và Boost trước đó thực sự có hỗ trợ cho Intializers được chỉ định và đã có nhiều đề xuất để thêm hỗ trợ choc ++tiêu chuẩn, ví dụ: n4172 và Đề xuất của Daryle Walker để Thêm Chỉ định vào Bộ khởi tạo . Các đề xuất trích dẫn việc thực hiệnc99Các trình khởi tạo được chỉ định của Visual C ++, gcc và Clang tuyên bố:

Chúng tôi tin rằng những thay đổi sẽ tương đối dễ thực hiện

Nhưng ủy ban tiêu chuẩn liên tục từ chối các đề xuất như vậy , nói rõ:

EWG đã tìm thấy nhiều vấn đề khác nhau với cách tiếp cận được đề xuất và không nghĩ rằng việc thử giải quyết vấn đề này là khả thi, vì nó đã được thử nhiều lần và lần nào cũng thất bại

Những nhận xét của Ben Voigt đã giúp tôi thấy được những vấn đề không thể vượt qua với cách tiếp cận này; được:

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

Thứ tự các hàm này sẽ được gọi trong c99: struct X foo = {.a = (char)f(), .b = g(), .c = h()}? Đáng ngạc nhiên, trongc99:

Thứ tự đánh giá các biểu thức phụ trong bất kỳ trình khởi tạo nào được sắp xếp theo trình tự không xác định ^{[ 1 ]}

(Visual C ++, gcc và Clang dường như có một hành vi đã được thỏa thuận vì tất cả chúng sẽ thực hiện các lệnh gọi theo thứ tự này :)

Nhưng bản chất không xác định của tiêu chuẩn có nghĩa là nếu các chức năng này có bất kỳ tương tác nào, trạng thái chương trình kết quả cũng sẽ không xác định và trình biên dịch sẽ không cảnh báo bạn : Có Cách nào để Cảnh báo về việc Hoạt động sai Bộ khởi tạo được Chỉ định không?

c ++ không có yêu cầu nghiêm ngặt initializer-list 11.6.4 [dcl.init.list] 4:

Trong danh sách bộ khởi tạo của một danh sách giằng-init, các mệnh đề bộ khởi tạo, bao gồm bất kỳ điều khoản nào là kết quả của việc mở rộng gói (17.5.3), được đánh giá theo thứ tự mà chúng xuất hiện. Có nghĩa là, mọi phép tính giá trị và phụ liên kết với một mệnh đề khởi tạo nhất định được giải trình tự trước mọi phép tính giá trị và tác dụng phụ được liên kết với bất kỳ mệnh đề khởi tạo nào theo sau nó trong danh sách được phân tách bằng dấu phẩy của danh sách bộ khởi tạo.

Vì thế c ++ hỗ trợ sẽ yêu cầu điều này được thực hiện theo thứ tự:

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

Phá vỡ khả năng tương thích với trước đó c99triển khai.
Như đã thảo luận ở trên, vấn đề này đã được giải quyết bởi những hạn chế về Trình khởi tạo được chỉ định được chấp nhận vàoc ++ 20. Chúng cung cấp một hành vi tiêu chuẩn hóa, đảm bảo thứ tự thực thi của các Trình khởi tạo được Chỉ định.

Hơi hackery nên chia sẻ cho vui thôi.

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

Và sử dụng nó như:

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

mở rộng thành:

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

Bộ khởi tạo được chỉ định hiện được bao gồm trong nội dung C ++ 20: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0329r4.pdf nên cuối cùng chúng ta cũng có thể thấy chúng!

Hai Tính năng Core C99 mà C ++ 11 thiếu đề cập đến “Bộ khởi tạo được chỉ định và C ++”.

Tôi nghĩ rằng 'trình khởi tạo được chỉ định' liên quan đến tối ưu hóa tiềm năng. Ở đây tôi sử dụng “gcc / g ++” 5.1 làm ví dụ.

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

Chúng tôi đã biết tại thời điểm biên dịch, a_point.xlà 0, vì vậy chúng tôi có thể mong đợi rằng nó foođược tối ưu hóa thành một 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được tối ưu hóa để x == 0chỉ in .

Đối với phiên bả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();
}

Và đây là đầu ra của mã lắp ráp được tối ưu hóa.

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   

Chúng ta có thể thấy rằng đó a_pointkhông thực sự là một giá trị hằng số thời gian biên dịch.