Discussion :

[BatuBou]

Bonjour a vous tous,

Voila je souhaite manipuler des unsigned char et faire des opérations dessus mais je rencontre pas mal de problème

Je souhaite soustraire un tableau d'unsigned char les uns avec les autres c'est a dire Xi - X(i-1)
Donc si les deux ne font pas de dépassement tout va bien, mais si la soustraction me donne un résultat négatif et que je le soustrait avec le suivant que dois je faire pour les le remettre en unsigned char? Faire un complement a deux?

Mes fonctions sont elles bien adaptées?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
typedef unsigned char uchar;
 
enum {FALSE, TRUE};
int Bit(uchar x, int pos)
{
return (x>>pos)&1;
}
 
int Add(uchar x, uchar y)
{
 uchar bx,by;
 int i=0, som =0;
 int ret = 0;
 while (i<(sizeof(char)*7))
   {
    bx = Bit(x,i);
    by = Bit(y,i);
    som = som | (bx^by^ret)<<i;
    ret = (bx|by)&(bx|ret)&(by|ret);
    i++;
   } 
 bx = Bit(x,i);
 by = Bit(y,i);
 return som;
}
 
int Sous(uchar x, uchar y)
{
 y = Add(~y, 1);
 return Add(x, y);
}
 
int EstNegatif (uchar x)
{
 if (Bit(x,8)==0)
  return FALSE;
 else return TRUE;
}

Le résultat que je vais trouver peut être sur n+1 bits, comment dois je faire pour le remettre sur n bits? avec un modulo 254?

Merci pour vos futures réponses

[diogene]

BatuBou :

mais si la soustraction me donne un résultat négatif et que je le soustrait avec le suivant que dois je faire pour les le remettre en unsigned char? Faire un complement a deux?

Il est évident que dans ce cas, tu ne peux mettre le résultat en unsigned char en conservant la valeur. Donc, tout dépend de ce que TU veux faire dans ce cas. mettre la valeur absolue du nombre (complément à deux puis stockage) ou stocker directement dans un unsigned char, auquel cas le comportement du compilateur fait qu'il prendra un modulo 256 pour ramener la valeur entre 0 et 255 (si tes char sont sur 8 bits)

[BatuBou]

Merci pour votre reponse, mais je dois avouer que j'ai du mal a comprendre les operations sur les bits.

J'ai fait une fonction pour afficher mes unsigned char, quand je lui demande de m'afficher uchar c = 251; il m'affiche 0 11111011.

Pour savoir si il est negatif ou non je dois donc tester le 8ieme bit?

Code :

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

1
2
3
4
5
6
7
8
9
10
void UcharToBin(uchar c){
	int i;
 
	for(i = sizeof(char)*CHAR_BIT -1; i>=0 ;i--){
		if((c&(1<<i)) == 0) printf ("0");
		else printf("1");
		if(!(i%CHAR_BIT)) printf("  ");
	}
	printf("\n");
}

Avec ma fonction Sous quand je fais Sous(251,254) il me renvoie 125

[Médinoc]

Un nombre unsigned n'est jamais négatif, par définition (uchar)251 correspond à (char)-5.
Et ta fonction affiche un bit de trop.


Si tu veux pouvoir utiliser des char négatifs, tu n'auras pas de nombre supérieur à 127.

[BatuBou]

Non en fait je veux utiliser la soustraction sur des unsigned char, mais comme le resultat va donner des entiers signés sur n + 1 bit je souhaite les ramener dans un premier temps a des unsigned char et dans un second temps les ramener sur n bits, c'est pour faire un codage differentiel sur des images...

Desolé d'insister mais je ne comprends pas du tout la manipulation des bits

Merci encore pour votre aide

[Médinoc]

SI tu veux soustraire 251, je te conseille de le convertir en un entier de taille supérieure ou égale à 9 bits et de lui donner la valeur -251.
Ensuite, tu n'auras plus qu'à en faire une addition sur 9 bits, et ignorer la retenue (le 10e bit)

[Melem]

Non en fait je veux utiliser la soustraction sur des unsigned char, mais comme le resultat va donner des entiers signés sur n + 1 bit je souhaite les ramener dans un premier temps a des unsigned char et dans un second temps les ramener sur n bits

