Khởi tạo cấu trúc C ++

Có thể khởi tạo cấu trúc trong C ++ như được chỉ ra dưới đây không

struct address {
    int street_no;
    char *street_name;
    char *city;
    char *prov;
    char *postal_code;
};
address temp_address =
    { .city = "Hamilton", .prov = "Ontario" };

Các liên kết ở đây và ở đây đề cập rằng chỉ có thể sử dụng kiểu này trong C. Nếu vậy tại sao điều này không thể có trong C ++? Có bất kỳ lý do kỹ thuật cơ bản nào tại sao nó không được triển khai trong C ++, hoặc sử dụng phong cách này là không tốt. Tôi thích sử dụng cách khởi tạo này vì cấu trúc của tôi lớn và phong cách này cho tôi khả năng đọc rõ ràng về giá trị nào được gán cho thành viên nào.

Hãy chia sẻ với tôi nếu có những cách khác để chúng ta có thể đạt được khả năng đọc tương tự.

Tôi đã giới thiệu các liên kết sau trước khi đăng câu hỏi này

1. C / C ++ cho AIX
2. Khởi tạo cấu trúc C với biến
3. Khởi tạo cấu trúc tĩnh với các thẻ trong C ++
4. C ++ 11 Khởi tạo cấu trúc phù hợp

Nếu bạn muốn làm rõ từng giá trị của trình khởi tạo là gì, chỉ cần chia nó thành nhiều dòng, với một nhận xét trên mỗi dòng:

address temp_addres = {
  0,  // street_no
  nullptr,  // street_name
  "Hamilton",  // city
  "Ontario",  // prov
  nullptr,  // postal_code
};

Sau khi câu hỏi của tôi không mang lại kết quả thỏa mãn (vì C ++ không triển khai init dựa trên thẻ cho các cấu trúc), tôi đã sử dụng mẹo mà tôi tìm thấy ở đây: Các thành viên của cấu trúc C ++ được khởi tạo thành 0 theo mặc định?

Đối với bạn, nó sẽ là số tiền để làm điều đó:

address temp_address = {}; // will zero all fields in C++
temp_address.city = "Hamilton";
temp_address.prov = "Ontario";

Đây chắc chắn là gần nhất với những gì bạn muốn ban đầu (không có tất cả các trường trừ những trường bạn muốn khởi tạo).

Như những người khác đã đề cập đây là chỉ định khởi tạo.

Tính năng này là một phần của C ++ 20

Các định danh trường thực sự là cú pháp khởi tạo C. Trong C ++, chỉ cần đưa ra các giá trị theo đúng thứ tự mà không cần tên trường. Thật không may, điều này có nghĩa là bạn cần cung cấp cho tất cả chúng (thực ra bạn có thể bỏ qua các trường có giá trị bằng 0 và kết quả sẽ giống nhau):

address temp_address = { 0, 0, "Hamilton", "Ontario", 0 }; 

Tính năng này được gọi là khởi tạo được chỉ định . Nó là một bổ sung cho tiêu chuẩn C99. Tuy nhiên, tính năng này đã bị loại khỏi C ++ 11. Theo Ngôn ngữ lập trình C ++, ấn bản thứ 4, Mục 44.3.3.2 (Tính năng C không được thông qua bởi C ++):

Một vài bổ sung cho C99 (so với C89) đã không được chấp nhận trong C ++:

[1] Mảng có độ dài thay đổi (VLAs); sử dụng vector hoặc một số dạng của mảng động

[2] Chỉ định khởi tạo; sử dụng các nhà xây dựng

Ngữ pháp C99 có các trình khởi tạo được chỉ định [Xem ISO / IEC 9899: 2011, Dự thảo của Ủy ban N1570 - ngày 12 tháng 4 năm 2011]

6.7.9 Khởi tạo

initializer:
    assignment-expression
    { initializer-list }
    { initializer-list , }
initializer-list:
    designation_opt initializer
    initializer-list , designationopt initializer
designation:
    designator-list =
designator-list:
    designator
    designator-list designator
designator:
    [ constant-expression ]
    . identifier

Mặt khác, C ++ 11 không có bộ khởi tạo được chỉ định [Xem ISO / IEC 14882: 2011, Dự thảo của Ủy ban N3690 - ngày 15 tháng 5 năm 2013]

8,5 Khởi tạo

initializer:
    brace-or-equal-initializer
    ( expression-list )
brace-or-equal-initializer:
    = initializer-clause
    braced-init-list
initializer-clause:
    assignment-expression
    braced-init-list
initializer-list:
    initializer-clause ...opt
    initializer-list , initializer-clause ...opt
braced-init-list:
    { initializer-list ,opt }
    { }

Để đạt được hiệu quả tương tự, hãy sử dụng các hàm tạo hoặc danh sách khởi tạo:

Bạn chỉ có thể khởi tạo thông qua ctor:

