Comment puis-je combiner les 4 octets en une 32 bits entier non signé?

Je suis en train de convertir 4 octets en une 32 bits entier non signé.

J'ai pensé que peut-être quelque chose comme:

UInt32 combined = (UInt32)((map[i] << 32) | (map[i+1] << 24) | (map[i+2] << 16) | (map[i+3] << 8));

Mais cela ne semble pas fonctionner. Ce qui me manque?

InformationsquelleAutor Pocki | 2011-06-20
  1. 10

    Quarts de travail sont tous de 8. Maj le 24, 16, 8 et 0.

    • Est-ce la seule chose de mal avec elle?
    • En supposant que vous choisissez de coller avec les mathématiques plutôt que de déléguer, oui.
    • la partie confuse pour moi, c'est que je suis en déplaçant un octet postes de plus qu'il possède. Alors, pourquoi la vitesse d'un octet 24 postes de travail? Il n'est pas insensible à la 32 bits int qu'une fois tous les quarts de travail.
    • La valeur des octets occupe les bits 1 à 8. Vous souhaitez passer 24 bits il occupe bits de 24 à 32. Si vous changez de 32 bits, il s'en va à la fin dans l'oubli.
    • Le compilateur est conscient de cela. Mais c'est encore effectuer l'opération en 32 bits, quelle que soit la taille de l'opérande de gauche.
    • ce que je peux lire à propos de ce comportement du compilateur d'aide de 32 bits de ces opérations, même si le type d'être opéré est plus petit? Je veux juste comprendre le sens.
    • Tout est aligné sur le zeroeth (à l'extrême droite, bit le moins significatif). Chaque octet prend huit bits, pour obtenir le bit le plus significatif de l'octet le plus significatif de la gauche (la plus importante), de la position dans le 32 bits word, vous devez passer par 24 bits. L'octet le moins significatif n'a pas à être changé à tout. Écrire une simple illustration de ce sur un morceau de papier, de sorte que vous pouvez les visualiser.
    • Je n'ai pas une référence pour moi-même, mais je sais que les compilateurs C fonctionner de cette manière et je peux voir comment les concepteurs de C# voudrais que le comportement familières pour les développeurs venant de plus de.
    • Harvey, je comprends la partie. Ce que je ne comprends pas tout, c'est comment vous pouvez même changer d'une ~octet~ 24 bits. Un octet contient 8 bits, de sorte que son déplacement de 24 postes ne seraient pas de trop. Il n'est pas converti en 32 bits uint jusqu'après les quarts de travail. Alors, comment est-il en mesure d'effectuer les changements qui sont plus grandes que les octets? Ignacio revendications les quarts de travail sont effectuées avec 32 bits disponibles. Comment?
    • Ce qu'il ne comprend pas, c'est que depuis map[n] est à seulement 8 bits, pourquoi un changement de plus de 8 n'est pas effacer complètement.
    • Le déplacement des opérateurs fonctionnent automatiquement sur ints au minimum, ils ont donc mis un byte ou un short dans un int et puis faire la maj. Si la valeur est déjà un long, il n'est pas diminuer la taille.
    • Joel est correct. Tous les octets sont exprimés à un entier de 32 bits, la valeur de avant le déplacement est effectué.
    • Merci tout le monde pour expliquer que! C'était le débrancher, qui n'a pas de sens pour moi.
    • Je viens de remarquer que le passage d'un ushort convertit également à int plutôt que uint. long l = (uint)255 << 24 et long l = 255 << 24 ont des résultats très différents.

    InformationsquelleAutor Ignacio Vazquez-Abrams
  2. 7

    Utiliser le BitConverter classe.

    Plus précisément, cette surcharge.

    • et.. la raison pour laquelle vous utilisez ce manuel changements est parce que si mon code C# devaient jamais être compilé sur une architecture différente, l'endianess qu'il fonctionne encore?
    • Non, décalage de bits fonctionnera toujours de la même façon, peu importe l'ordre dans lequel les octets réels eux-mêmes sont stockés dans la mémoire. << toujours des décalages de bits "supérieur", et >> déplace "inférieur".
    • Oui, la conversion est endian spécifiques. Il y a un système indicateur spécifique à la classe qu'elle utilise pour ajuster la conversion. Le code ressemble à ceci: if (IsLittleEndian) { return (((numRef[0] | (numRef[1] << 8)) | (numRef[2] << 0x10)) | (numRef[3] << 0x18)); } return ((((numRef[0] << 0x18) | (numRef[1] << 0x10)) | (numRef[2] << 8)) | numRef[3]);
    InformationsquelleAutor Robert Harvey
  3. 4

    BitConverter.ToInt32()

    Vous pouvez toujours faire quelque chose comme ceci:

    public static unsafe int ToInt32(byte[] value, int startIndex)
{
    fixed (byte* numRef = &(value[startIndex]))
    {
        if ((startIndex % 4) == 0)
        {
            return *(((int*)numRef));
        }
        if (IsLittleEndian)
        {
            return (((numRef[0] | (numRef[1] << 8)) | (numRef[2] << 0x10)) | (numRef[3] << 0x18));
        }
        return ((((numRef[0] << 0x18) | (numRef[1] << 0x10)) | (numRef[2] << 8)) | numRef[3]);
    }
}

    Mais ce serait à réinventer la roue, comme c'est en fait la façon dont BitConverter.ToInt32() est mis en œuvre.

    InformationsquelleAutor Alex Aza