Khởi tạo cấu trúc C ++ thuận tiện

Tôi đang cố gắng tìm một cách thuận tiện để khởi tạo các cấu trúc C 'pod'. Bây giờ, hãy xem xét các cấu trúc sau:

struct FooBar {
  int foo;
  float bar;
};
// just to make all examples work in C and C++:
typedef struct FooBar FooBar;

Nếu tôi muốn khởi tạo thuận tiện điều này trong C (!), Tôi có thể chỉ cần viết:

/* A */ FooBar fb = { .foo = 12, .bar = 3.4 }; // illegal C++, legal C

Lưu ý rằng tôi muốn tránh một cách rõ ràng các ký hiệu sau, bởi vì nó tấn công tôi như bị làm gãy cổ nếu tôi thay đổi bất cứ điều gì trong cấu trúc trong tương lai:

/* B */ FooBar fb = { 12, 3.4 }; // legal C++, legal C, bad style?

Để đạt được điều tương tự (hoặc ít nhất là tương tự) trong C ++ như trong /* A */ví dụ, tôi sẽ phải thực hiện một hàm tạo ngu ngốc:

FooBar::FooBar(int foo, float bar) : foo(foo), bar(bar) {}
// ->
/* C */ FooBar fb(12, 3.4);

Cái nào tốt cho nước sôi, nhưng không thích hợp cho người lười biếng (lười biếng là một điều tốt, phải không?). Ngoài ra, nó cũng khá tệ như /* B */ví dụ, vì nó không nói rõ giá trị nào thuộc về thành viên nào.

Vì vậy, câu hỏi của tôi về cơ bản là làm thế nào tôi có thể đạt được một cái gì đó tương tự như /* A */ hoặc tốt hơn trong C ++? Ngoài ra, tôi sẽ ổn với một lời giải thích tại sao tôi không muốn làm điều này (tức là tại sao mô hình tinh thần của tôi là xấu).

BIÊN TẬP

Bởi thuận tiện , tôi có nghĩa là cũng có thể duy trì và không dư thừa .

Các khởi tạo được chỉ định sẽ được hỗ trợ trong c ++ 2a, nhưng bạn không phải chờ đợi, vì chúng được hỗ trợ bởi GCC, Clang và MSVC.

#include <iostream>
#include <filesystem>

struct hello_world {
    const char* hello;
    const char* world;
};

int main () 
{
    hello_world hw = {
        .hello = "hello, ",
        .world = "world!"
    };

    std::cout << hw.hello << hw.world << std::endl;
    return 0;
}

GCC Demo MSVC Demo

Vì style AC ++ không được phép và bạn không muốn style Bsử dụng style BX:

FooBar fb = { /*.foo=*/ 12, /*.bar=*/ 3.4 };  // :)

Ít nhất là giúp đỡ ở một mức độ nào đó.

Bạn có thể sử dụng lambda:

const FooBar fb = [&] {
    FooBar fb;
    fb.foo = 12;
    fb.bar = 3.4;
    return fb;
}();

Thông tin thêm về thành ngữ này có thể được tìm thấy trên blog của Herb Sutter .

Trích xuất các phần tử vào các hàm mô tả chúng (tái cấu trúc cơ bản):

FooBar fb = { foo(), bar() };

Tôi biết rằng kiểu đó rất gần với kiểu bạn không muốn sử dụng, nhưng nó cho phép thay thế dễ dàng hơn các giá trị không đổi và cũng giải thích chúng (do đó không cần chỉnh sửa nhận xét), nếu chúng thay đổi.

Một điều khác bạn có thể làm (vì bạn lười biếng) là đặt hàm tạo nội tuyến, vì vậy bạn không phải nhập nhiều (xóa "Foobar ::" và thời gian chuyển đổi giữa tệp h và cpp):

struct FooBar {
  FooBar(int f, float b) : foo(f), bar(b) {}
  int foo;
  float bar;
};

Câu hỏi của bạn hơi khó vì ngay cả chức năng:

