Discussion :

[vbaddict44]

Bonjour,

Je suis entrain de développer un programme c++ et une erreure fait planter le programme, bien que la compilation se déroule bien.

j'ai un vector de pointeur:

Code :

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

1
2
 
std::vector<Structure*> m_collec;

et je veut y ajouter des éléments pour cela je fait :

Code :

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

1
2
3
 
Structure* w1 = new WeatherDeck(...);
m_collec.push_back(w1);

sachant que WeatherDeck hérite de Structure.

le programme plante a cause du push_back mais je ne comprend pas pourquoi ?

la console me dit DOS :

Code :

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

1
2
3
4
5
6
 
This*application*has*requested*the*Runtime*to*terminate*it*in*an*unusual*way.
Please*contact*the*application's*support*team*for*more*information.
 
Process*returned*3*(0x3)***execution*time*:*0.171*s
Press*any*key*to*continue.

[mitkl]

Ça risque d'être compliqué avec aussi peu d'informations, sous quel environnement travailles-tu (IDE, etc) ? Des outils comme des debuggers peuvent t'aider, à la fin de Structure* w1 = new WeatherDeck(...); regarde notamment si son contenu est correct pour voir s'il n'y a pas un problème de mémoire dans ton programme, c'est pas dit que le problème vienne directement de std::vector::push_back(), il y a peut-être du code qui corrompt la stack avant dans l'ordre d'execution. Ce n'est qu'une supposition mais si c'est le cas un debugger sera bien utile. :p

[vbaddict44]

Bonjour,

j'utilise Code::Blocks sous windows xp pro la pile d'appel me dit :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#0 00000000	0x00503a4c in __cxa_throw() (??:??)
#1 00000000	0x00504a61 in operator new() (??:??)
#2 005277CA	__gnu_cxx::new_allocator<Structure*>::allocate(this=0x22eae4, __n=1073741823) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/ext/new_allocator.h:89)
#3 0055BE12	std::_Vector_base<Structure*, std::allocator<Structure*> >::_M_allocate(this=0x22eae4, __n=1073741823) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_vector.h:140)
#4 0057D7EE	std::vector<Structure*, std::allocator<Structure*> >::_M_insert_aux(this=0x22eae4, __position={_M_current = 0x0}, __x=@0x22e5c8) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/vector.tcc:322)
#5 0057DD24	std::vector<Structure*, std::allocator<Structure*> >::push_back(this=0x22eae4, __x=@0x22e5c8) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_vector.h:741)
#6 00410DA5	InputXmlManager::StructureParsing(structXml={node = 0xcbfb10}, myStruct=0x22eae0, listMat={_M_t = {_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, materiaux> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, materiaux> > >> = {<No data fields>}, <No data fields>}, _M_key_compare = {<std::binary_function<std::basic_string<char, std:: (C:\Sharp\SOURCE_C_avril_2012_HERVE\InputXmlManager.cpp:841)
#7 00410747	InputXmlManager::recuperation_donnees_strikingship(fileName={static npos = 4294967295, _M_dataplus = {<std::allocator<char>> = {<__gnu_cxx::new_allocator<char>> = {<No data fields>}, <No data fields>}, _M_p = 0x3e5eac "C:\\Sharp\\SOURCE_C_avril_2012_HERVE\\impacteur_deformable.xml"}}, listMat={_M_t = {_M_impl = {<std::allocator<std::_Rb_tree_node<std::pair<const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, materiaux> > >> = {<__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair< (C:\Sharp\SOURCE_C_avril_2012_HERVE\InputXmlManager.cpp:804)
#8 004B75AC	main(argc=3, argv=0x3e2548) (C:\Sharp\SOURCE_C_avril_2012_HERVE\main.cpp:117)

et le debugger :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
done
Registered new type: wxString
Registered new type: STL String
Registered new type: STL Vector
Setting breakpoints
Debugger name and version: GNU gdb 6.8
Child process PID: 3860
In __cxa_throw () ()
At c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/ext/new_allocator.h:89

[Lightness1024]

lance ton programme avec Application Verifier. (peut etre qu'il faut visual studio par contre)

[vbaddict44]

je n'ai pas Visual Studio

[vbaddict44]

j'ai maintenant un problème avec le fichier new_allocator.h ligne 89

Code :

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

1
2
 
	return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));

[screetch]

