Discussion :

[Atharendil]

Bonjour,

dans mon programme j'ai deux classes template dans lesquelles les allocations mémoires sont générées dynamiquement :
Sc_DynamicVector<T> qui possède un T* array en attribut et Sc_DynamicMatrix<T> avec un attribut Sc_DynamicVector<T>* matrix.

Le bug survient à l'exécution (plantage de la console) quand j'essaie d'allouer un tableau de Sc_DynamicVector<T> afin de le passer au constructeur de Sc_DynamicMatrix<T>.

Voilà le code :

Code :

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

1
2
3
4
5
6
7
8
9
 
double tabtest[6]={10,9,8,7,6,1};
double tabtest2[6]={3,3,4,4,5,5};
Sc_DynamicVector<double> *v1=new Sc_DynamicVector<double>(6, tabtest);
Sc_DynamicVector<double> *v2=new Sc_DynamicVector<double>(6, tabtest2);
 
Sc_DynamicVector<double> *tabVect = new Sc_DynamicVector<double>[3];
tabVect[0]=*v1; tabVect[1]=*v1; tabVect[2]=*v1; 
Sc_DynamicMatrix<double> m1, m2(3, tabVect);

C'est seulement quand je décommente la partie tabVect[1]=*v1; tabVect[2]=*v1; que le programme plante.
Si je n'alloue pas dynamiquement le tableau de Sc_DynamicVector<double>, c'est à la déclaration de m2 que ça plante.

Et le code des constructeurs (car le problème vient peut-etre aussi de là ) :

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
 
template <class T>
Sc_DynamicVector<T>::Sc_DynamicVector(unsigned int _size, T* _array)
{
	size=_size;
 
	array=new T[size];
	for(unsigned int i=0; i<size;i++){
		array[i]=_array[i];
	}
}
 
template <class T>
Sc_DynamicMatrix<T>::Sc_DynamicMatrix()
{
	size=1;
 
	mat=new Sc_DynamicVector<T>[size];
	mat[0]=Sc_DynamicVector<T>();
}
 
template <class T>
Sc_DynamicMatrix<T>::Sc_DynamicMatrix(unsigned int _size, Sc_DynamicVector<T> * _mat)
{
	size=_size;
 
	mat=new Sc_DynamicVector<T>[size];
	for(unsigned int i=0;i<size;i++){
		mat[i]=Sc_DynamicVector<T>(_mat[i]);
	}
}

Si quelqu'un saurait me sortir de cette impasse (assez prise de tête quand même )...

[Mat007]

Salut,

A quoi ressemble l'opérateur = de Sc_DynamicVector ?

MAT.

[Atharendil]

Salut,

le code pour l'opérateur est écrit de façon assez classique, rien de spécial :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
template <class T>
Sc_DynamicVector<T> Sc_DynamicVector<T>::operator =(Sc_DynamicVector<T> v)
{
	if(&v != this)
	{
		size=v.size;
		for(unsigned int i=0;i<size;i++){
			array[i]=v.array[i];
		}
	}
	return *this;
}

Même en mettant des breakpoints partout, impossible de localiser la cause de l'erreur, car le programme plante après avoir passé tous les breakpoints... Je suis déséspéré

[Mat007]

Oui enfin de façon classique c'est vite dit, en général on utilise plutôt un temporaire pour se servir du constructeur par copie (voir par ex GotW59 ).

Sinon là dans ton opérateur d'affectation tu écrases allègrement array sans désallouer le précédent, et surtout sans le réallouer.
Du coup quand tu crées ton tableau tabVect ça initialise avec des Sc_DynamicVector construit en appelant le constructeur par défaut, donc avec une taille de 1.
Ensuite tu leur affectes v1 et v2, qui ont une taille de 6, en appelant l'opérateur d'affectation, et ça part en sucette pour les i >= 1...

MAT.

[Atharendil]

Merci Mat, je vais essayer ça, tu dois surement avoir raison.

En fait, je ne suis pas très à l'aise en C++ (dans lequel je viens de débuter) et pas encore assez avec les pointeurs.

Si je comprends bien, avant la boucle for, je dois faire :

Code :

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

1
2
3
 
delete[] array;
array=new T[size];

Si c'est bien ça, je te dois une fière chandelle , car tu me sors d'une méchante impasse sur laquelle je bloquait depuis quelques heures déjà .

[Atharendil]

J'ai testé et ça marche

Du coup, je n'ai plus qu'à modifier toutes les fois où j'ai fait la même erreur dans d'autres classes ^^

Encore un grand merci à toi !

[Mat007]

Sinon pour éviter ce (léger) casse-tête de jongler avec les allocations tu peux utiliser un std::vector à la place d'un tableau, c'est en fait la méthode préconisée en C++.
C'est bien pratique, ça vaut le coup de se plonger dans un tutoriel sur les vecteurs de la STL.

On utilise finalement très rarement les tableaux en C++.

MAT.