Exception de première chance : stack overflow

Version imprimable

Bonjour,

j'ai un petit souci avec mon code, mais c'est pas étonnant, je ne suis pas très doué. Si quelqu'un pouvait me trouver l'erreur vite fait, je pense pas que cela soit trop dur. Je vous fournit ce qui cloche.. Alors dans le main un moment j'ai
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 double *X, *Y, *Z; X = new double[nX]; Y = new double[nY]; Z = new double[nZ]; double ****mat; mat = (double ****) malloc(sizeof(double)*10); for(int i=0; i<10; i++){ mat[i] = new double** [nX]; for(int j=0; j<nX; j++) { mat[i][j] = new double* [nY]; for(int k=0; k<nY ; k++) mat[i][j][k] = new double[nZ]; } } double ***Spe; Spe = new double** [N]; for(i=0; i<N; i++) { Spe[i] = new double* [4]; for(j=0; j<4 ; j++) Spe[i][j] = new double[w[i]]; } double **Pos; Pos = new double* [N]; for(i=0; i<N; i++) Pos[i] = new double[3]; for(int t=1; t<11; t++){ cout << "Calculs à t="<< t << endl; P2bm3dml(mat[t-1],X,Y,Z,N,Pos,Spe,t,d,h,v); }
L'exception au débuggage m'est indiqué a la ligne ou j'apelle la fonction P2bm3dml. (t,d,h et v sont des doubles)

Maintenant je vous mets le prototype de la fonction

void P2bm3dml(double ***mat, double *x, double *y, double *z, int N, double **p, double ***s, double t, double d, double h, double v);

Y'a t-il déjà quelquechose qui cloque à ce niveau là ?

Merci d'avance

02/02/2011, 16h06
cob59

:vomi:

Si le debugger indique la ligne où P2bm3dml est appelée, l'erreur est probablement située dans cette fonction-là.
02/02/2011, 16h17
Emmanuel Deloget

Mince, cob, m'ai trompé de bouton. Désolé :oops:

Sinon, Far_Away, c'est du C, pas du C++. En C++, ça donne quelque chose qui est encore moins lisible donc je vais te l'épargner. double ****mat, c'est l'une de mes recettes préférée pour provoquer un plantage quelconque.
02/02/2011, 16h22
r0d

Citation:

Envoyé par Emmanuel Deloget

En C++, ça donne quelque chose qui est encore moins lisible donc je vais te l'épargner.

Je ne suis pas d'accord. Par exemple si on passe par une classe matrice, le code résultant serait plus explicite. Il y aurait certes plus de lignes de code, ne serait-ce qu'avec l'implémentation de la classe matrice, mais je pense que ce serait au contraire nettement plus lisible.
D'ailleurs, en restant en C, je pense qu'il serait mieux de passer par une structure que de balancer directement du pointeur de pointeur de pointeur.
02/02/2011, 16h44
Far_Away

Merci, oui en effet, c'est du C... je dis du C++ car j'ai mixé les deux, notamment le reste du programme fait appel a bcp de C++.
Les pointeurs *4 c'était pour m'éviter d'utiliser des classes vector ou matrix de boost.... Fénéantise pure et simple.

Maintenant oui, l'erreur est bien dans la fonction P2bm3d car en passant tout en commentaire à l'intérieur et en mettant un simple cout, tout va pour le mieux..

Donc ceci m'amène à une question en fait voilà ce que j'ai à faire grossièrement.

le triple pointeur passé en 1er argument à la fonction P2bm3d est passé pour être rempli par cette fonction.
En gros à la fin de P2bm3D je fais

for(int i=0; i<nX; i++)
for(int j=0; j<nY; j++)
for(int k=0; k<nZ; k++)
mat[i][j][k] = P1[i][j][k] - SUM[i][j][k];

ou P1 et SUM sont définis dans P2bm3D.

