Discussion :

[dboulange]

Bonjour,
je cherche à créer les opérateurs de décalage de bits << et >> pour qu'ils s'appliquent à un tableau de 8 unsigned char, quelqu'un a t'il un algo simple est rapide (de préférence).
Merci.

[matazz]

Question :
tu as tab[0]=0xFF, tab[1]=0xAA... et tu veut appliquer un décalage de n bits sur chaque cellule ou bien l'ensemble de ton tableau est pour toi un type et tu veut décaler de n bits la valeur de ton type (je sais pas si c'est clair ça) [/b]

[dboulange]

En gros mon tableau est un type mais je peux y avoir accés comme un tableau toto[0]...toto[7]
mon but et de faire le décalage sur l'ensemble du tableau et non sur chaque élément.

[AFIJARODOX]

Je ne vois pas trop l'intérêt mais bon :

déclare plutôt un string dans lequel tu concatène les éléments de ton tableau puis applique << ou >>.

Afi

[dboulange]

Cette solution est trop simple ça marche pas.

[matazz]

ben je sais pas mais imaginons :
(pour des questions de simplifications je te le fais sur 2 Byte (unsigned char)
imaginons que tu ais 0xFF 0xAA (11111111 10101010) sous forme d"un pointeur sur un tableau Byte *tab (où tab[0]=0xFF et tab[1]=0xAA
en castant ton Byte* dans un short* et en faisant le décalage sur le short, ça devrait marcher.
en effet (je me trompe peut être) mais les Bytes de ton tableaux sont dans le même espace mémoire et succéssifs...

Ce code là devrait marcher (à tester quand même !!)

Code :

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

1
2
3
 
short *val = (short*)tab;
*val = *val << 3;

donc dans ton cas en le faisant sur un __int64 (codé sur 8 Bytes) ça devrai marcher...

Par contre niveau performance je sais pas trop ce que ça donne mais bon je pense que ça doit être pas mal...

[matazz]

bon ben j'ai testé avec un __int64 et ça marche.
j'ai corrigé mon post précédent car c'est un short* qu'il faut utiliser...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
	BYTE *Tab = new BYTE[8];
	Tab[0] = 0x8F;
	Tab[1] = 0x8F;
	Tab[2] = 0x8F;
	Tab[3] = 0x8F;
	Tab[4] = 0x8F;
	Tab[5] = 0x8F;
	Tab[6] = 0x8F;
	Tab[7] = 0x8F;
 
	__int64 *Decal = (__int64*)Tab;
	*Decal = *Decal<<1;
 
//Resultat : 0x1f1f1f1f1f1f1f1e

0x8F (1000 1111) par décalage de 1 bit à gauche donne 0x1F (0001 1111) quand on à 0xFF à droite
...
et pour le dernier 0x8F donne 0x1E (0001 1110) car le premier bit décalé est remplacé par 0.

[dboulange]

J'ai juste un petit problème avec ta solution, c'est que mon programme doit compiler sous Windows et sous unix en ANSI et que le type __int64 n'existe pas.
Pour ta premiére solution il faut quand même tester le bit de poids fort pour savoir si on effectue le décalage sur le "short" suivant.
Merci pour tes réponses.

[Laurent Gomila]

Il y a de fortes chances que les systèmes n'ayant pas du __int64 aient du long long (une petite directive précompilateur et c'est reglé), cependant je pense que c'est une solution incorrecte : ça dépend de l'endianness de la machine (ou alors là encore, il faut jouer avec le préprocesseur, mais ça devient vraiment lourd pour pas grand chose).

Les performances sont-elles réellement un critère important dans ton cas ?

[matazz]

Désolé je pensait que le type __intn était standard...(VC++ quand tu nous tiens...)

[dboulange]

J'ai trouvé cette solution, qui doit prendre un peu de temps, mais elle utilise que des décalage dit moi ce que tu en penses :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
unsigned short followingBit = 0;
for( int i=0; i<val_.m_value.i; i++ )
{
     for( j=0; i<8; j++ )
     {
          temp.m_value.b[i] = (m_value.b[i]) >> 1;
          temp.m_value.b[i] = (m_value.b[i]) ^ followingBit;
 
            followingBit = (m_value.b[i]) << 7;
        }
}

[Balises CODE rajoutées par Loulou24, merci d'y penser à l'avenir]

[dboulange]

C'est le même que précédemment mais avec les bons indices...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
        int j;
        unsigned short followingBit = 0;
        for( int i=0; i<val_.m_value.i; i++ )
        {
          for( j=0; j<8; j++ )
          {
            temp.m_value.b[j] = (m_value.b[j]) >> 1;
            temp.m_value.b[j] = (m_value.b[j]) ^ followingBit;
 
            followingBit = (m_value.b[j]) << 7;
          }
        }

[Laurent Gomila]

Désolé je pensait que le type __intn était standard...(VC++ quand tu nous tiens...)

En général ce qui commence par _ ou __ ne l'est jamais

dboulange ->

[matazz]

effectivement en décalant chaque valeur de cellule et en récupérant les nbits du précédant décalage sa devrait marcher.

[JolyLoic]

Le code proposé réalise un décalage de 3 bits en faisant 3 décalages de 1 bit, ce qui marche, mais n'est assurément pas très efficace.

Tant que les décalages sont inférieurs à numeric_limits<unsigned chax>::digits (8 en général), c'est très simple à faire directement le bon décalage dans chaque case, et à reporter toute le retenue, qui doit alors avoir la taille d'un unsigned char aussi.

Si le décalage est supérieur à ce nombre, ce qui me semble le plus simple c'est dans ce cas là, de considérer le nombre de décalage d'unsigned char entiers (on bouge directement les cases du tableau), puis d'appliquer l'algo précédent pour ce qu'il reste à décaler.