vector::size() retourne une valeur négative

Version imprimable

Bonjour à tous ,
j'espère que vous allez m'aider .
en fait,je trouve un résultat bizarre : taille du vecteur négative 8O !!
mon code est trop long donc j'essaierai de citer l'essentiel .
j'ai une structure , dans laquelle je définit un vecteur

Code:

1
2
3
4
5
6
7
8
struct mon_pkt {
	...
	std::vector<nsaddr_t> ma_list_;
        ...
	inline	 int taile() {
	 		return ma_list_.size() ;
	}
};

ensuite, j'utilise cette structure , je crée une variable ph de type mon_pkt
aprés je stocke les tailles des vecteurs dans une file appelée window

Code:

window.Enfiler(ph->taille());

puis, j'utilise les valeurs stockées dans la file :

Code:

1
2
3
4
5
for(int i=0;i<y;i++) //y nombre d'éléments dans la file window
			 {
				r = window.get_element(i);
				 printf( " size = %d  \n ", r );
                         }

voici ce que j'obtient :

Code:

1
2
3
4
size = -1219271720  
size = 16  
size = 41  
size = 58

le premier vecteur de taille -1219271720 8O !!!!!!!
je sais pas d'ou vient cette valeur :koi:
A propos la classe File , voici le code :

Code:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
// Fichier File.cpp
// Définitions des fonctions membres de la classe File
#include <cassert>
#include <iostream>
#include <stdio.h>
#include "File.h"
	File::File ( int taille )
	// Constructeur
		{
		window = new int [taille];
		}
	//File::~File ()
	//	{
	//	delete[] window;
	//	}
		// destructeur
	void File::ViderFile ()
		{
		for(int i=0;i<taille;i++)
			{
				window[i]=0;
			}
		}
	void File::Enfiler ( const int & element )
		{
			if ( FilePleine())
				int x = Defiler();
			int indice = dernier_indice();
			window[indice] = element;
 
		}
	int File::Defiler ()
		{
			//if ( FileVide() )
				//printf("erreur la file vide");
			int x = window[0];
			Decaler_tableau();
			return x ;
 
		}
	int File::PremierElement () const
		{
			if ( FileVide() ) 
				printf("erreur la file vide");
			return window[0];
		}
	bool File::FileVide () const
		{
			int nbre_element = 0 ;
			for (int i=0;i<taille;i++)
				if (window[i]==0)
				{
					nbre_element ++;
				}
			if (nbre_element == taille )
				return 1;
			else 
				return 0;
		}
	bool File::FilePleine () const
	 	{
		int nbre_element = 0 ;
			for (int i=0;i<taille;i++)
				if (window[i]!=0)
				{
					nbre_element ++;
				}
			if (nbre_element == taille )
				return 1;
			else 
				return 0;
		}
	int File::get_element(int position)
		{
			return window[position];
		}
	int File::dernier_indice()
		{
			for (int i=0;i<taille;i++)
				if (window[i]==0)
				{
					return i;
					break;
				}
		}
	void File::Decaler_tableau()
		{	
			for (int i=1;i<taille;i++)
				window[i-1]=window[i];
		}
	File File::copie_file()
		{
 
			File copie = File(taille);
			int i=0 ;
			for  (int i=0;i<taille;i++)
			{
				copie.Enfiler(window[i]);
			}
			return copie;
		}

merci d'avance pour l'aide :)

08/06/2011, 16h36
jblecanard

Hello !

Qu'est ce que ça donne si tu stockes les tailles avec le type unsigned int plutôt que int ? Ca ressemble à s'y méprendre à un dépassement.
08/06/2011, 16h37
pyros
Salut,

Dans ton constructeur, attention, window = new int [taille]; alloue la mémoire mais ne l'initialise pas à 0. Tu peux rajouter des parenthèses pour initialiser tes valeurs à 0 (ou faire un memset, ou boucler et mettre tes valeurs une par une)
Code:

1 2 window = new int [taille]();
Pour moi, voici ce qu'il se passe:
Tu cré ta file, le tableau windows contient un peu n'importe quoi (car non initialisé).
Lorsque tu enfile ton premier élément, la fonction dernier_indice() ne renvois pas 0 comme attendu, mais 1, car windows[0] ne vaux pas 0 mais n'importe quoi. Mais, coup de bol, la 2ème case de window vaut 0.
Donc, ton 1er élément est en fait ajouté à la 2ème case de ton tableau window, et tu a donc n'importe quoi dans ta 1ère case.

Petite remarque: s'il s'agit d'un exercice du type "implémenté à la main une file", bon courage :ccool:
S'il s'agit d'un dev quelconque, utilise un std::queue qui est déjà une file toute faite, ou au pire, utilise un std::vecteur au lieu d'un new int[] :)
08/06/2011, 16h39
jblecanard