Maintenant au début de P2bm3D je créée encore un quadruple pointeur
double ****m = NULL;
m = (double ****) malloc(sizeof(double)*N);
for(int i=0; i<N; i++)
{
m[i] = new double** [nX];
for(int j=0; j<nX; j++)
{
m[i][j] = new double* [nY];
for(int k=0; k<nY; k++)
m[i][j][k] = new double[nZ];
}
}

Et là rebelotte, je dois passer mes triples pointeurs m[i] cela a une fonction Sat3d et qui prend en argumemt en triple pointeur pour qu'elle me remplissent mon m car pour calculer P1 j'ai besoin de ce m.

Procèderiez de cette façon ?
J'ai beau mettre un breakpoint des l'entree dans P2bm3d, il bloque avant.. je ne comprends plus rien comme si l'erreur ne venait pas du corps de la fonction... et pourtant comme dis pus haut en passant tout en com, ca roule.

Autre précision ce code marche avec Xcode sur mac, là c'est sur visual c++ qu'il me sort cela. Voilà
02/02/2011, 16h50
Far_Away

Et je reviens tout de suite car je suis trop bête je pense, voila mes premières déclarations dans la fonction P2bm3d

double MT[nX][nY][nZ], P1[nX][nY][nZ], P2[nX][nY][nZ], SUM[nX][nY][nZ];
for(int i=0; i<nX; i++)
for(int j=0; j<nY; j++)
for(int k=0; k<nZ; k++){
MT[i][j][k] = 1;
P1[i][j][k] = 0;
P2[i][j][k] = 0;
SUM[i][j][k] = 0;
}

Ca serait la source d'erreur, pourtant le compilo ne gueule pas, et tout cela s'éxécute sur d'autres soft de développement.

Comment régler le problème, cette déclaration n'est donc pas bonne ?
02/02/2011, 17h13
Far_Away

Donc oui problème solved...
Arf jsuis bidon :=)
02/02/2011, 17h46
cob59
Quelques remarques là-dessus :
Code:

1 2 double ****m = NULL; m = (double ****) malloc(sizeof(double)*N);
1) Les malloc n'ont d'intérêt qu'en C. Le C++ propose les opérateurs new et delete pour allouer dynamiquement des objets ou des tableaux.

2) Ici, malloc va allouer un espace mémoire de taille équivalente à N éléments de type double alors que alors qu'il est censé contenir N éléments de type double***. Si les pointeurs n'avaient pas une taille inférieure à celle du type double, ton code aurait déjà planté.

3) Ici comme ailleurs, as-tu vraiment besoin d'une alloc dynamique ? Est que ça ne serait pas plus simple :

Code:

double*** m[N];

Comme le dit r0d, il serait plus judicieux de déclarer quelques types (matrix, vector, etc) éclaircir ton code et t'éviter de jongler avec des pointeurs.

Citation:

Envoyé par r0d

Je ne suis pas d'accord. Par exemple si on passe par une classe matrice, le code résultant serait plus explicite. Il y aurait certes plus de lignes de code, ne serait-ce qu'avec l'implémentation de la classe matrice, mais je pense que ce serait au contraire nettement plus lisible.
D'ailleurs, en restant en C, je pense qu'il serait mieux de passer par une structure que de balancer directement du pointeur de pointeur de pointeur.