struct address {
  address() : city("Hamilton"), prov("Ontario") {}
  int street_no;
  char *street_name;
  char *city;
  char *prov;
  char *postal_code;
};

Bạn thậm chí có thể đóng gói giải pháp của Gui13 vào câu lệnh khởi tạo đơn:

struct address {
                 int street_no;
                 char *street_name;
                 char *city;
                 char *prov;
                 char *postal_code;
               };


address ta = (ta = address(), ta.city = "Hamilton", ta.prov = "Ontario", ta);

Tuyên bố miễn trừ trách nhiệm: Tôi không đề xuất phong cách này

Tôi biết câu hỏi này khá cũ, nhưng tôi đã tìm thấy một cách khác để khởi tạo, sử dụng constexpr và currying:

struct mp_struct_t {
    public:
        constexpr mp_struct_t(int member1) : mp_struct_t(member1, 0, 0) {}
        constexpr mp_struct_t(int member1, int member2, int member3) : member1(member1), member2(member2), member3(member3) {}
        constexpr mp_struct_t another_member(int member) { return {member1, member,     member2}; }
        constexpr mp_struct_t yet_another_one(int member) { return {member1, member2, member}; }

    int member1, member2, member3;
};

static mp_struct_t a_struct = mp_struct_t{1}
                           .another_member(2)
                           .yet_another_one(3);

Phương pháp này cũng hoạt động cho các biến tĩnh toàn cầu và thậm chí cả các biến constexpr. Nhược điểm duy nhất là khả năng bảo trì kém: Mỗi khi thành viên khác phải được khởi tạo bằng phương pháp này, tất cả các phương thức khởi tạo thành viên phải được thay đổi.

Tôi có thể đang thiếu một cái gì đó ở đây, tại sao không:

#include <cstdio>    
struct Group {
    int x;
    int y;
    const char* s;
};

int main() 
{  
  Group group {
    .x = 1, 
    .y = 2, 
    .s = "Hello it works"
  };
  printf("%d, %d, %s", group.x, group.y, group.s);
}

Nó không được thực hiện trong C ++. (Ngoài ra, char*chuỗi? Tôi hy vọng không).

Thông thường nếu bạn có quá nhiều tham số thì đó là mùi mã khá nghiêm trọng. Nhưng thay vào đó, tại sao không chỉ đơn giản là khởi tạo giá trị cấu trúc và sau đó gán từng thành viên?

Tôi tìm thấy cách làm này cho các biến toàn cục, không yêu cầu sửa đổi định nghĩa cấu trúc ban đầu:

struct address {
             int street_no;
             char *street_name;
             char *city;
             char *prov;
             char *postal_code;
           };

sau đó khai báo biến của một kiểu mới được kế thừa từ kiểu cấu trúc ban đầu và sử dụng hàm tạo để khởi tạo các trường:

struct temp_address : address { temp_address() { 
    city = "Hamilton"; 
    prov = "Ontario"; 
} } temp_address;

Không hoàn toàn thanh lịch như phong cách C mặc dù ...

Đối với một biến cục bộ, nó yêu cầu một bộ nhớ bổ sung (this, 0, sizeof (* this)) ở đầu hàm tạo, vì vậy rõ ràng nó không tệ hơn và câu trả lời của @ gui13 là phù hợp hơn.

(Lưu ý rằng 'temp_address' là một biến loại 'temp_address', tuy nhiên loại mới này kế thừa từ 'địa chỉ' và có thể được sử dụng ở mọi nơi nơi 'địa chỉ' được mong đợi, vì vậy nó ổn.)

Tôi đã phải đối mặt với một vấn đề tương tự ngày hôm nay, nơi tôi có một cấu trúc mà tôi muốn điền vào dữ liệu thử nghiệm sẽ được chuyển qua làm đối số cho hàm tôi đang kiểm tra. Tôi muốn có một vectơ của các cấu trúc này và đang tìm kiếm một phương thức một lớp để khởi tạo mỗi cấu trúc.

Tôi đã kết thúc với một hàm tạo trong cấu trúc, mà tôi tin rằng nó cũng được đề xuất trong một vài câu trả lời cho câu hỏi của bạn.

Có lẽ thực tế xấu khi có các đối số cho hàm tạo có cùng tên với các biến thành viên công khai, yêu cầu sử dụng thiscon trỏ. Ai đó có thể đề nghị chỉnh sửa nếu có cách tốt hơn.

typedef struct testdatum_s {
    public:
    std::string argument1;
    std::string argument2;
    std::string argument3;
    std::string argument4;
    int count;

    testdatum_s (
        std::string argument1,
        std::string argument2,
        std::string argument3,
        std::string argument4,
        int count)
    {
        this->rotation = argument1;
        this->tstamp = argument2;
        this->auth = argument3;
        this->answer = argument4;
        this->count = count;
    }

} testdatum;

