Inisialisasi struct C ++ yang nyaman

Saya mencoba menemukan cara yang nyaman untuk menginisialisasi 'pod' struct C ++. Sekarang, pertimbangkan struct berikut:

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

Jika saya ingin menginisialisasi ini dengan mudah di C (!), Saya cukup menulis:

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

Perhatikan bahwa saya ingin secara eksplisit menghindari notasi berikut, karena menurut saya dibuat untuk mematahkan leher saya jika saya mengubah sesuatu di struct di masa depan:

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

Untuk mencapai yang sama (atau paling tidak serupa) di C ++ seperti pada /* A */contoh, saya harus mengimplementasikan konstruktor idiot:

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

Mana yang baik untuk air mendidih, tetapi tidak cocok untuk orang malas (kemalasan adalah hal yang baik, bukan?). Juga, ini sama buruknya dengan /* B */contoh, karena tidak secara eksplisit menyatakan nilai yang masuk ke anggota mana.

Jadi, pertanyaan saya pada dasarnya adalah bagaimana saya bisa mencapai sesuatu yang mirip /* A */atau lebih baik di C ++? Atau, saya akan baik-baik saja dengan penjelasan mengapa saya tidak ingin melakukan ini (yaitu mengapa paradigma mental saya buruk).

EDIT

Dengan nyaman , maksud saya juga dapat dipertahankan dan tidak berlebihan .

Inisialisasi yang ditunjuk akan didukung dalam c ++ 2a, tetapi Anda tidak harus menunggu, karena mereka secara resmi didukung oleh GCC, Dentang dan 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

Karena style Atidak diizinkan dalam C ++ dan Anda tidak ingin style Blalu bagaimana menggunakan style BX:

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

Setidaknya membantu sedikit banyak.

Anda bisa menggunakan lambda:

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

Informasi lebih lanjut tentang idiom ini dapat ditemukan di blog Herb Sutter .

Ekstrak kontants menjadi fungsi yang menggambarkannya (refactoring dasar):

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

Saya tahu bahwa gaya sangat dekat dengan gaya yang tidak ingin Anda gunakan, tetapi memungkinkan penggantian nilai konstan yang lebih mudah dan juga menjelaskannya (sehingga tidak perlu mengedit komentar), jika mereka pernah mengubahnya.

Hal lain yang dapat Anda lakukan (karena Anda malas) adalah membuat konstruktor sebaris, sehingga Anda tidak perlu mengetik sebanyak (menghapus "Foobar ::" dan menghabiskan waktu beralih antara file h dan cpp):

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

Pertanyaan Anda agak sulit karena bahkan fungsinya:

static FooBar MakeFooBar(int foo, float bar);

dapat disebut sebagai:

FooBar fb = MakeFooBar(3.4, 5);

karena aturan promosi dan konversi untuk tipe numerik bawaan. (C tidak pernah diketik dengan sangat kuat)

Di C ++, apa yang Anda inginkan dapat dicapai, meskipun dengan bantuan template dan pernyataan statis:

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 };
}

Di C, Anda dapat memberi nama parameter, tetapi Anda tidak akan pernah lanjut.

Di sisi lain, jika semua yang Anda inginkan bernama parameter, maka Anda menulis banyak kode rumit:

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);

Dan Anda dapat menambahkan perlindungan promosi tipe jika Anda suka.

Banyak frontend C ++ kompiler (termasuk GCC dan dentang) memahami sintaks initializer C. Jika Anda bisa, cukup gunakan metode itu.

Namun cara lain dalam C ++ adalah

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);

Opsi D:

FooBar FooBarMake(int foo, float bar)

Legal C, legal C ++. Mudah dioptimalkan untuk POD. Tentu saja tidak ada argumen bernama, tetapi ini seperti semua C ++. Jika Anda ingin argumen bernama, Objective C harus menjadi pilihan yang lebih baik.

Opsi E:

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

Legal C, legal C ++. Argumen yang dinamai.

Saya tahu pertanyaan ini sudah lama, tetapi ada cara untuk menyelesaikan ini sampai C ++ 20 akhirnya membawa fitur ini dari C ke C ++. Apa yang dapat Anda lakukan untuk menyelesaikan ini adalah menggunakan macro preprocessor dengan static_asserts untuk memeriksa inisialisasi Anda valid. (Saya tahu makro umumnya buruk, tetapi di sini saya tidak melihat cara lain.) Lihat contoh kode di bawah ini:

#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...

Kemudian ketika Anda memiliki struct dengan atribut const, Anda bisa melakukan ini:

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.);

Agak merepotkan, karena Anda memerlukan makro untuk setiap kemungkinan jumlah atribut dan Anda perlu mengulangi jenis dan nama instance Anda dalam panggilan makro. Anda juga tidak dapat menggunakan makro dalam pernyataan pengembalian, karena pernyataan muncul setelah inisialisasi.

Tetapi itu memecahkan masalah Anda: Ketika Anda mengubah struct, panggilan akan gagal pada waktu kompilasi.

Jika Anda menggunakan C ++ 17, Anda bahkan dapat membuat makro ini lebih ketat dengan memaksa jenis yang sama, misalnya:

#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);\

Jalan /* B */ ini baik-baik saja di C ++ juga C ++ 0x akan memperpanjang sintaks sehingga berguna untuk wadah C ++ juga. Saya tidak mengerti mengapa Anda menyebutnya gaya buruk?

Jika Anda ingin menunjukkan parameter dengan nama maka Anda dapat menggunakan pustaka parameter boost , tetapi itu mungkin membingungkan seseorang yang tidak terbiasa dengannya.

Menyusun ulang anggota struct seperti mengatur ulang parameter fungsi, refactoring seperti itu dapat menyebabkan masalah jika Anda tidak melakukannya dengan sangat hati-hati.

Bagaimana dengan sintaks ini?

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

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

Baru saja diuji pada Microsoft Visual C ++ 2015 dan pada g ++ 6.0.2. Bekerja dengan baik.
Anda dapat membuat makro spesifik juga jika Anda ingin menghindari duplikasi nama variabel.

Bagi saya cara paling malas untuk memungkinkan inzialisasi inline adalah menggunakan makro ini.

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

Makro itu menciptakan atribut dan metode referensi diri.