ie naive, optimistische und ach so falsche Sicht auf die c ++ 11 einheitliche Initialisierungssynt

Ich dachte, dass seit C ++ 11 benutzerdefinierte Typobjekte mit dem neuen @ erstellt werden sollt{...} Syntax anstelle des alten(...) Syntax (außer Konstruktor überladen fürstd::initializer_list und ähnliche Parameter (z. B.std::vector: Größe ctor vs 1 Element init_list ctor)).

Die Vorteile sind: keine impliziten Conversions, kein Problem mit der lästigsten Analyse, Konsistenz (?). Ich sah kein Problem, da ich dachte, dass sie gleich sind (außer dem angegebenen Beispiel).

Aber sie sind nicht.

ine Geschichte von purem Wahnsi

Das{} ruft den Standardkonstruktor auf.

... Ausser wenn

der Standardkonstruktor wird gelöscht unds sind keine weiteren Konstruktoren definier

Sieht es dann so aus, als würde der Wert eher das Objekt initialisieren? ... Auch wenn das Objekt den Standardkonstruktor gelöscht hat, wird das{} kann ein Objekt erstellen. Übertrifft dies nicht den gesamten Zweck eines gelöschten Konstruktors?

...Ausser wenn

das Objekt hat einen gelöschten Standardkonstruktor undandere (s) Konstruktor (en) definiert.

Dann scheitert es mitcall to deleted constructor.

...Ausser wenn

das Objekt hat einen gelöschten Konstruktor undkein anderer Konstruktor definiert undmindestens ein nicht statisches Datenelement.

Dann schlägt es mit fehlenden Feldinitialisierern fehl.

Aber dann können Sie @ verwend{value}, um das Objekt zu konstruieren.

Ok vielleicht ist dies die selbe wie die erste Ausnahme (Wert init das Objekt)

...Ausser wenn

die Klasse hat einen gelöschten Konstruktorund mindestens ein Datenmitglied in der Klasse ist standardmäßig initialisiert.

Then noch{} Noch{value} kann ein Objekt erstellen.

ch bin sicher, ich habe ein paar verpasst. Die Ironie ist, dass es heißtUnifor Initialisierungssyntax. Ich sage nochmal:UNIFOR Initialisierungssyntax.

as ist das für ein Wahnsin

Scenario A Gelöschter Standardkonstruktor:

struct foo {
  foo() = delete;
};

// All bellow OK (no errors, no warnings)
foo f = foo{};
foo f = {};
foo f{}; // will use only this from now on.

Scenario B Standardkonstruktor gelöscht, andere Konstruktoren gelöscht

struct foo {
  foo() = delete;
  foo(int) = delete;
};

foo f{}; // OK

Scenario C Gelöschter Standardkonstruktor, andere Konstruktoren definiert

struct foo {
  foo() = delete;
  foo(int) {};
};

foo f{}; // error call to deleted constructor

Scenario D Gelöschter Standardkonstruktor, keine anderen Konstruktoren definiert, Datenelement

struct foo {
  int a;
  foo() = delete;
};

foo f{}; // error use of deleted function foo::foo()
foo f{3}; // OK

Scenario E Gelöschter Standardkonstruktor, gelöschter T-Konstruktor, T-Datenelement

struct foo {
  int a;
  foo() = delete;
  foo(int) = delete;
};

foo f{}; // ERROR: missing initializer
foo f{3}; // OK

Scenario F Gelöschter Standardkonstruktor, Klasseninitialisierer von Datenelementen

struct foo {
  int a = 3;
  foo() = delete;
};

/* Fa */ foo f{}; // ERROR: use of deleted function `foo::foo()`
/* Fb */ foo f{3}; // ERROR: no matching function to call `foo::foo(init list)`