char* et big-endian

Version imprimable

18/12/2021, 09h14
pol2095

char* et big-endian
Bonjour,

quand je crée un char*
Code:

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

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:

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; } }

18/12/2021, 12h24
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()
18/12/2021, 14h53
Kannagi

l'endianess n'a aucun sens sur 1 octet , donc j'ai du mal à comprendre la question.
18/12/2021, 15h02
pol2095

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

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:

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;

20/12/2021, 14h33
Bousk

L'endianness dépend de ta machine.
https://bousk.developpez.com/cours/s...on-bases/#LI-A
21/12/2021, 13h18
pol2095

D'après mes tests Windows, Android, iOS, macOS, Ubuntu, Fedora utilisent little-endian.
21/12/2021, 13h56
dalfab

Citation:

Envoyé par pol2095

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.
21/12/2021, 14h15
pol2095

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

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:

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:

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)); }