Valeur negative qui sort des tenebres ?

Battosaiii · 12/03/2006, 22h33

En testant un bout de code je remarque qu'une valeur negative s'integre dans la variable S alors que C n'est JAMAIS negatif. Comment peut on obtenir des valeurs negatives de nulle part encore un mystere de l'informatique ... Toutefois si quelqu'un voit d'ou ca peut venir ....

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
39
40
41
42
double SimulationMux(double L)
{
	int k,T=8620,A,m=20,S,C;
	double MD;
	//printf("foo 2");
	//C stand for buffer occupancy
	//S= sum of the queue size
	int N=m*T;//simulation for an integer number of periods, i.e., mT time slots 
//for timeslot = 1 to infinity,there is 8620 timeslots every 5,875ms(packetization delay)
	for(k=0;k<N;k++)
	{	
		if(k==0) { C=0;}
	//	printf("kboucle1=%d ",k);
		//figure out how many of the sources generate an arrival NOW
		//this is the number of arriving cells - use the equation of evolution
		//to figure out the new buffer occupancy
		A=ArrivalFromSources(k,L);
		//printf("number of arrival = %d \n",A);
		C=BufferOccupancy(A,C);
		//printf("buffer occupancy = %d \n",C);
		//sum of the queue size :
		if(C<0) printf("C est negatif %d\n",C);
		S+=C;
//printf(" S=%d\n",S);
	}
//	if(S<0){S=-S;}
	//printf(" S=%d\n",S);
	//mean delay
	MD=Delay(S,N)+5.875;
	//printf("%lf",MD);
	return MD;
}
 
int BufferOccupancy(int A,int C)
{
	int Cf;
	Cf=C+A-1;
	if(Cf<0) Cf=0;
//printf("A=%d\n",A);
	return Cf;
 
}

A noter que la fonction Bufferoccupancy retourne TOUJOURS une valeur positif ou nul... incomprehensible je vous le dis ...

Invité(e) · 13/03/2006, 00h01

Bonsoir
Un somme de int tous positifs peut devenir négative si la limite supérieure des int est dépassée...
Cette valeur est d'environ 2 millard en 32 bit, 32768 (ou 32767 peut etre...)en 16 bit.
un test simple :

Code :

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

1
2
3
4
5
6
7
short int i; //sur 16 bit sur un x86
i = 32768; // (ou 32767 ?)
if(i>0)
    printf("i est positif\n");
++i;
if(i<0)
    printf("i est négatif !\n");

pour résoudre le problème, il suffit peut etre d'utiliser un type plus grand (sur 64 bit) et/ou de n'utiliser que des types positifs (unsigned int i)
si cela ne suffit toujours pas, il faut alors surveiller la cohérence du résultat de chaque opération...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
int a,b,c;
// ..
a = b+c;
if((a - b) == c) // bien remarquer comment est posée la comparaison
                 // le principe est d'inverser l'opération pour obtenir une des 
                 // opérandes initiales, il ne faudra pas tester (a == (b+c))
                 // qui sera forcement vrai puisse que c'est comme ca qu'on a 
                 // obtenu a.
   printf("ok\n");
else
    printf("erreur\");

J'espere etre clair

bonne nuit et bon courage

mabu

**Emmanuel Delahaye** · 13/03/2006, 08h22

Envoyé par Battosaiii

En testant un bout de code je remarque qu'une valeur negative s'integre dans la variable S alors que C n'est JAMAIS negatif. Comment peut on obtenir des valeurs negatives de nulle part encore un mystere de l'informatique ... Toutefois si quelqu'un voit d'ou ca peut venir

Il n'y a aucun mystère. Il faut savoir que le langage C supporte 3 modes de représentation des nombres négatifs

signe + magnitude
complément à 1
complément à 2

Détails ici :

http://mdbui2.ift.ulaval.ca/Knowledges/Coding_Number/Nombres_negatifs.htm

Dans le cas du complément à 2 (le plus courant) lorsqu'on atteint la limite supérieure (INT_MAX, dans le cas d'un int, par exemple), la valeur suivante correspond à la représentation d'un nombre négatif (en l'occurence, INT_MIN).

