C++ int tableau d'octets

J'ai cette méthode dans mon code java qui retourne le tableau d'octets de donnée de type int:

private static byte[] intToBytes(int paramInt)
{
     byte[] arrayOfByte = new byte[4];
     ByteBuffer localByteBuffer = ByteBuffer.allocate(4);
     localByteBuffer.putInt(paramInt);
     for (int i = 0; i < 4; i++)
         arrayOfByte[(3 - i)] = localByteBuffer.array()[i];
     return arrayOfByte;
}

Quelqu'un peut-il me donner des astuce comment puis-je convertir cette méthode C++?

InformationsquelleAutor justme_ | 2011-04-07

arrays byte c++int

19

À l'aide de std::vector<unsigned char>:
```
#include <vector>
using namespace std;

vector<unsigned char> intToBytes(int paramInt)
{
     vector<unsigned char> arrayOfByte(4);
     for (int i = 0; i < 4; i++)
         arrayOfByte[3 - i] = (paramInt >> (i * 8));
     return arrayOfByte;
}
```
- Le code Java génère un big endian représentation; vous générez un petit-boutiste un. (J'avais aussi simplement utiliser le décalage que la boucle de contrôle: int i = 32; while ( i != 0 ) { arrayOfByte[i] = paramInt >> i; i -= 8; }
- Kanze, merci. édité.
- attendez... peut-on réellement utiliser i pour accéder à arrayOfByte quand il y aura des valeurs de [32, 24, 16, 8]? Je pense que vous devriez faire arrayOfByte[i/8].
- Oui, L'index doit être i/8.
InformationsquelleAutor Donotalo
48

Vous n'avez pas besoin d'une fonction pour cela; une distribution simple suffira:
```
int x;
static_cast<char*>(static_cast<void*>(&x));
```
N'importe quel objet en C++ peut être réinterprété comme un tableau d'octets. Si vous voulez effectivement faire une copie des octets dans un tableau séparé, vous pouvez utiliser std::copy:
```
int x;
char bytes[sizeof x];
std::copy(static_cast<const char*>(static_cast<const void*>(&x)),
          static_cast<const char*>(static_cast<const void*>(&x)) + sizeof x,
          bytes);
```
Aucune de ces méthodes ne prend ordre des octets en compte, mais comme vous pouvez réinterpréter le int comme un tableau d'octets, c'est facile à effectuer les modifications nécessaires vous-même.
- Peut-être. Pas sur un processeur Intel box (ou au moins, il ne donnera pas les mêmes résultats).
- Je suis curieux: pourquoi avez-vous fait deux static_cast<>s au lieu d'un reinterpret_cast<>?
- La Superstition. L'approche devrait fonctionner.
- À préciser: Il y avait de longues discussions ici un an ou deux au sujet de si un reinterpret_cast est garanti pour être l'équivalent de la paire de static_cast. Si je me souviens bien, il était d'accord en principe que les deux devraient toujours travailler, mais il a été très compliquée donc j'ai toujours éviter de reinterpret_cast.
InformationsquelleAutor James McNellis
12

Un autre moyen utile de le faire que j'utilise est les syndicats:
```
union byteint
{
    byte b[sizeof int];
    int i;
};
byteint bi;
bi.i = 1337;
for(int i = 0; i<4;i++)
    destination[i] = bi.b[i];
```
Cela fera en sorte que le tableau d'octets et le nombre entier de "chevauchement"( partagent la même mémoire ).
cela peut être fait avec toutes sortes de types, aussi longtemps que le tableau d'octets est de la même taille que le type( sinon l'un des champs ne sera pas influencé par les autres ). Et de les avoir comme un seul objet est également très pratique lorsque vous devez basculer entre les entier de manipulation de bits et de la manipulation et de la copie.
- La lecture d'un mauvais membre de l'union est un Comportement Indéfini et l'utilisation abusive de l'union
- Ce qui est faux. Ce n'est pas ce que les syndicats sont pour. Ce n'est pas la manière dont les syndicats de travail. Mythe!
InformationsquelleAutor NullData

Vous pouvez obtenir octets individuels avec anding et le déplacement des opérations:

byte1 =  nint & 0x000000ff
byte2 = (nint & 0x0000ff00) >> 8
byte3 = (nint & 0x00ff0000) >> 16
byte4 = (nint & 0xff000000) >> 24

InformationsquelleAutor BlackBear

Int byte et vice versa.

unsigned char bytes[4];
unsigned long n = 1024;

bytes[0] = (n >> 24) & 0xFF;
bytes[1] = (n >> 16) & 0xFF;
bytes[2] = (n >> 8) & 0xFF;
bytes[3] = n & 0xFF;

printf("%x %x %x %x\n", bytes[0], bytes[1], bytes[2], bytes[3]);


int num = 0;
for(int i = 0; i < 4; i++)
 {
 num <<= 8;
 num |= bytes[i];
 }


printf("number %d",num);

InformationsquelleAutor Sarath AK

std::vector<unsigned char> intToBytes(int value)
{
    std::vector<unsigned char> result;
    result.push_back(value >> 24);
    result.push_back(value >> 16);
    result.push_back(value >>  8);
    result.push_back(value      );
    return result;
}

InformationsquelleAutor James Kanze

2

Un int (ou tout autre type de données que ce soit), est déjà stocké des octets en mémoire. Alors pourquoi ne pas simplement copier la mémoire directement?
```
memcpy(arrayOfByte, &x, sizeof x);
```
Un simple élégant une ligne qui fonctionne également avec n'importe quel autre type de données.

Si vous avez besoin d'octets inversée, vous pouvez utiliser std::reverse
```
memcpy(arrayOfByte, &x, sizeof x);
std::reverse(arrayOfByte, arrayOfByte + sizeof x);
```
ou, mieux encore, il suffit de copier les octets dans l'ordre inverse de commencer avec
```
BYTE* p = (BYTE*) &x;
std::reverse_copy(p, p + sizeof x, arrayOfByte);
```
Si vous ne voulez pas faire une copie des données à tous, et juste avoir sa représentation en octets
```
BYTE* bytes = (BYTE*) &x;
```
InformationsquelleAutor SportySpice
1
```
return ((byte[0]<<24)|(byte[1]<<16)|(byte[2]<<8)|(byte[3]));
```
😀
- il a demandé exactement le contraire 🙂
- wow, je n'ai pas! Toujours l'impression que si je ne réponds pas tout de suite d'un million d'autres personnes. J'avais raison, mais je suppose que je devrais assurez-vous d'obtenir le droit de la question hahaha
- ouais, moi aussi essayer de répondre aussi vite que possible, et parfois écrire un tel bullsh*ts 😉
- Il est toujours utile.
InformationsquelleAutor jberg

Je sais que cette question a déjà les réponses mais je vous donne ma solution à ce problème. Je suis en utilisant la fonction de modèle et entier contrainte.

Voici ma solution:

#include <type_traits>
#include <vector>

template <typename T,
          typename std::enable_if<std::is_arithmetic<T>::value>::type* = nullptr>
std::vector<uint8_t> splitValueToBytes(T const& value)
{
    std::vector<uint8_t> bytes;

    for (size_t i = 0; i < sizeof(value); i++)
    {
        uint8_t byte = value >> (i * 8);
        bytes.insert(bytes.begin(), byte);
    }

    return bytes;
}

InformationsquelleAutor NutCracker

Vous devez vous connecter pour publier un commentaire.