Vrai, mais le code de la classe matrice, lui, serait assez indigeste - matrice à N dimensions, (N variable, bien sûr), etc. rien que de penser à la multiplication de matrices NxM de type T, ou T1 = matrice KxP du type T2 (c'est à dire dont les valeurs sont elles même des matrices) ça me donne mal à la tête :)

Quoi que.

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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
 
#ifndef ndim_matrix_h
#define ndim_matrix_h
 
#include <cstddef>
#include <stdexcept>
#include <ostream>
#include <iomanip>
 
namespace math
{
 
	// similar is not exactly the same as std::array<>
	// but std::array<> is C++0x, and the TR1 version may
	// not be present as well. Sad but true. 
	// TAKE CARE : Dim = 0 is going to do some "fun stuff". 
	template <class Type, unsigned int Dim>
	struct vector
	{
		static const unsigned int dimension = Dim;
		typedef Type value_type;
		typedef value_type* iterator;
		typedef const value_type* const_iterator;
		typedef value_type& reference;
		typedef const value_type& const_reference;
 
		// EXPOSITION ONLY
		// you shall not use that; however, C++98 mandates this to enable the 
		// use of the C-style array initializer list (a.k.a. brace initializer list,
		// in the form { ... })
		value_type m_values[dimension]; 
 
		// no constructor (or the type is not an aggregate type anymore)
		// no destructor (same reason)
 
		iterator 		begin() { return m_values[0]; }
		iterator 		end() { return m_values[dimension]; }
		const_iterator 	begin() const { return m_values[0]; }
		const_iterator 	end() const { return m_values[dimension]; }
 
		// no real need for the reverse iterators, so let's forget those
 
		reference		front() { return m_values[0]; }
		reference		back() { return m_values[dimension-1]; }
		const_reference	front() const { return m_values[0]; }
		const_reference	back() const { return m_values[dimension-1]; }
 
		reference		operator[](std::size_t index) { return m_values[index]; }
		const_reference operator[](std::size_t index) const { return m_values[index]; }
 
		reference		at(std::size_t index)
		{ 
			if (index > dimension) throw std::out_of_range();
			return m_values[index]; 
		}
		const_reference at(std::size_t index) const
		{ 
			if (index > dimension) throw std::out_of_range();
			return m_values[index]; 
		}
 
		std::size_t size() const { return dimension; }
 
		value_type*	data() { return &m_values[0]; }
		const value_type* data() const { return &m_values[0]; }
 
		vector& operator+=(const vector& other)
		{
			for (std::size_t i=0; i<dimension; ++i)
			{
				m_values[i] += other.m_values[i];
			}
			return *this;
		}
 
		vector& operator*=(const vector& b)
		{
			vector a(*this);
			for (std::size_t i=0; i<dimension; ++i)
			{
				std::size_t si = (i + 1) % dimension;
				std::size_t ssi = (i + 2) % dimension;
				m_values[i] = a[si] * b[ssi] - a[ssi] * b[si];
			}
			return *this;
		}
 
		void swap(vector& other)
		{
			for (std::size_t i=0; i<dimension; ++i)
			{ std::swap(m_values[i], other.m_values[i]); }
		}
	};
 
	template <class Type, unsigned int Dim>
		vector<Type, Dim>
			operator*(
				const vector<Type,Dim>& first,
				const vector<Type,Dim>& second)
	{
		vector<Type, Dim> r = first;
 
		return r.operator*=(second);
	}
 
	template <class Type, unsigned int Dim>
		vector<Type, Dim>
			operator+(
				const vector<Type,Dim>& first,
				const vector<Type,Dim>& second)
	{
		vector<Type, Dim> r = first;
 
		return r.operator+=(second);
	}
 
	// make that an aggregate type too, just for fun!
	// Dim1 lines of Dim2 columns
	template <class Type, unsigned int Dim1, unsigned int Dim2>
	struct matrix
	{
		static const unsigned int dimension_x = Dim1;
		static const unsigned int dimension_y = Dim2;
		typedef Type value_type;
 
		typedef vector<vector<value_type, dimension_y>, dimension_x> matrix_type;
		typedef vector<value_type, dimension_y> column_type;
 
		matrix_type m_mat;
 
		std::size_t columns() const
		{ return m_mat[0].size(); }
 
		std::size_t lines() const
		{ return m_mat.size(); }
 
		column_type& operator[](std::size_t index)
		{ return m_mat[index]; }
 
		const column_type&operator[](std::size_t index) const
		{ return m_mat[index]; }
	};
 
	// [NxM] * [MxK] ==> [NxK]
	template <class Type, unsigned int Dim1, unsigned int Dim2, unsigned int DimCom>
		matrix<Type, Dim1, Dim2> 
			operator*(
				const matrix<Type,Dim1,DimCom>& first, 
				const matrix<Type,DimCom,Dim2>& second)
	{
		typedef matrix<Type, Dim1, Dim2> result_type;
		typedef typename result_type::value_type value_type;
 
		matrix<Type, Dim1, Dim2> r = result_type();
 
		for (std::size_t i=0; i<r.lines(); ++i)
		{
			for (std::size_t j=0; j<r.columns(); ++j)
			{
				r[i][j] = value_type();
 
				for (std::size_t k=0; k<DimCom; ++k)
				{
					r[i][j] += first[i][k] * second[k][j];
				}
			}
		}
 
		return r;
	}
 
	// you want to play with theses?
	// how about these: 
	//   matrix<vector<float, A>, B, C>
	//   matrix<matrix<float, A, B>, C, D>
	// and so on, recursively...
 
	template <class Type, unsigned int Dim>
	std::ostream& operator<<(std::ostream& o, const vector<Type,Dim>& v)
	{
		o << "[ ";
		for (std::size_t i=0; i < v.size(); ++i)
		{
			o << std::setw(5) << v[i] << " ";
		}
		o << "] ";
		return o;
	}
 
	template <class Type, unsigned int Dim1, unsigned int Dim2>
	std::ostream& operator<<(std::ostream& o, const matrix<Type,Dim1,Dim2>& m)
	{
		for (std::size_t i=0; i < m.lines(); ++i)
		{
			o << "[ ";
			for (std::size_t j=0; j<m.columns(); ++j)
			{
				o << std::setw(5) << m[i][j] << " ";
			}
			o << "]" << std::endl;
		}
		return o;
	}
 
}
 
#endif // ndim_matrix_h

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
 
#include "ndim_matrix.h"
#include <iostream>
 
int main()
{
	math::vector<float, 3> v = { 0, 1, 2 };
	math::matrix<float, 4, 4> m = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5 };	
 
	math::matrix<float,3,4> a = 
		{
			1, 0, 0, 1, 
			1, 1, 0, 0, 
			1, 1, 1, 1,
		};
 
	math::matrix<float,4,2> b =
		{
			1, 0, 
			0, 1, 
			0, 1, 
			1, 0
		};
 
	std::cout << "a = " << std::endl << a << std::endl;
	std::cout << "b = " << std::endl << b << std::endl;
 
	math::matrix<float,3,2> c = a * b;
 
	std::cout << "c = " << std::endl << c << std::endl << std::endl;
 
	math::vector<int, 3> init1 = { 1, 0, 0 };
	math::vector<int, 3> init2 = { 0, 1, 0 };
 
	math::matrix<math::vector<int, 3>, 3, 3> wow1 = { init1, init1, init1, init1, init1, init1, init1, init1, init1 };
	math::matrix<math::vector<int, 3>, 3, 3> wow2 = { init2, init2, init2, init2, init2, init2, init2, init2, init2 };
 
	std::cout << "wow1 = " << std::endl << wow1 << std::endl;
	std::cout << "wow2 = " << std::endl << wow2 << std::endl;
	std::cout << "wow1 x wow2 = " << std::endl << (wow1 * wow2) << std::endl;
 
	std::cout << "sizeof(wow1) = " << sizeof(wow1) << std::endl;
}

On doit pouvoir faire des matrices de matrices de matrices de vecteurs. Et exploser la pile au passage...

02/02/2011, 20h22
Far_Away

Pour répondre à Cob59, je ne peux pas faire l'allocation que tu dis, N étant passé en paramètre :( il n'est connu qu'à l'exec, sinon évidemment tout aurait plus simple.
Mais il est vrai que mon code n'est pas propre... D'ailleurs chose étrange, une fois le problème réglé, j'ai exécuté mon programme et la... mon résultat est totalement faux... pourtant rien dans le code n'est changé mis a part ce que je viens de vous dire.. et le code d'avant me donne un résultat correct.. il y aurait donc de grosses grosses, d'énormes problèmes au niveau des accès mémoires avec ce code sur Visual.