Attribution d'un bit de valeur par bit

Question

Si j'ai un struct comme ceci:

struct example 
{ 
    uint16_t bar:1; 
    uint16_t foo:1; 
}; 

, j'ai une autre variable 16 bits: uint16_t value;

Si je veux que le premier bit « valeur » pour être assigné à "example.bar", et le second bit en valeur à affecter à "example.foo", comment ferais-je cela?

EDIT:

J'ai essayé les éléments suivants:

typedef struct 
{ 
    unsigned short  in_1_16; 
    unsigned short  in_17_32; 
    unsigned short  in_33_48; 
} READSTR; 

typedef struct 
{ 
    unsigned short  chan_1_16; 
    unsigned short  chan_17_32; 
    unsigned short  chan_33_48; 
} TLM; 

void main() 
{ 
    TLM tlm; 
    tlm.chan_1_16 = 0xFFFF; 
    READSTR t675; 

    t675.in_1_16 = 0x10; 
    t675.in_17_32 = 0x9; 
    t675.in_33_48 = 0x8; 

tlm.chan_1_16 |= t675.in_1_16 & 1; 
tlm.chan_1_16 |= t675.in_1_16 & (1 << 1); 
tlm.chan_1_16 |= t675.in_1_16 & (1 << 2); 
tlm.chan_1_16 |= t675.in_1_16 & (1 << 3); 
tlm.chan_1_16 |= t675.in_1_16 & (1 << 4); 
tlm.chan_1_16 |= t675.in_1_16 & (1 << 5); 
tlm.chan_1_16 |= t675.in_1_16 & (1 << 6); 
tlm.chan_1_16 |= t675.in_1_16 & (1 << 7); 
tlm.chan_1_16 |= t675.in_1_16 & (1 << 8); 
tlm.chan_1_16 |= t675.in_1_16 & (1 << 9); 
tlm.chan_1_16 |= t675.in_1_16 & (1 << 10); 
tlm.chan_1_16 |= t675.in_1_16 & (1 << 11); 
tlm.chan_1_16 |= t675.in_1_16 & (1 << 12); 
tlm.chan_1_16 |= t675.in_1_16 & (1 << 13); 
tlm.chan_1_16 |= t675.in_1_16 & (1 << 14); 
tlm.chan_1_16 |= t675.in_1_16 & (1 << 15); 
printf("%x", tlm.chan_1_16); 

Je suis en train de la valeur sur struct à tous ceux (0xFFFF), et je suis en train de le mettre à 0x10, peu par bit. Mais quand je cours ce code j'obtiens toujours 0xFFFF. Vous ne savez pas ce que je fais mal?

Answer 1

essayer avec:

struct example x; 
x.bar = value & 1; 
x.foo = value & 1 << 1; 

fooN = value & 1 << N; 

Answer 2

#include <iostream> 

typedef unsigned short uint16; 

struct example 
{ 
    uint16 bar:1; 
    uint16 foo:1; 
}; 

union foo 
{ 
    struct example x; 
    uint16 value; 
}; 

int main() 
{ 
    uint16 bar = 0x01; 

    foo f; 
    f.value = bar; 

    std::cout << f.x.bar << std::endl; // display 1 
    std::cout << f.x.foo << std::endl; // display 0 
} 

EDIT
Cet extrait a été utilisé dans le code de production et utilisé pour fonctionner comme prévu. Quoi qu'il en soit, il a été testé avec des assertions statiques et des tests unitaires qui garantissaient son exactitude. Comme ils ne sont pas rapportés ici, je suis d'accord qu'il ne devrait pas être utilisé "tel quel".

Puisque vous (OP) mentionné C++, je suggère d'utiliser std::bitset classe:

#include <bitset> 

int main() 
{ 
    std::bitset<16> set(bar); 

    example x; 
    x.bar = set[0]; 
    x.foo = set[1]; 

    std::cout << x.bar << std::endl; // display 1 
    std::cout << x.foo << std::endl; // display 0 
} 

Answer 3

Il est impossible de dire, car les champs de bits sont très mal défini par la norme. Ce qui suit, vous ne pouvez pas savoir:

• si le champ de bits int est traité comme int
• signé ou non signé l'ordre des bits (lsb est où?)
• si le champ de bits peut atteindre passé l'alignement de la mémoire de la CPU ou non
• l'alignement des éléments de champ non-bit de la struct
• l'alignement de la mémoire de champs de bits (vers la gauche ou vers la droite?)
• la endianess des champs de bits
• si les valeurs int simples qui leur sont assignées sont interprétées comme signé ou non signé
• comment les champs de bits sont promus implicitement par les promotions entières
• si les champs de bits signés sont un complément à ou complément à deux
• emplacement des octets de remplissage
• comment des bits de remplissage sont traités
• valeurs des bits de remplissage
• et ainsi de suite

Comme vous pouvez le constater, les champs de bits sont très très mauvais et ne devraient jamais être utilisés.La seule solution raisonnable est de réécrire le code sans champs de bits:

#define FOO 0x01U 
#define BAR 0x02U 

uint16_t value; 

value |= FOO; /* set FOO bit */ 
value &= ~FOO; /* clear FOO bit */ 

Le code ci-dessus peut être exécuté sur un compilateur C/C++ pour tout système dans le monde et vous obtiendrez le résultat escompté.

Answer 4

Les valeurs attribuées aux champs de bits non signés sont définies comme étant modulo 2 ** N réduit, où N est le nombre de bits dans le champ de bit. Cela signifie que si vous affectez un nombre non signé à un champ de bits non signé, les N bits les moins significatifs du nombre d'origine seront utilisés.

Ainsi, étant donné struct example x, si vous voulez que le bit le moins significatif de value à placer dans x.bar vous pouvez simplement faire:

x.bar = value; 

Si vous voulez que le deuxième moins significatif peu de value à placer Dans x.foo, vous pouvez également utiliser:

x.foo = value >> 1;