Tu veux noyer une carpe ou quoi? Un nombre non signé par essence ne peut pas être négatif que veux-tu de plus. La plage des valeurs possibles que peut prendre un unsigned char si sa taille est de 8 bits est 0 - 255. A l'intérieur de l'ordinateur les données sont représentées sous forme binaire. Si je te demandes par exemple : que représente 10001010. Que vas tu répondres? Un entier (signé ou non signé)? Un flottant? Une adresse? Un caractère? Une couleur? Une position? ... C'est à toi de faire l'intérprétation que tu veux mais vu d'un signed char ça vaut peut-être -118, vu d'un unsigned char c'est 138, etc. Et réciproquement si tu affectes 138 ou -118 etc. à un unsigned char tu auras le même résultat : 138! Soit 10001010. Les opérateurs de manipulation de bits permettent de manipuler les données au niveau des bits, sans aucune interprétation quelconque. Pour faire des opérations de décalage << ou >>, il vaut mieux toujours utiliser des entiers non signés (je rappellme qu'un caractère est aussi un entier) car le résultat de l'opération avec des entiers signés est dépendant de l'implémentation (à cause de la représentation des nombres négatifs).

[f.morgan3]

Ok, mais je pense plutôt que ce que tu souhaite faire si j'ai bien compris :

utiliser les 8 bits d'un unsigned char par exemple et ajouté un bit en tête qui sera le bit de signe. Ainsi tu peux utiliser les valeurs de -255 a 255 c pas bête...

donc ce qu'il te faut c'est un short int en signé. Le problème c'est que tu va avoir : bit de signe -> 7 * 0-> Valeur de 0 à 255

Comme tu l'aura compris tu a 7 bit a 0, sa prend de la place pour rien.

Tu peux donc inverser le signed en unsigned ansi tu aura :

7*1 -> bit de signe inversé -> valeur en unsigned.

Dis moi si c un truc comme sa que tu souhaites ....

Désolé si je suis pas clair

[BatuBou]

La c'est moi qu'on a noyé

Je vais reprendre depuis le debut:

Quand je vais soustraire mes deux unsigned char je vais obtenir un unsigned char...

Mais avec mes fonctions ecrient plus haut je ne trouve pas le bon resultat enfin je pense...

par exemple la soustraction avec ma fonction Sous(150, 251) me retourne 27...

Donc j'ai essayé avec un short int pour recuperer le bit de poids fort, positif ou negatif, mais ca ne marche pas mieux

Desolé si je ne comprends pas grand chose

Merci pour vos reponses

[fremen167]

La c'est moi qu'on a noyé

Je vais reprendre depuis le debut:

Quand je vais soustraire mes deux unsigned char je vais obtenir un unsigned char...

Mais avec mes fonctions ecrient plus haut je ne trouve pas le bon resultat enfin je pense...

par exemple la soustraction avec ma fonction Sous(150, 251) me retourne 27...

Donc j'ai essayé avec un short int pour recuperer le bit de poids fort, positif ou negatif, mais ca ne marche pas mieux

Desolé si je ne comprends pas grand chose

Merci pour vos reponses

Tout d'abord, il faut que TU définisses la sémantique de tes opérateurs :
Addition (x, y) : que veux-tu obtenir si x + y > 255 ?
Soustraction (x, y) : que veux-tu obtenir si x < y ?

Dans le cas de l'addition, tu calcules dans une variable intermédiaire plus grande qu'un char, puis tu vérifies si le résultat intermédiaire est > 255... et tu le traites comme tu le souhaites.

Supposons que tu veuilles retourner la valeur absolue dans le cas de la soustraction. Alors tu peux implémenter :

Code :

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

1
2
3
 
SI x > y, retourner x - y
sinon retourner y - x.

[diogene]

La c'est moi qu'on a noyé

Je vais reprendre depuis le debut:

Quand je vais soustraire mes deux unsigned char je vais obtenir un unsigned char...

En fait, non. La soustraction de deux unsigned char va te donner un int. Le problème arrive lorsque tu veux ranger cet int dans un unsigned char.
Pour ajouter deux unsigned char, il suffit d'utiliser +
Pour soustraire deux unsigned char, il suffit d'utiliser -
Dans les deux cas, le résultat est un int.
Dans le cas général, ces résultats ne tiennent pas dans un unsigned char.
Que faire du résultat de ces opérations ? C'est toi qui devrait savoir ce que tu veux faire du résultat, quel traitement tu dois appliquer. Nous, on ne sait pas et on ne peut pas te donner de conseils si tu n'expliques pas clairement ce que tu veux obtenir au final

[BatuBou]

Merci pour votre réponse

Je fais donc la soustraction de mes unsigned char
Le résultat sera donc récupéré dans un short, entier signé.

Maintenant je souhaite ramener ce résultat à en entier non signé.
Suffit il de tester le 9ieme bit savoir si c'est un, si c'est le cas faire le complément à deux de mon résultat?