tu as des problemes d'ecrasement memoire, probablement tu appelles delete deux fois sur le meme objet ou quelque chose de similaire.
Indice: ne regarde pas la pile d'appel, le crash n'est qu'un symptome du probleme, pas le probleme lui-meme.

[vbaddict44]

tu as des problemes d'ecrasement memoire, probablement tu appelles delete deux fois sur le meme objet ou quelque chose de similaire.
Indice: ne regarde pas la pile d'appel, le crash n'est qu'un symptome du probleme, pas le probleme lui-meme.

je te met quand même la call stack au cas ou tu y verrais quelque chose de louche:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
#0 00000000	0x00503cb8 in __cxa_throw() (??:??)
#1 00000000	0x00504ccd in operator new() (??:??)
#2 005282D9	__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::string const, materiaux> > >::allocate(this=0x22fea4, __n=1) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/ext/new_allocator.h:89)
#3 00581CB1	std::_Rb_tree<std::string, std::pair<std::string const, materiaux>, std::_Select1st<std::pair<std::string const, materiaux> >, std::less<std::string>, std::allocator<std::pair<std::string const, materiaux> > >::_M_get_node(this=0x22fea4) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_tree.h:359)
#4 00581E93	std::_Rb_tree<std::string, std::pair<std::string const, materiaux>, std::_Select1st<std::pair<std::string const, materiaux> >, std::less<std::string>, std::allocator<std::pair<std::string const, materiaux> > >::_M_create_node(this=0x22fea4, __x=@0x5b7afc8) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_tree.h:369)
#5 00581D4B	std::_Rb_tree<std::string, std::pair<std::string const, materiaux>, std::_Select1st<std::pair<std::string const, materiaux> >, std::less<std::string>, std::allocator<std::pair<std::string const, materiaux> > >::_M_clone_node(this=0x22fea4, __x=0x5b7afb8) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_tree.h:416)
#6 0058275F	std::_Rb_tree<std::string, std::pair<std::string const, materiaux>, std::_Select1st<std::pair<std::string const, materiaux> >, std::less<std::string>, std::allocator<std::pair<std::string const, materiaux> > >::_M_copy(this=0x22fea4, __x=0x5b7afb8, __p=0x1b0e6fb8) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_tree.h:944)
#7 005829B1	_Rb_tree(this=0x22fea4, __x=@0x22fe18) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_tree.h:602)
#8 0057A79C	map(this=0x22fea4, __x=@0x22fe18) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_map.h:171)
#9 004B77C7	main(argc=3, argv=0x2894ff0) (C:\Sharp\SOURCE_C_avril_2012_HERVE\main.cpp:117)

[mitkl]

même en déclarant une simple map dans ton main() avec rien d'autres ton programme plante ?

[vbaddict44]

non pas de plantage la déclaration d'une simple map se déroule bien

[mitkl]

est-ce que le code présent avant le vector qui plante est volumineux ? tu pourrais le coller ici pour qu'on voit où ça pêche dans la gestion mémoire

[vbaddict44]

je ne pense pas que ça soit un vector qui plante.
Est-ce que cela peut venir du namespace std ?

[mitkl]

non ce n'est pas vector qui plante mais le premier message indique que le programme plante à

Code :

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

1
2
Structure* w1 = new WeatherDeck(...);
m_collec.push_back(w1);

il y a donc, avant ce push_back, un problème de gestion de la mémoire qui peut être antérieur ou à l'intérieur de Structure* w1 = new WeatherDeck(...);

pour l'instant le code que tu as fournis tout le long de ce topic est bon le problème n'est pas là, il y a un endroit dans ton code, dans ton projet, dans n'importe quel fichier où la mémoire est mal gérée (mauvaise allocation, etc) et si ce problème n'est pas réglé, même des choses toutes bêtes peuvent planter à l'execution, dans ton cas, c'est un std::vector::push_back

Non, ça ne peut pas venir de la STL, celle-ci est suffisamment robuste pour ne pas planter sur un push_back. Enfin, ce que je veux dans un autre sens c'est que ça n'est pas parce que la call stack t'affiche une erreur dans un fichier de la lib que le problème vient de là.

