C++: Comment puis-je jeter un int à un unsigned long et de ne pas changer tous les bits?

C++: Comment puis-je jeter un int à un unsigned long et de ne pas changer tous les bits?
Je veux emballer et déballer des valeurs dans la mémoire. Le mot de la taille est de 64 bits.

Cet extrait illustre bien le problème:

int v1 = -2; //0xfe
unsigned long v2=(unsigned long)v1; //0xfffe, I want 0x00fe

La solution est simple:

unsigned long v2=(unsigned int)v1; //0x00fe

Toutefois, ce code est dans un modèle où le type de cible est un paramètre, j'ai donc dû recourir à cette:

uint64 target = mem[index] & mask;
uint64 v;
if (value < 0) {
    switch (bits) {
    case 8:
        v = (uint8)value;
        break;
    case 16:
        v = (uint16)value;
        break;
    case 32:
        v = (uint32)value;
        break;
    }
} else {
    v = value;
}
v = v << lShift;
target |= v;
mem[index] = target;

Supposons, par exemple, le type de "valeur" est un int (16 bits) et les bits=16.
Le but est de masquer les bits dans la mémoire de valeur et de les remplacer.

Quelqu'un sait-il un moyen plus facile?

Vous avez une taille de mot de 64 bits et int 16? C'est spécial.
Qu'est-ce que la signature de la méthode? Vous ne donner que des informations partielles ainsi seulement s'attendre à une partie de la bonne solution. Mais je soupçonne que vous pouvez utiliser boost::type_traits pour vous aider.
La façon dont vous le faites n'est pas portable. Si vous souhaitez conserver les bits de façon portable, vous avez besoin de recourir à type de beaucoup les jeux de mots: unsigned long v2= *(unsigned int*)&v1;. Sinon vous avez un conversion de valeur, qui est autorisé à modifier des bits en fonction du signe de la représentation.

OriginalL'auteur Michael Fitzpatrick | 2011-08-05

  1. 7

    En supposant que vous avez le C++0x support:

    #include <type_traits>
v= static_cast<std::make_unsigned<decltype(value)>::type>(value);

    Je suis en supposant que vous êtes le paramétrage du type de value, sinon cela n'a aucun sens.

    EDIT: C++-ish en utilisant static_cast au lieu d'un C cast. Je suppose que c'est ce qui m'a un downvote.

    Très agréable, bon à savoir il y a déjà un trait pour que!

    OriginalL'auteur MSN

  2. 5

    Si vous n'avez pas l'esprit de la saisie, un trait de classe vient à l'esprit:

    template <typename IType> struct ToULong;

template <> struct ToULong<signed char>
{
  static inline unsigned long int get(signed char c) { return (unsigned char)(c); }
};

template <> struct ToULong<signed short int>
{
  static inline unsigned long int get(signed short int c) { return (unsigned short int)(c); }
};

/* ... signed int, signed long int, signed long long int ... */

    Utilisation:

    template <typename IType>
struct Foo
{
  unsigned lont int get_data() const { return ToULong<IType>::get(m_data); }
private:
  IType m_data;
}

    Mise à jour: Encore plus simple, vous avez juste à faire un tas de surcharges:

    unsigned long int toULong(            char c) { return (unsigned      char)(c); }
