Je suis confronté au pbs little/big endians. Un ami m'a dit que programmer une fonction qui permet la convertion tient en 10 lignes. Ca m'embète d'utiliser une librairie, c'est chiant et pleins de conflits. Je vais donc essayer de programmer cette fonction de convertion 'à la main'.  
J'attends vos conseils !!
 
Bye !

J'aime bien gunm aussi
 
peut-être en assembleur ???

J'avoue ne pas voir quel est ton problème !
Peux tu préciser ?
 
Si c'est un  pb d'affichage, l'échange de 2 octets prendra moins de 10 lignes...

/* Convertion little endian<-->big endian */
bswap(char *dst, char *dst, int n)
{
 int i,j;
 for(i = 0, j = n - 1; i < n; i++, j--)
  dst[i] = src[j];
}
 
int a;
int b;
 
bswap(&a, &b, sizeof(a));
 
A toi d'optimiser maintenant que tu sait ce que c'est.

Si tu es sur un processeur intel, tu peux faire ça :
 
int a;
 
_asm
{
 mov eax, a
 bswap eax
}
 
ça swap les octets de poids fort et poids faible.

[edit]--Message édité par gilou2--[/edit]

Juste besoin d'une macro avec des shifts et des OU pour masquer:
 
#define bswap32(x) (((x) & 0xFF000000) >> 24 || ((x) & 0x00FF0000 >> 8 || ((x & 0x0000FF00) << 8) || ((x) & 0x000000FF << 24))
 
Le même chose pour 16 bits.
 
Effectivement t'as aussi d'autres moyens avec de l'asm direct sur pas mal de proc (nottament les intels, car ce sont eux qui sont petit endien). Mais c'est pas portable. Si c'est pour un pb de reseaux (big endian) généralement on fait des macro HOST2NET et NET2HOST, definies differement selon l'endianess de l'host.

euh si tu programmes ca en C, je dirais juste que c'est pas en réinventant la roue à chake fois ke tu dois coder un truc que tu vas etre efficace ...
 
Enfin, si cela t'amuses de programmer ca, j'ai rien dit.

ouaou tout ça comme réponses ?!
gilou2 : je pensais à un truc similaire à celui que tu proposes en premier :
 
void a_convertion_LBE(char* ptr,int taille){
 
 char tmp [100];
 int i;
 
 /* on parcours la zone mémoire tout en sauvegardant */
 for (i=taille;i>=0;i--){
  tmp[i-1]=*ptr++;
 }
 memcpy(ptr,tmp,taille);
}
 
Mais bon ça marche pas encore. Sais pas si il vaut mieux récupérer en char * ou int *, vais voir. C'est pas propre mais là n'est pas le problème.
 
MC : ta solution à l'air bien sympa mais je comprends pas totalement ce que tu a écris mais je vais y réfléchir. Tu peux me dire à quoi correspond le 24/ le 8 ? Tu fais un décalage des octets c'est ça ?
 
 
JPA : oui c'est juste un décalage des octets que je veux faire.
 
Je bosses sur intel et transmissions réseau pour unix.
 
 
Merci !

Euh si tu fais la conversion sur un gros espace de donnée comme ca tu vas te retrouver avec tes données dans le mauvais ordre (mais le bon endianess). Il faut que tu le fasse sur chaque donnée 16 et 32 bits, d'ou l'interet de l'assembleur pour optimiser. L'idée de la macro c'est juste de swapper les octets par decalage et masque (le LSB devient le MSB). C'est globalement plus efficace qu'une boucle (surtout sur un proc recent qui n'aime pas les boucles courtes).
 
Je programme en embedded (routeurs), on a des .h qui definissent des macros qui pointent vers les fonctions soit en C soit en assembleur (en fait de l'assembleur en ligne) selon la plateforme que l'on utilise (on fait la transition de big a little endian et on change de proc en plus). Tu n'as qu'a t'en faire un le plus portable possible comme ca tu n'as pas a te soucier du portage ni d'eventuelle librairies (surtout pour un truc aussi trivial que ca).

MC> Dans ta macro il faut remplacer les "||" par "|".