Discussion :

[pol2095]

Bonjour,

quand je crée un char*

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
int numBytes = sizeof(int);
int value = 2024 ;
char* bytes = (char*)malloc(numBytes);
memcpy( bytes, &value, numBytes );

il est dans l'ordre little-endian, peut-on le créer directement en big-endian ?

Merci

[dalfab]

Bonjour,

Peux tu préciser ta question?
Un pointeur char* c'est un nombre, ça pas de sens de parler d'endianess pour cela.
Si par contre on s'intéresse à ce qui est pointé, l'endianess aurait un sens, mais ici il s'agit de bytes (=char) qui sont placés les uns après les autres et donc l'endianess n'interviendrait pas.
A moins que les bytes fassent plusieurs octets, là savoir s'ils sont big-endians ou little-endian est important, est-ce bien la question?

Si on suit ton exemple, tu te place dans le cas particulier d'un entier. Et si c'était un short, et si c'était un long? Le traitement à faire ne serait pas le même pour changer l'endianess.
Le seul moyen est de forcer les données à être dans l'ordre où te le souhaite, est de faire que ce code ne dépende pas de l'endianess de ton processeur (qui serait ici little-endian). Je suppose que les char font un octet dans mon exemple.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
void  write_int( unsigned char* pt, unsigned int x ) {
    for ( size_t i{} ; i < sizeof(int) ; ++i ) {
        pt[i+sizeof(int)-1] = static_cast<unsigned char>( x );   // écriture d'un buffer big-endian
        x >>= 8;
    }
}

[pol2095]

un "int" occupe 4 octets (4 char)
j'ai le même problème sur Mac en Objective-C
je suis en big-endian si j'utilise std::reverse()

[Kannagi]

l'endianess n'a aucun sens sur 1 octet , donc j'ai du mal à comprendre la question.

[pol2095]

les 4 char retourne -24 7 0 0
alors que le reverse retourne 0 0 7 -24
il y a 4 octets ?

[Kannagi]

ah oui , tu voulais afficher ton int , un simple affichage hexadécimal aurait suffit.
Donc oui , il faut inverser.

sur stackoverflow , tu serait tomber sur ce genre de code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
uint32_t b0,b1,b2,b3;
uint32_t res;
 
b0 = (num & 0x000000ff) << 24u;
b1 = (num & 0x0000ff00) << 8u;
b2 = (num & 0x00ff0000) >> 8u;
b3 = (num & 0xff000000) >> 24u;
 
res = b0 | b1 | b2 | b3;

[Bousk]

L'endianness dépend de ta machine.
https://bousk.developpez.com/cours/s...on-bases/#LI-A

[pol2095]

D'après mes tests Windows, Android, iOS, macOS, Ubuntu, Fedora utilisent little-endian.

[dalfab]

D'après mes tests Windows, Android, iOS, macOS, Ubuntu, Fedora utilisent little-endian.

Comme écrit plus haut, ça n'est pas le système d'exploitation qui décide, c'est le processeur. Par exemple, les Intel sont presque tous little-endian, les PowerPC étaient big mais sont little depuis la V10, les ARM sont little ou big.

Sur un code écrit correctement, c'est totalement transparent.

Quand on doit sérialiser les données, c'est le protocole qui indique quel format utiliser. Là c'est souvent poids fort en tête, ce qui correspondrait au big-endian.

[pol2095]

je teste si le système est little ou big endian, en fonction j'utilise un reverse ou pas pour le int.

[Médinoc]

Franchement t'as plus vite fait de faire un code qui écrit directement octet par octet sans passer par memcpy().
Ce sera plus portable et tu n'auras même pas besoin de faire un test!

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void write_be32(std::vector<char> &sortie, unsigned int entier)
{
	auto b0 = static_cast<unsigned char>(entier);
	auto b1 = static_cast<unsigned char>(entier >> 8);
	auto b2 = static_cast<unsigned char>(entier >> 16);
	auto b3 = static_cast<unsigned char>(entier >> 24);
	//Et pour la version qui sérialise toujours en little-endian, il suffit juste d'inverser l'ordre des 4 lignes qui suivent
	sortie.push_back(b3);
	sortie.push_back(b2);
	sortie.push_back(b1);
	sortie.push_back(b0);
}
 
void write_be32(std::vector<char> &sortie, int entier) { write_be32(sortie, static_cast<unsigned int>(entier)); }

Et si tu tiens vraiment à utiliser un pointeur nu:

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void write_be32(char* &sortie, unsigned int entier)
{
	auto b0 = static_cast<unsigned char>(entier);
	auto b1 = static_cast<unsigned char>(entier >> 8);
	auto b2 = static_cast<unsigned char>(entier >> 16);
	auto b3 = static_cast<unsigned char>(entier >> 24);
	//Et pour la version qui sérialise toujours en little-endian, il suffit juste d'inverser l'ordre des 4 lignes qui suivent
	*(sortie++) = b3;
	*(sortie++) = b2;
	*(sortie++) = b1;
	*(sortie++) = b0;
}
 
void write_be32(char* &sortie, int entier) { write_be32(sortie, static_cast<unsigned int>(entier)); }