便利なC ++構造体の初期化

「ポッド」C ++構造体を初期化する便利な方法を見つけようとしています。ここで、次の構造体について考えてみましょう。

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

これをC（！）で簡単に初期化したい場合は、次のように書くだけです。

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

次の表記法は明示的に避けたいことに注意してください。これは、将来構造体で何かを変更すると首を骨折するように作られているように思われるためです。

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

C ++で/* A */例と同じ（または少なくとも同様）を実現するには、ばかばかしいコンストラクターを実装する必要があります。

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

どちらがお湯を沸かすのに適していますが、怠惰な人々には適していません（怠惰は良いことですよね？）。また、/* B */どの値がどのメンバーに渡されるかを明示的に示していないため、例と同じくらい悪いです。

だから、私の質問は基本的に私が/* A */C ++ と同じかそれ以上のことをどのように達成できるかです？あるいは、なぜこれをしたくないのか（つまり、私の精神的パラダイムが悪いのか）の説明で大丈夫でしょう。

編集

することで便利な、私はまた意味保守性と非冗長。

指定された初期化はc ++ 2aでサポートされますが、GCC、Clang、および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

以来style ACで許可されていません++、あなたはしたくないstyle B、その後どのように使用についてstyle BX：

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

少なくともある程度は助けてください。

あなたはラムダを使うことができます：

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

このイディオムの詳細については、Herb Sutterのブログをご覧ください。

それらを記述する関数に定数を抽出します（基本的なリファクタリング）：

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

スタイルが使いたくないスタイルに非常に近いことは知っていますが、定数値を簡単に置き換えることができ、変更された場合はそれらを説明することができます（コメントを編集する必要がないため）。

（怠惰なため）できるもう1つのことは、コンストラクターをインラインにすることです。そのため、それほど多く入力する必要はありません（ "Foobar ::"を削除し、hファイルとcppファイルの切り替えに費やした時間）。

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

あなたの質問は、関数でさえ次の理由でやや難しいです：

static FooBar MakeFooBar(int foo, float bar);

次のように呼び出すことができます：

FooBar fb = MakeFooBar(3.4, 5);

組み込みの数値型の昇格および変換ルールがあるためです。（Cは本当に強く型付けされたことがありません）

C ++では、テンプレートと静的アサーションを使用して、必要なことを実現できます。

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では、パラメーターに名前を付けることができますが、それ以上は得られません。

一方、名前付きパラメータだけが必要な場合は、面倒なコードをたくさん記述します。

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

また、必要に応じて、タイププロモーション保護を適用できます。

多くのコンパイラのC ++フロントエンド（GCCおよびclangを含む）は、C初期化子の構文を理解しています。可能であれば、その方法を使用してください。

C ++のさらに別の方法は

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

オプションD：

FooBar FooBarMake(int foo, float bar)

リーガルC、リーガルC ++。POD向けに簡単に最適化できます。もちろん、名前付き引数はありませんが、これはすべてのC ++と同じです。名前付き引数が必要な場合は、Objective Cをお勧めします。

オプションE：

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

リーガルC、リーガルC ++。名前付き引数。

私はこの質問が古いことを知っていますが、C ++ 20が最終的にこの機能をCからC ++にもたらすまで、これを解決する方法があります。これを解決するには、static_assertsを指定したプリプロセッサマクロを使用して、初期化が有効かどうかを確認します。（私はマクロが一般的に悪いことを知っていますが、ここでは別の方法は見ていません。）以下のサンプルコードを参照してください：

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

次に、const属性を持つ構造体がある場合、これを行うことができます。

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

考えられるすべての属性に対してマクロが必要であり、マクロの呼び出しでインスタンスのタイプと名前を繰り返す必要があるため、これは少し不便です。また、アサートは初期化の後に来るため、returnステートメントでマクロを使用することはできません。

しかし、問題は解決します。構造体を変更すると、呼び出しはコンパイル時に失敗します。

C ++ 17を使用している場合は、同じ型を強制することで、これらのマクロをより厳密にすることもできます。例：

#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 ++では方法は問題ありませんが、C ++ 0xは構文を拡張するため、C ++コンテナにも役立ちます。なぜあなたはそれを悪いスタイルと呼ぶのか分かりませんか？

名前でパラメーターを示したい場合は、ブーストパラメーターライブラリを使用できますが、慣れていないユーザーを混乱させる可能性があります。

構造体メンバーの並べ替えは、関数パラメーターの並べ替えに似ています。このようなリファクタリングは、慎重に行わないと問題が発生する可能性があります。

この構文はどうですか？

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

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

Microsoft Visual C ++ 2015とg ++ 6.0.2でテストされました。正常に動作しています。
変数名の重複を避けたい場合にも、特定のマクロを作成できます。

私にとって、インライン初期化を許可する最も怠惰な方法は、このマクロを使用することです。

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

そのマクロは属性と自己参照メソッドを作成します。