C'est pour le codage différentiel

Merci encore, j'ai vraiment beaucoup de mal avec les opérations sur les bits, et a comprendre comment cela fonctionne...

D'ailleurs une question, pourquoi n'est il pas besoin de passer par les opérations bit à bit pour additionner ou soustraire deux unsigned char?

Par la suite quand j'aurais bien compris ce procedé je chercherais a ramener le resultat sur n bits, ainsi mon flux d'entré n'aura pas changé du flux de depart, je parle au niveau taille et type (donc en unsigned char)

[Médinoc]

Je te conseille plutôt une autre route:
Pour soustraire un nombre non-signé de N bits, tu as besoin selon moi d'au moins N+1 bits, pour convertir ce nombre en nombre négatif et faire l'addition.

Donc, pour tes unsigned char (8 bits), tu dois utiliser au moins 9 bits. Le plus petit type d'au moins 9 bits étant short.

Donc, la suite d'actions

• conversion (implicite) des nombres en short.
• Négation du second nombre
• Addition

te donnera un résultat sur 16 bits dont tu peux récupérer les 9 bits de poids faible.
Le 9e bit t'indiquera si le résultat est négatif, en complément à deux.

[Melem]

Je fais donc la soustraction de mes unsigned char
Le résultat sera donc récupéré dans un short, entier signé.

Maintenant je souhaite ramener ce résultat à en entier non signé ...

Je commence à me demander si tu lis vraiment les réponses qu'on te donne.

11111111 c'est un 11111111! C'est ni 127, ni -1, ni blanc, ni ... c'est 11111111. Ca représente 127 si TU décides de l'interpréter comme un entier non signé, -1 si TU décides de l'interpréter comme un entier signé, ...

Code :

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

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
#include <string.h>
 
int main (void)
{
    short n = -1;
    unsigned short u = n;
    printf("n = %hd, m = %hu\n", n, u);
    return 0;
}

Poste ce que tu obtiens à l'écran (je veux m'assurer que tu ne jettes pas tout simplement à la poubelle nos messages).

Et les opérateurs de manipulation de bits, ça sert seulement à manipuler les données au niveau des bits, sans aucune interprétation quelconque ... comme je l'ai déjà dit dans un message plus haut que tu n'as pas lu.

[BatuBou]

C'est bien aimable a toi de te donner la peine de me répondre encore... Mais si tu perds patience de m'expliquer passe a une autre discussion.
J'ai dit si tu avais lu que je ne comprends rien, c'est donc pourquoi j'essaye de comprendre, désolé si je ne comprends pas aussi vite que toi.
Et j'ai autre chose de mieux à faire que de faire perdre le temps des gens qui essayent de m'expliquer.

Je décide d'interpréter mes unsigned char comme des unsigned char mais quand je fais une soustraction dessus si je continue a les traiter comme des unsigned char, ca va pas me donner le résultat estompé...

Dans un message précédent on m'a dit que le résultat allait dépasser de mon unsigned char, donc je dois bien les traiter autrement... je dois les considérer comme des short, et ensuite prendre les 9 premiers bits, faire le complément a deux de ceux qui sont négatif pour les remettre en non signe, car si je les considère en tant que unsigned char ca ne va pas marcher...
C'est comme les remettre sur n bits au lieu de n+1, j'ai beau les considérer comme des unsigned char, ca va pas donner le bon résultat...

J'ai fait ce que Médinoc m'a conseillé et j'ai l'impression que c'est le résultat que je souhaitais obtenir.

[Melem]

T’as l’air de ne pas comprendre en effet ou tu ne veux pas comprendre. Bon, on va revoir tout depuis le début (j’ai remarqué que t’aimes pas ça mais je trouve que c’est la seule solution), en prenant des exemples concrets.

Opérations
Tout d’abord, on va s’accorder qu’on utilisera les opérations + et – du langage C puisque si tes fonctions marchent bien, elles devraient retourner le même résultat que si on avait utilisé ces opérateurs.

Données
Soient a et b deux caractères non signés (unsigned char) avec a = 1 et b = 255.

On va supposer qu’un unsigned char est codé sur 8 bits. Désignons par U l’ensemble des valeurs représentables par un unsigned char. En énumération, on a donc U = {0, 1, 2, …, 255}.

On va également supposer qu’un int est codé sur 32 bits et que les entiers signés sont représentés selon la technique du complément à deux.

Nombres négatifs
Quel que soit x appartenant à U :

Code :

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

1
2
x + ~x =  11111111
x + ~x + 1 = 100000000

, mais le 1 constitue un bit de trop donc

