Kullanışlı C ++ yapı başlatma

'Pod' C ++ yapıları başlatmak için uygun bir yol bulmaya çalışıyorum. Şimdi, aşağıdaki yapıyı düşünün:

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

Bunu rahatça C (!) İle başlatmak istiyorsanız, sadece şunu yazabilirim:

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

Aşağıdaki gösterimlerden açıkça kaçınmak istediğimi unutmayın, çünkü gelecekte yapıdaki herhangi bir şeyi değiştirirsem boynumu kırmam için bana çarpıyor:

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

/* A */Örnekte olduğu gibi C ++ ile aynı (veya en azından benzer) ulaşmak için , bir aptal yapıcı uygulamak gerekir:

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

Hangi kaynar su için iyidir, ancak tembel insanlar için uygun değildir (tembellik iyi bir şey, değil mi?). Ayrıca, /* B */hangi değerin hangi üyeye gittiğini açıkça belirtmediği için , örnek kadar kötüdür .

Yani, sorum temelde benzer bir şeyi nasıl başarabileceğim /* A */ C ++ veya daha iyi bir ? Alternatif olarak, bunu neden yapmak istememem gerektiğine dair bir açıklama ile iyi olurum (yani zihinsel paradigmamın neden kötü olduğu).

DÜZENLE

By kullanışlı , ben de demek sürdürülebilir ve yedek olmayan .

Belirtilen başlatmalar c ++ 2a'da desteklenecektir, ancak beklemek zorunda değilsiniz, çünkü bunlar GCC, Clang ve MSVC tarafından resmen desteklenmektedir .

#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

Yana style AC izin verilmez ++ ve istemediğiniz style Bnasıl kullanma hakkında daha sonra style BX:

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

En azından bir dereceye kadar yardım et.

Bir lambda kullanabilirsiniz:

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

Bu deyim hakkında daha fazla bilgi Herb Sutter'in blogunda bulunabilir .

Sabitleri, onları tanımlayan fonksiyonlara çıkarın (temel yeniden düzenleme):

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

Stilin kullanmak istemediğinize çok yakın olduğunu biliyorum, ancak sabit değerlerin daha kolay değiştirilmesini sağlar ve aynı zamanda bunları açıklar (böylece yorumları düzenlemeye gerek yoktur).

Yapabileceğiniz başka bir şey (tembel olduğunuz için) yapıcıyı satır içi yapmaktır, bu yüzden çok fazla yazmak zorunda kalmazsınız ("Foobar ::" ve h ve cpp dosyası arasında geçiş yapmak için harcanan zaman):

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

Sorunuz biraz zor çünkü işlev bile:

static FooBar MakeFooBar(int foo, float bar);

şu şekilde adlandırılabilir:

FooBar fb = MakeFooBar(3.4, 5);

yerleşik sayısal türler için tanıtım ve dönüşüm kuralları nedeniyle. (C hiçbir zaman gerçekten güçlü bir şekilde yazılmamıştır)

C ++ 'da, şablonlar ve statik iddialar yardımıyla istediğiniz şey elde edilebilir:

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

C'de parametreleri adlandırabilirsiniz, ancak daha fazla ilerleyemezsiniz.

Öte yandan, tüm istediğiniz parametreler olarak adlandırılırsa, çok hantal bir kod yazarsınız:

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

İsterseniz tip tanıtım korumasında biber yapabilirsiniz.

Birçok derleyicinin C ++ ön uçları (GCC ve clang dahil) C başlatıcı sözdizimini anlar. Yapabiliyorsanız, bu yöntemi kullanın.

C ++ 'da başka bir yol

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

Seçenek D:

FooBar FooBarMake(int foo, float bar)

Yasal C, yasal C ++. POD'lar için kolayca optimize edilebilir. Elbette adlandırılmış bir argüman yok, ama bu tüm C ++ gibi. Adlandırılmış bağımsız değişkenler istiyorsanız, Amaç C daha iyi bir seçim olmalıdır.

E Seçeneği:

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

Yasal C, yasal C ++. Adlandırılmış argümanlar.

Bu sorunun eski olduğunu biliyorum, ancak C ++ 20 sonunda bu özelliği C ++ C ++ 'a getirene kadar bunu çözmenin bir yolu var. Bunu çözmek için yapabileceğiniz şey, başlatmanızın geçerli olup olmadığını kontrol etmek için static_asserts ile önişlemci makroları kullanmaktır. (Makroların genellikle kötü olduğunu biliyorum, ama burada başka bir yol göremiyorum.) Aşağıdaki örnek koda bakın:

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

Sonra const özniteliklerine sahip bir yapınız varsa, bunu yapabilirsiniz:

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

Biraz sakıncalıdır, çünkü olası her sayıdaki özellik için makrolara ve makro çağrısında örneğinizin türünü ve adını tekrarlamanız gerekir. Ayrıca makrolar bir return deyiminde kullanılamaz, çünkü varsayımlar başlatma işleminden sonra gelir.

Ancak sorununuzu çözer: Yapıyı değiştirdiğinizde çağrı derleme zamanında başarısız olur.

C ++ 17 kullanıyorsanız, aynı türleri zorlayarak bu makroları daha katı hale getirebilirsiniz, örneğin:

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

/* B */C ++ 'da yol gayet iyi C ++ 0x sözdizimini genişletecek ve C ++ kapsayıcıları için de faydalı olacak. Neden kötü stil dediğini anlamıyorum?

Parametreleri adlarla belirtmek istiyorsanız boost parametre kitaplığını kullanabilirsiniz , ancak tanıdık olmayan birisini karıştırabilir.

Yapı üyelerini yeniden sıralamak işlev parametrelerini yeniden sıralamaya benzer, bu tür yeniden düzenleme çok dikkatli yapmazsanız sorunlara neden olabilir.

Bu sözdizimine ne oldu?

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

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

Sadece bir Microsoft Visual C ++ 2015 ve g ++ 6.0.2 üzerinde test edildi. Tamam çalışıyor.
Değişken adının kopyalanmasını önlemek istiyorsanız, belirli bir makro da yapabilirsiniz.

Benim için satır içi inizializasyona izin vermenin en tembel yolu bu makroyu kullanmaktır.

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

Bu makro öznitelik ve kendi kendine başvuru yöntemi oluşturur.