Ce topic tourne en rond, il n'y a pas 36 solutions, il faut répérer où se situe le problème dans le code, sinon tu risques d'avoir du mal à continuer quoi que ce soit si tu as une pile corrumpu. Si tu n'es pas à l'aise avec la gestion mémoire, pile (stack), tas (heap), etc. Je ne peux que te conseiller la lecture de http://ilay.org/yann/articles/mem/ ça t'aidera sûrement à comprendre ce qu'il se passe dans ton programme.

[vbaddict44]

Merci beaucoup pour ton aide. Un gros boulot m'attend pour trouver cette fichu erreure.

[vbaddict44]

Bonjour, je pense que l'erreure vient de cette methoe qui retourne un tableau de double :

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
double* Library::Intersection(double beta,double xG,double yG,double xpos,double r1,double r2)
{
    double x1;
    double y1;
    double x2;
    double y2;
    double delta;
    double a;
    double b;
    double c;
    double result[4]={0};
 
    if(r1 == 0)
    {
        x1=xpos;
        x2=xpos;
        y1=0;
        y2=0;
    }
    else
    {
        if((beta != (PI/2) - 0.01* PI/2))
        {
            x1=xpos;
            x2=xpos;
            y1=yG + r2 *  pow(max(1.0000000001 - pow((x1 - xG) / r1 ,2),0.0),(1/2));
            y2= -y1;
        }
        else
        {
            a = pow(tan(beta) , 2) + pow(r1/r2,2);
            b = 2*tan(beta)* (-xpos * tan(beta) -yG) - 2*xG*pow(r1/r2,2);
            c = pow((-xpos * tan(beta) - yG),2) + pow( (r2*xG )/r1 ,2) - pow(r2,2);
            delta = pow(b,2) - 4 *a*c;
            x1 = pow(-b + delta,1 / 2) / (2 * a);
            x2 = pow(-b - delta,1 / 2) / (2 * a);
            y1 = tan(beta) * x1 - tan(beta) * xpos;
            y2 = tan(beta) * x2 - tan(beta) * xpos;
        }
    }
    if(beta<= PI/2)
    {
        result[0] = x1;
        result[1] = y1;
        result[2] = x2;
        result[3] = y2;
    }
    else
    {
        result[0] = x2;
        result[1] = y2;
        result[2] = x1;
        result[3] = y1;
    }
    return result;
}

que j'utilise de cette manière dans une autre méthode :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
 
double *intersect;
intersect= Library::Intersection(beta, xG, 0, -xpos, r1_tmp, r2_tmp);
 if(collec_tmp[elt]->retour_side()==0)
  {
      x_tmp=intersect[0];
  }
   else
   {
      x_tmp=intersect[2];
   }

une idée de ce qui ne va pas ?

[Arzar]

une idée de ce qui ne va pas ?

Oui

Code :

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

1
2
3
4
5
6
7
double* foo()
{
   //...
   double result[4]={0};
   // ...
   return result;
}

Le problème c'est que le tableau result est crée sur la pile, donc n'est plus valide en sortant de la fonction. C'est le même problème que si tu faisais :

Code :

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

1
2
3
4
5
int* foo()
{
   int i = 0;
   return &i;
}

i et result sont détruits en sortant de la portée de la fonction (juste après le return). Le pointeur renvoyé pointe donc sur une zone mémoire invalide. C'est typiquement le genre d'erreur qui provoque un comportement indéterminé, ce qui se traduit souvent par un plantage un peu plus loin dans l’exécution du programme dans un bout de code qui semble sans rapport.

Il y a deux manières pour corriger le problème.

- Soit en passant le tableau comme paramètre entrant :

Code :

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

1
2
3
4
5
6
7
8
void Library::Intersection(/*...*/, double *result)
{
   // ...
   result[0] = x2;
   result[1] = y2;
   result[2] = x1;
   result[3] = y1;
}

Donc avec ce système c'est l’appelant qui fourni le tableau à remplir :

Code :

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

1
2
3
4
5
6
void foo()
{
   double result[4];
   Library::Intersection(/*...*/, result);
  // ici result est encore valide
 }

il faut juste faire attention à ce que l’appelant crée bien un tableau de 4 éléments

- Soit en convertissant le tableau en structure, que l'on pourra renvoyer par valeur :

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
 
struct Vec4
{
   double x;
   double y;
   double z;
   double w;
};
 
Vec4 Library::Intersection(double beta,double xG,double yG,double xpos,double r1,double r2)
{
  Vec4 result;
  //...
  result.x = x2;
  result.y = y2;
  result.z = x1;
  result.w = y1;
  return result;
}

