方便的C ++结构初始化

我正在尝试寻找一种方便的方法来初始化“ pod” 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 };  // :)

至少在某种程度上有所帮助。

您可以使用lambda：

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

有关该惯用语的更多信息，请参见Herb Sutter的博客。

将竞争对象提取到描述它们的函数中（基本重构）：

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

我知道该样式与您不希望使用的样式非常接近，但是它可以更轻松地替换常量值，并且可以对常量值进行解释（因此无需编辑注释）（如果更改了）。

您可以做的另一件事（因为您很懒惰）是使构造函数内联，因此您不必键入太多内容（删除“ 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 ++一样。如果要使用命名参数，则目标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 ++容器也很有用。我不明白你为什么称它为不良风格？

如果您想用名称来表示参数，则可以使用boost参数库，但这可能会使不熟悉它的人感到困惑。

对结构成员进行重新排序就像对函数参数进行重新排序一样，如果您不十分仔细地进行重构，则可能会导致问题。

那这种语法呢？

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

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

刚刚在Microsoft Visual C ++ 2015和g ++ 6.0.2上进行了测试。工作正常。
如果要避免重复变量名称，也可以创建特定的宏。

对我来说，允许内联inizialization的最懒的方法是使用此宏。

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

该宏创建属性和自引用方法。