Bequeme C ++ - Strukturinitialisierung

Ich versuche einen bequemen Weg zu finden, um 'pod' C ++ - Strukturen zu initialisieren. Betrachten Sie nun die folgende Struktur:

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

Wenn ich dies bequem in C (!) Initialisieren möchte, könnte ich einfach schreiben:

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

Beachten Sie, dass ich die folgende Notation explizit vermeiden möchte, da es mir so vorkommt, als würde ich mir den Hals brechen, wenn ich in Zukunft etwas an der Struktur ändere :

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

Um in C ++ dasselbe (oder zumindest ein ähnliches) wie im /* A */Beispiel zu erreichen, müsste ich einen idiotischen Konstruktor implementieren:

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

Was gut zum Kochen von Wasser ist, aber nicht für faule Leute geeignet (Faulheit ist eine gute Sache, oder?). Außerdem ist es so schlecht wie das /* B */Beispiel, da nicht explizit angegeben wird, welcher Wert an welches Mitglied geht.

Meine Frage ist also im Grunde, wie ich /* A */in C ++ etwas Ähnliches oder Besseres erreichen kann . Alternativ wäre ich mit einer Erklärung einverstanden, warum ich dies nicht tun möchte (dh warum mein mentales Paradigma schlecht ist).

BEARBEITEN

Mit bequem meine ich auch wartbar und nicht redundant .

Bestimmte Initialisierungen werden in c ++ 2a unterstützt, aber Sie müssen nicht warten, da sie offiziell von GCC, Clang und MSVC unterstützt werden.

#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

Schon seit style A ist in C ++ nicht erlaubt und du willst style Bdann nicht wie wäre es mit style BX:

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

Zumindest einigermaßen helfen.

Sie könnten ein Lambda verwenden:

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

Weitere Informationen zu dieser Redewendung finden Sie im Blog von Herb Sutter .

Extrahieren Sie die Contants in Funktionen, die sie beschreiben (grundlegendes Refactoring):

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

Ich weiß, dass der Stil dem sehr nahe kommt, den Sie nicht verwenden wollten, aber er ermöglicht das einfachere Ersetzen der konstanten Werte und erklärt sie auch (sodass keine Kommentare bearbeitet werden müssen), falls sie sich jemals ändern.

Eine andere Möglichkeit (da Sie faul sind) besteht darin, den Konstruktor inline zu machen, damit Sie nicht so viel eingeben müssen (Entfernen von "Foobar ::" und Zeitaufwand für das Umschalten zwischen h- und cpp-Datei):

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

Ihre Frage ist etwas schwierig, weil sogar die Funktion:

static FooBar MakeFooBar(int foo, float bar);

kann genannt werden als:

FooBar fb = MakeFooBar(3.4, 5);

aufgrund der Regeln für Werbung und Konvertierung für integrierte numerische Typen. (C wurde nie wirklich stark getippt)

In C ++ ist das, was Sie wollen, mit Hilfe von Vorlagen und statischen Zusicherungen erreichbar:

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

In C können Sie die Parameter benennen, aber Sie werden nie weiter kommen.

Wenn Sie jedoch nur benannte Parameter verwenden möchten, schreiben Sie viel umständlichen Code:

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

Und wenn Sie möchten, können Sie den Schutz der Typwerbung verbessern.

Die C ++ - Frontends vieler Compiler (einschließlich GCC und Clang) verstehen die C-Initialisierersyntax. Wenn Sie können, verwenden Sie einfach diese Methode.

Ein weiterer Weg in C ++ ist

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

Option D:

FooBar FooBarMake(int foo, float bar)

Legal C, legal C ++. Leicht für PODs optimierbar. Natürlich gibt es keine benannten Argumente, aber das ist wie bei allen C ++. Wenn Sie benannte Argumente möchten, sollte Ziel C die bessere Wahl sein.

Option E:

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

Legal C, legal C ++. Benannte Argumente.

Ich weiß, dass diese Frage alt ist, aber es gibt eine Möglichkeit, dies zu lösen, bis C ++ 20 diese Funktion endlich von C nach C ++ bringt. Um dies zu lösen, können Sie Präprozessor-Makros mit static_asserts verwenden, um zu überprüfen, ob Ihre Initialisierung gültig ist. (Ich weiß, dass Makros im Allgemeinen schlecht sind, aber hier sehe ich keinen anderen Weg.) Siehe Beispielcode unten:

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

Wenn Sie dann eine Struktur mit const-Attributen haben, können Sie dies tun:

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

Dies ist etwas unpraktisch, da Sie Makros für jede mögliche Anzahl von Attributen benötigen und den Typ und Namen Ihrer Instanz im Makroaufruf wiederholen müssen. Sie können das Makro auch nicht in einer return-Anweisung verwenden, da die Asserts nach der Initialisierung erfolgen.

Aber es löst Ihr Problem: Wenn Sie die Struktur ändern, schlägt der Aufruf beim Kompilieren fehl.

Wenn Sie C ++ 17 verwenden, können Sie diese Makros sogar strenger gestalten, indem Sie dieselben Typen erzwingen, z.

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

Der Weg /* B */ ist in C ++ in Ordnung, auch das C ++ 0x wird die Syntax erweitern, so dass es auch für C ++ - Container nützlich ist. Ich verstehe nicht, warum du es schlechten Stil nennst?

Wenn Sie Parameter mit Namen angeben möchten, können Sie die Boost-Parameterbibliothek verwenden , die jedoch jemanden verwirren kann, der damit nicht vertraut ist.

Das Neuordnen von Strukturelementen ähnelt dem Neuordnen von Funktionsparametern. Ein solches Refactoring kann Probleme verursachen, wenn Sie es nicht sehr sorgfältig ausführen.

Was ist mit dieser Syntax?

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

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

Gerade auf einem Microsoft Visual C ++ 2015 und auf g ++ 6.0.2 getestet. OK funktionieren.
Sie können ein bestimmtes Makro auch erstellen, wenn Sie das Duplizieren des Variablennamens vermeiden möchten.

Für mich ist die Verwendung dieses Makros der faulste Weg, eine Inline-Inizialisierung zuzulassen.

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

Dieses Makro erstellt ein Attribut und eine Selbstreferenzmethode.