static FooBar MakeFooBar(int foo, float bar);

có thể được gọi là:

FooBar fb = MakeFooBar(3.4, 5);

bởi vì các quy tắc quảng cáo và chuyển đổi cho các loại số tích hợp. (C chưa bao giờ được gõ mạnh)

Trong C ++, những gì bạn muốn là có thể đạt được, mặc dù với sự trợ giúp của các mẫu và xác nhận tĩnh:

template <typename Integer, typename Real>
FooBar MakeFooBar(Integer foo, Real bar) {
  static_assert(std::is_same<Integer, int>::value, "foo should be of type int");
  static_assert(std::is_same<Real, float>::value, "bar should be of type float");
  return { foo, bar };
}

Trong C, bạn có thể đặt tên cho các tham số, nhưng bạn sẽ không bao giờ nhận được thêm.

Mặt khác, nếu tất cả những gì bạn muốn được đặt tên là tham số, thì bạn viết rất nhiều mã rườm rà:

struct FooBarMaker {
  FooBarMaker(int f): _f(f) {}
  FooBar Bar(float b) const { return FooBar(_f, b); }
  int _f;
};

static FooBarMaker Foo(int f) { return FooBarMaker(f); }

// Usage
FooBar fb = Foo(5).Bar(3.4);

Và bạn có thể tiêu trong loại bảo vệ khuyến mãi nếu bạn muốn.

Nhiều giao diện C ++ của trình biên dịch (bao gồm GCC và clang) hiểu cú pháp khởi tạo C. Nếu bạn có thể, chỉ cần sử dụng phương pháp đó.

Một cách khác trong C ++ là

struct Point
{
private:

 int x;
 int y;

public:
    Point& setX(int xIn) { x = Xin; return *this;}
    Point& setY(int yIn) { y = Yin; return *this;}

}

Point pt;
pt.setX(20).setY(20);

Tùy chọn D:

FooBar FooBarMake(int foo, float bar)

Pháp lý C, pháp lý C ++. Dễ dàng tối ưu hóa cho PODs. Tất nhiên không có đối số được đặt tên, nhưng điều này giống như tất cả C ++. Nếu bạn muốn các đối số được đặt tên, Objective C nên là lựa chọn tốt hơn.

Tùy chọn E:

FooBar fb;
memset(&fb, 0, sizeof(FooBar));
fb.foo = 4;
fb.bar = 15.5f;

Pháp lý C, pháp lý C ++. Lập luận được đặt tên.

Tôi biết câu hỏi này đã cũ, nhưng có một cách để giải quyết vấn đề này cho đến khi C ++ 20 cuối cùng đưa tính năng này từ C sang C ++. Những gì bạn có thể làm để giải quyết vấn đề này là sử dụng các macro tiền xử lý với static_asserts để kiểm tra việc khởi tạo của bạn có hợp lệ không. (Tôi biết macro nói chung là xấu, nhưng ở đây tôi không thấy một cách khác.) Xem mã ví dụ bên dưới:

#define INVALID_STRUCT_ERROR "Instantiation of struct failed: Type, order or number of attributes is wrong."

#define CREATE_STRUCT_1(type, identifier, m_1, p_1) \
{ p_1 };\
static_assert(offsetof(type, m_1) == 0, INVALID_STRUCT_ERROR);\

#define CREATE_STRUCT_2(type, identifier, m_1, p_1, m_2, p_2) \
{ p_1, p_2 };\
static_assert(offsetof(type, m_1) == 0, INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_2) >= sizeof(identifier.m_1), INVALID_STRUCT_ERROR);\

#define CREATE_STRUCT_3(type, identifier, m_1, p_1, m_2, p_2, m_3, p_3) \
{ p_1, p_2, p_3 };\
static_assert(offsetof(type, m_1) == 0, INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_2) >= sizeof(identifier.m_1), INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_3) >= (offsetof(type, m_2) + sizeof(identifier.m_2)), INVALID_STRUCT_ERROR);\