unsigned long int toULong(signed      char c) { return (unsigned      char)(c); }
unsigned long int toULong(signed short int c) { return (unsigned short int)(c); }
unsigned long int toULong(signed       int c) { return (unsigned       int)(c); }
unsigned long int toULong(signed  long int c) { return (unsigned  long int)(c); }

    2e mise à jour: vous devriez probablement Vous dire static_cast<T>(x) plutôt que (T)(x) si vous voulez être encore plus similaire à C++.

    Downvoter, le soin d'expliquer à votre objection?
    Cela a l'air vraiment prometteur puisque le compilateur est en train de faire le travail que mon exemple n'est au moment de l'exécution. Ainsi, au lieu de l'expression "si (valeur < 0)" je vais ajouter "v = ToULong<IntType> ();" où "IntType" le type de la valeur de la variable.
    Vous devez appeler la fonction membre statique, ToULong<IntType>::get(value) -- mais je pense que les surchargées gratuit fonctions aussi bien et ils sont un peu plus simple sur le plan conceptuel. Le trait de classe vous donne un peu de type supplémentaire de sécurité, parce que les fonctions libres peuvent également travailler pour (sans ambiguïté) implicitement convertible types, qui peuvent être inattendus.

    OriginalL'auteur Kerrek SB

  3. 2

    Comment au sujet de l'union?

    union u1 {
    short int si;
    unsigned long int uli;

    unsigned long int stub;

    operator unsigned long int () {return uli;};
public:
    u1(short int nsi) : stub(0) {si = nsi;}

};
    Si sizeof(int) != sizeof(long int), puis les meilleurs morceaux de la unsigned long peut être indéfini.
    Velthuis Veuillez noter stub membre.
    Oh, OK, je vois maintenant.

    OriginalL'auteur outmind

  4. 1

    À l'aide de l'idée avancée par "Kerrek SB" je suis venu avec une solution.

    template <typename Tint> uint64 ToMemdata(Tint value) {
    return (uint64)value;};
template <> uint64 ToMemdata<int8>(int8 value) {
    return (uint64)((uint8)value);};
template <> uint64 ToMemdata<int16>(int16 value) {
    return (uint64)((uint16)value);};
template <> uint64 ToMemdata<int32>(int32 value) {
    return (uint64)((uint32)value);};
template <> uint64 ToMemdata<int64>(int64 value) {
    return (uint64)((uint64)value);};

template <typename Tint> void packedWrite(Tint value, int vectorIndex, uint64* pData) {

    uint64 v = ToMemdata(value);
    //This call eliminates a run time test for minus and a switch statement
    //Instead the compiler does it based on the template specialization

    uint64 aryix, itemofs;
    vectorArrayIndex(vectorIndex, &aryix, &itemofs); //get the memory index and the byte offset
    uint64 mask = vectorItemMask(itemofs); //get the mask for the particular byte
    uint64 aryData = pData[aryix]; //get the word in memory
    aryData &= mask; //mask it
    uint64 lShift = (uint64)(itemofs * sizeof(Tint) * 8); 
    uint64 d = v << lShift; //shift the value into the byte position
    aryData |= d; //put the value into memory
    pData[aryix] = aryData;
}

    L'aide de ce concept, j'ai été en mesure d'apporter d'autres améliorations au code.
    Par exemple, l'appel à vectorItemMask() est maintenant templateized aussi.

    OriginalL'auteur Michael Fitzpatrick

  5. -1

    De jeter sans changer les bits de prendre une référence, puis de déréférencement avec le type approprié:

    int v1 = -2; //0xfe
unsigned long v2=*(unsigned long *)&v1;

    Cela suppose que les tailles sont les mêmes. Il a un comportement indéfini si sizeof(int) != sizeof(unsigned long). Vous voulez probablement unsigned int.

    Edit: réalisé que j'ai répondu à une fausse question.

    Boost type_traits a quelque chose (je crois que c'est make_unsigned) pour convertir un type int pour la version non signée (si elle est signée) et ne rien faire si ce n'est pas signé.

    Casting int* à unsigned long* et de déférence est un comportement indéterminé si je me souviens bien.
    Avec certains compilateurs, int et unsigned long ont la même taille, ce qui signifie il n'y a pas un comportement indéfini. Ce qui est parfaitement analogue à un syndicat.
    Sauf qu'elle ne se stricte aliasing règles. D'accéder à un type par l'intermédiaire d'un pointeur vers un autre type UB.
    *reinterpret_cast<unsigned long *>&v1 UB?
    Le reinterpret_cast devra être définie par l'implémentation. Sinon, nous ne savons pas ce qu'il fait. Le standard laisse la conversion entre les différents types de pointeur jusqu'à la mise en œuvre.

    OriginalL'auteur Foo Bah

  6. -1

    Je crois que vous pourriez utiliser un bit à bit ET pour obtenir le résultat souhaité.

    unsigned long v2 = 0;
v2 = v2 | v1;
    Ne pourrait-il pas être au niveau du bit ou? C'est toujours pour un rendement de 0.
    Et vous obtenez toujours une promotion à un type commun avant en faisant de l'op.

    OriginalL'auteur Puppy