Mà tôi đã sử dụng trong hàm thử nghiệm của mình để gọi hàm đang được thử nghiệm với các đối số khác nhau như thế này:

std::vector<testdatum> testdata;

testdata.push_back(testdatum("val11", "val12", "val13", "val14", 5));
testdata.push_back(testdatum("val21", "val22", "val23", "val24", 1));
testdata.push_back(testdatum("val31", "val32", "val33", "val34", 7));

for (std::vector<testdatum>::iterator i = testdata.begin(); i != testdata.end(); ++i) {
    function_in_test(i->argument1, i->argument2, i->argument3, i->argument4m i->count);
}

Có thể, nhưng chỉ khi cấu trúc bạn đang khởi tạo là cấu trúc POD (dữ liệu cũ đơn giản). Nó không thể chứa bất kỳ phương thức, hàm tạo hoặc thậm chí các giá trị mặc định.

Trong C ++, các bộ khởi tạo kiểu C đã được thay thế bởi các hàm tạo mà theo thời gian biên dịch có thể đảm bảo rằng chỉ các khởi tạo hợp lệ được thực hiện (tức là sau khi khởi tạo các thành viên đối tượng là nhất quán).

Đó là một thực hành tốt, nhưng đôi khi một khởi tạo trước là tiện dụng, như trong ví dụ của bạn. OOP giải quyết điều này bằng các lớp trừu tượng hoặc các mẫu thiết kế sáng tạo .

Theo tôi, sử dụng cách bảo mật này sẽ giết chết sự đơn giản và đôi khi sự đánh đổi bảo mật có thể quá tốn kém, vì mã đơn giản không cần thiết kế tinh vi để duy trì.

Là một giải pháp thay thế, tôi đề nghị xác định các macro sử dụng lambdas để đơn giản hóa việc khởi tạo để trông gần giống như kiểu C:

struct address {
  int street_no;
  const char *street_name;
  const char *city;
  const char *prov;
  const char *postal_code;
};
#define ADDRESS_OPEN [] { address _={};
#define ADDRESS_CLOSE ; return _; }()
#define ADDRESS(x) ADDRESS_OPEN x ADDRESS_CLOSE

Macro ADDRESS mở rộng thành

[] { address _={}; /* definition... */ ; return _; }()

tạo ra và gọi lambda. Các tham số macro cũng được phân tách bằng dấu phẩy, vì vậy bạn cần đặt trình khởi tạo vào dấu ngoặc và gọi như

address temp_address = ADDRESS(( _.city = "Hamilton", _.prov = "Ontario" ));

Bạn cũng có thể viết trình khởi tạo macro tổng quát

#define INIT_OPEN(type) [] { type _={};
#define INIT_CLOSE ; return _; }()
#define INIT(type,x) INIT_OPEN(type) x INIT_CLOSE

nhưng sau đó cuộc gọi hơi kém đẹp

address temp_address = INIT(address,( _.city = "Hamilton", _.prov = "Ontario" ));

tuy nhiên, bạn có thể xác định macro ADDRESS bằng cách sử dụng macro INIT chung một cách dễ dàng

#define ADDRESS(x) INIT(address,x)

Trong GNUC ++ (dường như đã lỗi thời từ 2.5, một thời gian dài trước đây :) Xem câu trả lời ở đây: Khởi tạo cấu trúc C bằng cách sử dụng nhãn. Nó hoạt động, nhưng làm thế nào? ), có thể khởi tạo một cấu trúc như thế này:

struct inventory_item {
    int bananas;
    int apples;
    int pineapples;
};

inventory_item first_item = {
    bananas: 2,
    apples: 49,
    pineapples: 4
};

Lấy cảm hứng từ câu trả lời thực sự gọn gàng này: ( https://stackoverflow.com/a/49572324/4808079 )

Bạn có thể đóng lamba:

// Nobody wants to remember the order of these things
struct SomeBigStruct {
  int min = 1;
  int mean = 3 ;
  int mode = 5;
  int max = 10;
  string name;
  string nickname;
  ... // the list goes on
}

.

class SomeClass {
  static const inline SomeBigStruct voiceAmps = []{
    ModulationTarget $ {};
    $.min = 0;  
    $.nickname = "Bobby";
    $.bloodtype = "O-";
    return $;
  }();
}

Hoặc, nếu bạn muốn rất lạ mắt

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

class SomeClass {
  static const inline SomeBigStruct voiceAmps = DesignatedInit(
    ModulationTarget,
    $.min = 0,
    $.nickname = "Bobby",
    $.bloodtype = "O-",
  );
}

Có một số nhược điểm liên quan đến điều này, chủ yếu là phải làm với các thành viên chưa được khởi tạo. Từ những gì các câu trả lời được liên kết nhận xét, nó biên dịch hiệu quả, mặc dù tôi chưa kiểm tra nó.

Nhìn chung, tôi chỉ nghĩ rằng đó là một cách tiếp cận gọn gàng.