#define CREATE_STRUCT_4(type, identifier, m_1, p_1, m_2, p_2, m_3, p_3, m_4, p_4) \
{ p_1, p_2, p_3, p_4 };\
static_assert(offsetof(type, m_1) == 0, INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_2) >= sizeof(identifier.m_1), INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_3) >= (offsetof(type, m_2) + sizeof(identifier.m_2)), INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_4) >= (offsetof(type, m_3) + sizeof(identifier.m_3)), INVALID_STRUCT_ERROR);\

// Create more macros for structs with more attributes...

Sau đó, khi bạn có một cấu trúc với các thuộc tính const, bạn có thể làm điều này:

struct MyStruct
{
    const int attr1;
    const float attr2;
    const double attr3;
};

const MyStruct test = CREATE_STRUCT_3(MyStruct, test, attr1, 1, attr2, 2.f, attr3, 3.);

Điều này hơi bất tiện, vì bạn cần macro cho mọi số lượng thuộc tính có thể và bạn cần lặp lại loại và tên của thể hiện của bạn trong lệnh gọi macro. Ngoài ra, bạn không thể sử dụng macro trong câu lệnh return, bởi vì các xác nhận xuất hiện sau khi khởi tạo.

Nhưng nó giải quyết vấn đề của bạn: Khi bạn thay đổi cấu trúc, cuộc gọi sẽ thất bại tại thời gian biên dịch.

Nếu bạn sử dụng C ++ 17, bạn thậm chí có thể làm cho các macro này nghiêm ngặt hơn bằng cách buộc các loại tương tự, ví dụ:

#define CREATE_STRUCT_3(type, identifier, m_1, p_1, m_2, p_2, m_3, p_3) \
{ p_1, p_2, p_3 };\
static_assert(offsetof(type, m_1) == 0, INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_2) >= sizeof(identifier.m_1), INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_3) >= (offsetof(type, m_2) + sizeof(identifier.m_2)), INVALID_STRUCT_ERROR);\
static_assert(typeid(p_1) == typeid(identifier.m_1), INVALID_STRUCT_ERROR);\
static_assert(typeid(p_2) == typeid(identifier.m_2), INVALID_STRUCT_ERROR);\
static_assert(typeid(p_3) == typeid(identifier.m_3), INVALID_STRUCT_ERROR);\

Cách /* B */ tốt là trong C ++, C ++ 0x sẽ mở rộng cú pháp nên nó cũng hữu ích cho các thùng chứa C ++. Tôi không hiểu tại sao bạn gọi nó là phong cách xấu?

Nếu bạn muốn chỉ ra các tham số có tên thì bạn có thể sử dụng thư viện tham số boost , nhưng nó có thể gây nhầm lẫn cho ai đó không quen thuộc với nó.

Sắp xếp lại các thành viên cấu trúc giống như sắp xếp lại các tham số hàm, việc tái cấu trúc như vậy có thể gây ra vấn đề nếu bạn không thực hiện cẩn thận.

Cú pháp này thì sao?

typedef struct
{
    int a;
    short b;
}
ABCD;

ABCD abc = { abc.a = 5, abc.b = 7 };

Chỉ cần thử nghiệm trên Microsoft Visual C ++ 2015 và trên g ++ 6.0.2. Làm việc tốt.
Bạn cũng có thể tạo một macro cụ thể nếu bạn muốn tránh trùng lặp tên biến.

Đối với tôi cách lười nhất để cho phép inizialization nội tuyến là sử dụng macro này.

#define METHOD_MEMBER(TYPE, NAME, CLASS) \
CLASS &set_ ## NAME(const TYPE &_val) { NAME = _val; return *this; } \
TYPE NAME;

struct foo {
    METHOD_MEMBER(string, attr1, foo)
    METHOD_MEMBER(int, attr2, foo)
    METHOD_MEMBER(double, attr3, foo)
};

// inline usage
foo test = foo().set_attr1("hi").set_attr2(22).set_attr3(3.14);

Đó là thuộc tính tạo macro và phương pháp tự tham chiếu.