Code :

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

x + ~x + 1 = 00000000

, et de ce fait :

Code :

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

~x + 1 = - x.

Addition
En langage C, a + b (a et b définis plus haut) soit 00000001 + 11111111 vaut

Code :

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

1
2
3
 00000000 00000000 00000000 00000001
+
 00000000 00000000 00000000 11111111

soit

Code :

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

 00000000 00000000 00000001 00000000

soit encore 256.

Maintenant, si tu affectes cette valeur dans un unsigned char, seuls les 8 premiers bits seront rangés (les 24 autres : 00000000 00000000 00000001 perdus) ce qui donne

Code :

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

00000000

soit 0.

Soustraction
En langage C, a – b soit 00000001 – 11111111 vaut

Code :

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

1
2
3
 00000000 00000000 00000000 00000001
–
 00000000 00000000 00000000 11111111

soit

Code :

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

1
2
3
 00000000 00000000 00000000 00000001
+
 11111111 11111111 11111111 00000001

ce qui vaut

Code :

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

 11111111 11111111 11111111 00000010

soit 4294967041.

Maintenant, si tu affectes cette valeur dans un unsigned char, seuls les 8 premiers bits seront rangés (les 24 autres : 11111111 11111111 11111111 perdus) ce qui donne

Code :

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

00000010

soit 2.

Conclusion
Tu peux faire toutes les manœuvres que tu veux mais du moment que tu ranges le résultat d’une opération entre de valeurs de 8 bits dans une valeur 8 bits, tu dois être conscient qu’il y a éventuellement eu des pertes de données. Donc toute cette histoire de 9ème bit et puis quoi encore : oublie. Par exemple, 00000001 + 11111111 = 00000000 : on n’en a rien à ciré du 9ème bit. Encore un autre exemple : 00000001 – 11111111 = 00000001 + 00000001 = 00000010 : où est-ce qu’on a eu besoin de 9ème bit ?

Je ne te dis pas d’abandonner ton implémentation d’un additionneur 8 bits à l’aide des opérateurs de manipulation de bits, je suis passé par là. Seulement que tu n’as qu’à te soucier des données, pas de leur signification (et je répète oublie ce 9 ème bit). Leur signification, ça ne dépend que de toi.

Test

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
	unsigned char a = 1, b = 255, c;
 
	c = a + b;
	printf("%u + %u = %u\n", (unsigned)a, (unsigned)b, (unsigned)c);
 
	c = a - b;
	printf("%u - %u = %u\n", (unsigned)a, (unsigned)b, (unsigned)c);
	return 0;
}

Remarque
Attention ! si b est un char et non un unsigned char, la conversion de b en int donnera 11111111 11111111 11111111 11111111 (propagation du bit de signe), mais cela ne change rien à la conclusion.

Propositions

Code :

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

1
2
3
4
uchar Bit(uchar x, int pos)
{
    return (x >> pos) & 1;
}

Pas besoin d'un int pour stocker un bit.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
uchar Add(uchar x, uchar y)
{
    /* calcule z = x + y */
 
    uchar bx, by, b, r = 0, z = 0;
    int i;
 
    for(i = 0; i < CHAR_BIT; i++)
    {
        bx = Bit(x, i);
        by = Bit(y, i);
 
        b = bx ^ by ^ r;
        r = (bx & by) | (bx & r) | (by & r);
 
        z |= b << i;
    }
 
    /* Au diable le 9eme bit */
 
    return z;
}

Ton calcul de la retenue me semble erroné (j'ai pas fait des tests), j'ai modifié.

Code :

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

1
2
3
4
uchar Sous(uchar x, uchar y)
{
    return Add(x, Add((uchar)~y, 1);
}

Si tu veux avoir tous les résultats en int ou unsingned int ... (disons int), alors utilise le type int au lieu de uchar dans tes fonctions (mais le programme passera des uchar à ces fonctions), que ce soit en argument ou en valeur de retour. Une fois que tu auras le résulat de l'opération (de deux uchar), qui est un int, fais ce que t'en veux.

[BatuBou]

Merci beaucoup !

La j'ai bien compris !!

Ca a mis du temps pour que ca rentre

Merci pour ta patience et pour le temps passé a m'expliquer !!!

Bonne soirée et merci beaucoup pour tes explications !!!

[Emmanuel Delahaye]

T’as l’air de ne pas comprendre en effet ou tu ne veux pas comprendre. Bon, on va revoir tout depuis le début (j’ai remarqué que t’aimes pas ça mais je trouve que c’est la seule solution), en prenant des exemples concrets.
<...>