Bien vu Pyros, la non initialisation est plus sûrement source du problème qu'un dépassement !

oui , j'ai fait l'initialisation , maintenant j'obtient :
Code:

1 2 3 4 5 6 7 saut = 159875144 saut = 161921000 saut = 25 saut = -1220049952 saut = -1220049952 saut = 1074234847 saut = 6648949
même les valeurs positives trop grandes ne sont pas logiques dans mon cas !

08/06/2011, 17h11
pyros

Ajoute un printf("%d\n", indice); dans ta fonction enfiler pour vérifier que tes indices sont bien ok, ou en utilisant un debuggeur, ça serait encore mieux :)
08/06/2011, 17h27
MounaR

toujours indice = 0
08/06/2011, 17h38
pyros

et element il vaut quoi juste avant de faire window[indice] = element ? (toujours dans la fonction enfiler)
08/06/2011, 17h40
MounaR

toujours element = 0
08/06/2011, 17h42
kessoufi
sur les autres fonctions il me semble que taille est une variable membre de File , or elle n'est pas initialisée dans :
Code:

1 2 3 4 5 6 File::File ( int taille ) // Constructeur { window = new int [taille]; }
si c'est le cas ajoute ceci :
Code:

1 2 this->taille = taille;
au constructeur

Cdt

toujours le même résultat :

Code:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0
 indice  0
 element  0

08/06/2011, 17h59
pyros

Ah bah oui, si tu lui spécifie 0 comme élément, ta fonction dernier_indice reverra toujours 0 ^^

Revois un peu le fonctionnement de ta file en stockant le dernier indice et en l'incrémentant à chaque fois que tu ajoute un élément.

Ou alors si tu veux faire rapide (et crade ;)), initialise ton tableau avec des -1 et ré-implémente tes fonction pour qu'elles comptent le nombre de -1 au lieu du nombre de 0, et soit sûr de ne jamais mettre de valeur < 0 dans ta file !
08/06/2011, 18h15
MounaR

justement , mais element ne doit pas être égal à 0 . normalment element = ph->taille() qui retourne la taille du vecteur ph , ce qui est sur c'est que les vecteurs ne sont pas vides donc size() retourne nécessairement une valeur différente de 0 !!
09/06/2011, 09h24
pyros

Ben, si element vaut zéros, c'est que ma_list_.size() vaut zéros dans la fonction mon_pkt.taille() (vérifie au cas ou, mais si tu fait directement window.Enfiler(ph->taille()); c'est que ma_list est bien vide à ce moment là).

Comme les std::vector ne sont pas buggés (sisi, je te promet :mouarf:), c'est que tu dois avoir un problème ailleur, peut être dans ta classe mon_pkt.
09/06/2011, 11h16
3DArchi

Bonjour,
Outre les erreurs d'initialisation mentionnées par mes camarades précédemment, il reste encore (au moins) une erreur. Un indice, elle est dans : File:: Decaler_tableau.

Pour anticiper tes erreurs :
1/ Pour la classe File écrit les propriétés de taille et window qui doivent rester valides dès la construction de l'objet et jusqu'à sa destruction. Ce sont ses invariants.
2/ Pour chaque fonction de File, écris quelles sont les propriétés (sur taille et sur window) qui doivent être vérifiées pour que la fonction s'exécute correctement, les hypothèses que tu as faites pour écrire la fonction. Ce sont les préconditions de ta fonction.
3/ Pour chaque fonction de File, écris quelles sont les propriétés (sur taille et sur window) que la fonction s'engage à assurer en sortie, i.e. ce que tu attends de cette fonction. Ce sont les postconditions de ta fonction.

Ensuite :
Vérifie que chaque fonction qui en appelle une autre assure bien les préconditions de la fonction appelée
Vérifie que chaque fonction assure bien ses postconditions en sortie
Vérifie que les invariants sont bien rétablis en sortie de fonction publique.
=> Tu auras déjà une vérification 'formelle' de la validité de ton code.

La main à la pate : UTFD (adapation libre pour Use The Fucking Debugger)

Dans la série bonne pratique : as-tu jamais entendu parler de tests unitaires ?

Question à 10 balles : pourquoi tu as supprimé le destructeur de File ? Je suis près à parier que la réponse est dans la F.A.Q ou dans le tutoriel de Loïc :D
10/06/2011, 15h53
MounaR

je trouve pas logique que le size = 0 alors que lorsque j'affiche le contenu de vecteur , il m'affiche des bonnes valeurs !! ! :cry:

Code:

1
2
3
4
5
6
7
void File::Decaler_tableau()
		{	
			for (int i=1;i<taille;i++)
				window[i-1]=window[i];
 
window[taille-1] = 0;
		}