Supposons que INT_MAX vaille 0x7FFF (32767). Si on fait +1, on obtient 0x8000 qui est la représentation de -32768 dans un mot de 16-bit.

Si tu ne veux pas de valeurs négatives, il faut utiliser des entiers non signés (unsigned).

Battosaiii · 13/03/2006, 19h02

est ce que mettre
long int a;
au lieu de int a;
pour TOUTES mes variables int rsoudrait l'affaire ?
Quelles solutions SIMPLES apportes aux problemes. je remercie de vos explications, neanmois je vais chercher a faire face a ce probleme ...

Ou bien dois je passer au double ? je sais que c'est sur 32 bits . Des idees simples ?

**Médinoc** · 13/03/2006, 19h08

Sur un compilateur 32bits, un long et un int sont toujours sur 32bits.
Sur un compilatuer 16bits, un long fait généralement 32bits et un int 16 bits, donc ça t'aurai arrangé en augmentant la taille.

À présent, pour augmenter la taille, tu dois utiliser un entier 64 bits.
Pour cela,

sous visual 6, tu as le type __int64,
sous VS2005 et sous un compilo standard, tu as le type long long.

Battosaiii · 13/03/2006, 21h25

merci de ton aide, sans t'offenser je ne connais aucun de ces compilateurs. Moi j'utilise gcc avec cygwin sous windows.
Quelle est d'apres toi le bon type ?

**Médinoc** · 13/03/2006, 22h13

long long : GCC est un compilo plutôt respectueux des standards.
Mais sous cygwin, __int64 marche peut-être aussi (mais je le déconseille).

**gangsoleil** · 14/03/2006, 13h50

Envoyé par Battosaiii

est ce que mettre
long int a;
au lieu de int a;
pour TOUTES mes variables int rsoudrait l'affaire ?
Quelles solutions SIMPLES apportes aux problemes. je remercie de vos explications, neanmois je vais chercher a faire face a ce probleme ...

Ou bien dois je passer au double ? je sais que c'est sur 32 bits . Des idees simples ?

Passer du type int au type long int ne va faire que déplacer ton problème.

Je ne comprends pas pourquoi tu ne veux pas utiliser des unsigned int (ou unsigned long int si tu y tiens), comme proposé par Emmanuel ?

Sinon, une autre solution est de vérifier que tu n'as pas dépassement de capacité...

**Médinoc** · 14/03/2006, 14h02

Le coup du unsigned ne résoudra pas le problème, et pire, il le cachera: Au moins, avoir la valeur négative permet de SAVOIR qu'on a eu un dépassement de capacité...

**gangsoleil** · 14/03/2006, 16h11

Envoyé par Médinoc

Le coup du unsigned ne résoudra pas le problème, et pire, il le cachera: Au moins, avoir la valeur négative permet de SAVOIR qu'on a eu un dépassement de capacité...

Le fait d'avoir un dépassement de capacité est avant tout un problème d'algorithmique.

Si tu as une valeur qui ne peut dépasser INT_MAX, alors un entier suffit.

En revanche, si tu sais que ta valeur peut dépasser la INT_MAX, alors il convient de prendre des précautions. L'une de celles-ci peut être d'utililser des entiers non-signés, à condition d'être certain que ta valeur ne dépassera pas UINT_MAX.

Si tu sais que ta valeur est succeptible de dépasser UINT_MAX, alors c'est au programmeur de s'arranger pour effectuer les vérifications nécessaires pour ne pas avoir de dépassement de capacités. Cela peut se faire de différentes facon (utiliser les entiers longs, éventuellement non signés, ou bien passer sur des réels, avec esl autres problèmes que cela peut apporter), mais dans tous les cas il faut savoir ce que fait le programme pour l'écrire correctement.

Valeur negative qui sort des tenebres ?

C

Discussions similaires

Partager

Partager