Quelle est cette folle syntaxe C ++ 11 ==> struct: bar {} foo {} ;?

Qu'est-ce que cela pourrait signifier en C ++ 11?

struct : bar {} foo {};

Tout d'abord, nous allons prendre un UDT abstrait standard (type défini par l'utilisateur):

struct foo { virtual void f() = 0; }; // normal abstract type
foo obj;
// error: cannot declare variable 'obj' to be of abstract type 'foo'

Rappelons également que nous pouvons instancier l'UDT en même temps que nous le définissons:

struct foo { foo() { cout << "!"; } };          // just a definition

struct foo { foo() { cout << "!"; } } instance; // so much more
// Output: "!"

Combinons les exemples, et rappelons que nous pouvons définir un UDT qui n'a pas de nom :

struct { virtual void f() = 0; } instance; // unnamed abstract type
// error: cannot declare variable 'instance' to be of abstract type '<anonymous struct>'

Nous n'avons plus besoin de la preuve de l'UDT anonyme, nous pouvons donc perdre la fonction virtuelle pure. Renommer également instanceen foo, il nous reste:

struct {} foo;

Se rapprocher.

Maintenant, que se passerait-il si cet UDT anonyme provenait d'une base?

struct bar {};       // base UDT
struct : bar {} foo; // anonymous derived UDT, and instance thereof

Enfin, C ++ 11 introduit des initialiseurs étendus , de sorte que nous pouvons faire des choses déroutantes comme ceci:

int x{0};

Et ça:

int x{};

Et, enfin, ceci:

struct : bar {} foo {};

Il s'agit d'une structure non nommée dérivant de bar, instanciée en tant que foo avec un initialiseur vide.

Cela définit:

• une structure anonyme,
• qui est dérivé publiquement de bar
• qui ( anonymously) ne définit rien d'autre que de quoi il dérivebar
• et enfin, une instance, appelée "foo" est créée,
• avec une liste d'initialiseurs vide

struct : bar {} foo {};