comment attribuer plusieurs valeurs dans une structure à la fois?

Le premier est un agrégat d'initialiseur - vous pouvez lire et ceux marqués d'initialiseurs à cette solution:

Ce qui est étiqueté structure de la syntaxe d'initialisation?

C'est un spécial syntaxe d'initialisation, et vous ne pouvez pas faire quelque chose de similaire après l'initialisation de votre structure. Ce que vous pouvez faire est de fournir à un membre (ou un non-membre) fonction de prendre votre série de valeurs de paramètres qui vous affectez ensuite à l'intérieur de la fonction de membre - qui vous permettra d'accomplir ce après l'initialisation de la structure d'une manière qui est tout aussi concis (après que vous avez écrit la fonction de la première heure de cours!)

En C++11, vous pouvez effectuer l'affectation multiple avec "la cravate" (déclaré dans le tuple en-tête)

struct foo {
    int a, b, c;
} f;

std::tie(f.a, f.b, f.c) = std::make_tuple(1, 2, 3);

Si votre main droite expression est de taille fixe et vous avez seulement besoin d'obtenir certains éléments, vous pouvez utiliser l'ignorer espace réservé avec une cravate

std::tie(std::ignore, f.b, std::ignore) = some_tuple; //only f.b modified

Si vous trouvez la syntaxe std::cravate(f.a, f.b, f.c) code de l'encombrer, vous pourriez avoir un membre de la fonction de renvoi de ce n-uplet de références

struct foo {
    int a, b, c;
    auto members() -> decltype(std::tie(a, b, c)) {
        return std::tie(a, b, c);
    }
} f;

f.members() = std::make_tuple(1, 2, 3);

Tout cela bien sûr en supposant que la surcharge de l'opérateur d'affectation n'est pas une option parce que votre structure n'est pas constructible par une telle séquence de valeurs, auquel cas on pourrait dire

f = foo(1, 2, 3);

Empreinte mémoire - Voici un intéressant i386 plus.

Après beaucoup de tracas, à l'aide de optimisation et memcpy semble générer une plus petite empreinte de l'aide i386 avec GCC et C99. Je suis aide -O3 ici. stdlib semble avoir toutes sortes de plaisir les optimisations du compilateur à la main, et cet exemple fait usage de cette (memcpy est effectivement compilé ici).

Ce faire:

Foo foo; //some global variable

void setStructVal (void)   {

    const Foo FOO_ASSIGN_VAL = {    //this goes into .rodata
            .bunch       = 1,
            .of          = 2,
            .things      = 3,
            .initialized = 4
    };

    memcpy((void*) &FOO_ASSIGN_VAL, (void*) foo, sizeof(Foo));

    return;
}

Résultat:

• (.rodata) FOO_ASSIGN_VAL est stocké dans .rodata
• (.texte) une séquence d' *movl FOO_ASSIGN_VAL, %des registres* se
• (.texte) une séquence de movl %registres, foo se produire

Exemple:

• Dire Foo était de 48 champ de structure de u_int8_t valeurs. Il est aligné dans la mémoire.

• (IDÉAL) Sur une machine 32 bits, ce POURRAIT être aussi rapide que 12 MOVL instructions immédiates pour foo adresse de l'espace. Pour moi, c'est 12*10 == 120bytes de .texte de taille.

• (RÉELLE) Cependant, l'utilisation de la réponse par l'AUTO sera susceptible de générer 48 MOVB instructions .texte. Pour moi, c'est de 48*7 == 336bytes de .le texte!!

• (Plus PETIT*) Utiliser le memcpy version ci-dessus. SI l'alignement est pris en charge,

  • FOO_ASSIGN_VAL est placé .rodata (48 octets),
  • 12 MOVL en %inscrire
  • 12 MOVL venant de l' %des registres sont utilisés dans .texte (24*10) == 240bytes.
  • C'est donc pour moi un total de 288 octets.

Donc, pour moi, au moins avec mon i386 code,

- Ideal:    120 bytes
- Direct:   336 bytes
- Smallest: 288 bytes

*Du plus petit signifie ici " plus petite empreinte que je sais du. Il exécute aussi plus rapide que les méthodes ci-dessus (24 instructions vs 48). Bien sûr, l'IDÉAL version est plus rapide & plus petit, mais je n'arrive toujours pas à comprendre cela.

-Justin

*Est-ce que quelqu'un sait comment obtenir la mise en œuvre de la "IDÉAL " ci-dessus? Il est gênant, l'enfer hors de moi!!