On renvoie Vec4 par valeur, donc result est copié lors du return.
Utilisation :

Code :

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

1
2
3
4
void foo()
{
   Vec4 result = Library::Intersection(/*...*/); 
}

[vbaddict44]

Merci Arzar je teste ça.
est-il possible de retourner des vector<double> à la place de double* en retour de fonction ?

[Neckara]

C'est en effet possible puisque ton vecteur sera copié.

Mais ce sera beaucoup plus lent (du fait de la copie).

Ce que tu peux faire c'est construire un vecteur grâce à l'allocation dynamique (new/delete) et transmettre un vecteur & ou un vecteur *

[screetch]

pour 4 flottants il vaut mieux les retourner par valeur.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
struct ReturnValue
{
    float values[4];
};
 
ReturnValue blabla()
{
  ReturnValue result;
  result.values[0] = ...;
  return result;
}

vector c'est fait pour les conteneurs dont la taille peut varier a l'execution

faire new sur un vector et manipuler une addresse c'est donner le baton pour se faire battre

[vbaddict44]

Merci les gars mais j'ai utilisé la première solution présenté par Arzar mais le programme plante tjr pour une histoire de map il me semble :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#0 00000000	0x00506cbc in __cxa_throw() (??:??)
#1 00000000	0x00507cd1 in operator new() (??:??)
#2 00529839	__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::string const, materiaux> > >::allocate(this=0x22fea4, __n=1) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/ext/new_allocator.h:89)
#3 00583231	std::_Rb_tree<std::string, std::pair<std::string const, materiaux>, std::_Select1st<std::pair<std::string const, materiaux> >, std::less<std::string>, std::allocator<std::pair<std::string const, materiaux> > >::_M_get_node(this=0x22fea4) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_tree.h:359)
#4 00583413	std::_Rb_tree<std::string, std::pair<std::string const, materiaux>, std::_Select1st<std::pair<std::string const, materiaux> >, std::less<std::string>, std::allocator<std::pair<std::string const, materiaux> > >::_M_create_node(this=0x22fea4, __x=@0x5bdafc8) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_tree.h:369)
#5 005832CB	std::_Rb_tree<std::string, std::pair<std::string const, materiaux>, std::_Select1st<std::pair<std::string const, materiaux> >, std::less<std::string>, std::allocator<std::pair<std::string const, materiaux> > >::_M_clone_node(this=0x22fea4, __x=0x5bdafb8) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_tree.h:416)
#6 00583D57	std::_Rb_tree<std::string, std::pair<std::string const, materiaux>, std::_Select1st<std::pair<std::string const, materiaux> >, std::less<std::string>, std::allocator<std::pair<std::string const, materiaux> > >::_M_copy(this=0x22fea4, __x=0x5bdafb8, __p=0x1b0f0fb8) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_tree.h:944)
#7 00583D97	std::_Rb_tree<std::string, std::pair<std::string const, materiaux>, std::_Select1st<std::pair<std::string const, materiaux> >, std::less<std::string>, std::allocator<std::pair<std::string const, materiaux> > >::_M_copy(this=0x22fea4, __x=0x5bd4fb8, __p=0x1b0eafb8) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_tree.h:948)
#8 00583D20	std::_Rb_tree<std::string, std::pair<std::string const, materiaux>, std::_Select1st<std::pair<std::string const, materiaux> >, std::less<std::string>, std::allocator<std::pair<std::string const, materiaux> > >::_M_copy(this=0x22fea4, __x=0x5bcefb8, __p=0x1b0e6fb8) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_tree.h:938)
#9 00583D20	std::_Rb_tree<std::string, std::pair<std::string const, materiaux>, std::_Select1st<std::pair<std::string const, materiaux> >, std::less<std::string>, std::allocator<std::pair<std::string const, materiaux> > >::_M_copy(this=0x22fea4, __x=0x5bccfb8, __p=0x22fea8) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_tree.h:938)
#10 00583FA9	_Rb_tree(this=0x22fea4, __x=@0x22fe00) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_tree.h:602)
#11 0057BCFC	map(this=0x22fea4, __x=@0x22fe00) (c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/bits/stl_map.h:171)
#12 004BA6B4	main(argc=3, argv=0x2894ff0) (C:\Sharp\SOURCE_C_avril_2012_HERVE\main.cpp:118)