push_back fait planter le programme

**Arzar** · 31/05/2012, 12h01

Hmmm, vu que l'exception s'est déplacée, mais qu'elle est encore dans un new, j'ai plutôt tendance à penser qu'il reste malheureusement des soucis de dépassement de tableau/pointeurs invalides etc...

screetch · 31/05/2012, 13h56

ajoute

Code :

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

1
2
#define _DEBUG 1
#include <crtdbg.h>

en haut de main.cpp
ajoute

Code :

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

_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_CHECK_ALWAYS_DF);

dans main() au tout tout debut.

**mitkl** · 31/05/2012, 19h28

sans grosse conviction, c'est pas réservé à MSVC ça?

**vbaddict44** · 01/06/2012, 10h02

Bonjour, je suis sur une nouvelle piste, est-ce que ce type de méthode peut générer ce type de problème :

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
 
std::vector<Structure*> navireimpacteur::elem_attaches_borde_bulbe(bool etrave, bool bulbe, double wb, double beta)
{
 
    std::vector<Structure*> collec_elem_attaches_borde;
    std::vector<Structure*> collec_tmp;
    collec_tmp = identification_elt_structurel_actif(wb,beta,false,true);
    double z_limite;
    z_limite = -(GetGeometryBow().retour_Z_deck()-GetGeometryBow().retour_Z_bottom()) + GetGeometryBulb().retour_R_height();
    for(size_t i = 0; i <collec_tmp.size()  ; i++ )
    {
        if(collec_tmp[i]->retour_type() == "LongitudinalStiffener")
        {
            if(collec_tmp[i]->retour_location() >= 4 && collec_tmp[i]->retour_location()< 5)
            {
                collec_elem_attaches_borde.push_back(collec_tmp[i]);
            }
        }
        else if(collec_tmp[i]->retour_type() == "InnerDeck")
        {
            collec_elem_attaches_borde.push_back(collec_tmp[i]);
        }
        else if(collec_tmp[i]->retour_type() == "LongitudinalBulkhead")
        {
            collec_elem_attaches_borde.push_back(collec_tmp[i]);
        }
    }
    return collec_elem_attaches_borde;
}

que j'utilise de cette manière dans une autre classe :

Code :

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

1
2
3
 
 std::vector<Structure*> collec_borde;
    collec_borde = elem_attaches_borde_bulbe(etrave,bulbe,wb,beta);

**Neckara** · 01/06/2012, 10h07

N'est-il pas plus efficace de faire :

Code :

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

1
2
 
std::vector<Structure*> collec_borde = elem_attaches_borde_bulbe(etrave,bulbe,wb,beta);

Ceci t'évitera d'initialiser collec_borde avec le constructeur par défaut puis de le remplir.

Code :

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

1
2
 for(size_t i = 0; i <collec_tmp.size()  ; ++i )

i++ va enregistrer la valeur de i, incrémenté i puis retournée la valeur enregistrée, faire ++i est donc plus rapide.

Sinon, pourrais-tu nous donner le code source de identification_elt_structurel_actif() ?

EDIT :

Code :

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

1
2
 
for(size_t i = 0; i <collec_tmp.size()  ; i++ )

Si tu veux parcourir un vecteur :

Code :

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

1
2
3
4
5
6
7
 
std::vector<...>const_iterator fin = collec_tmp.end();
std::vector<...>iterator p = collect_tmp.begin();
for(; p != fin; ++p)
{
        (*p)->retour_type(); // *p est un élément de ton vecteur.
}

Il ne faut jamais utiliser la méthode size() car tu va alors parcourir la totalité de ton vecteur pour compter le nombre d'élément. Si ton vecteur est grand, cela va te prendre pas mal de temps.

EDIT 2 : Je suis en train de penser, as-tu bien mis le destructeur de Structure en virtuel?
Peux-tu aussi nous montrer les en-tête de ta classes Structure et d'une classe fille de Structure?

**Kiroxas** · 01/06/2012, 10h51

Salut,

Envoyé par Neckara

Il ne faut jamais utiliser la méthode size() car tu va alors parcourir la totalité de ton vecteur pour compter le nombre d'élément. Si ton vecteur est grand, cela va te prendre pas mal de temps.

Euh non quand même, size se fait en temps constant hein

!

Code :

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

for(size_t i = 0, end = collec_tmp.size() ; i < end ; ++i )

Du coup ça c'est aussi efficace, quoique peut-être moins joli que les itérateurs.

Envoyé par Neckara

Code :

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

1
2
3
4
5
6
std::vector<...>const_iterator fin = collec_tmp.end();
std::vector<...>iterator p = collect_tmp.begin();
for(; p != fin; ++p)
{
        (*p)->retour_type(); // *p est un élément de ton vecteur.
}

Par contre pourquoi ne pas définir tes itérateurs dans le scope de ta boucle ? C'est là que tu t'en sers après tout

Désolé, c'est un peu hors sujet

!

**Neckara** · 01/06/2012, 11h07

C'est certes un peu HS mais il faut prendre les bonnes habitudes le plus tôt possible ce qui rend le code un peu plus lisible donc plus facile à déboguer (et peut même éviter de futurs bugs et cela évite aussi à d'éventuels visiteurs de reproduire les mauvaises habitudes qui sont montrée comme le i++).

En C++ l'un des principes est : ce que je n'utilise pas ne doit rien me coûter.

Suivant ce principe, le std::vector ne contient pas de compteur du nombre d'éléments contenus. Il doit donc parcourir l'intégralité du tableau. (par contre je ne vois pas comment il fait pour avoir une complexité constante, il va falloir que je voye ça avec mon prof de C++ cet aprèm tiens)

EDIT après la réponse de Kiroxas: je viens d'y penser dans le tram :

C'est très simple, vector contient un pointeur :
- vers le début
- vers la fin

il suffit donc de faire fin - début pour obtenir le nombre d'élément.

J'ai dû confondre avec les list qui elles doivent parcourir tout les éléments.

Fin EDIT

De plus, si jamais il veut changer le std::vector par autre chose, comme une std::list, le code restera pratiquement inchangé.

Par contre pourquoi ne pas définir tes itérateurs dans le scope de ta boucle ?

pour garder le for le plus lisible possible.
Si on fait :

Code :

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

1
2
3
4
5
 
for(std::vector<...>iterator p = collect_tmp.begin(); p != collec_tmp.end(); ++p)
{
        (*p)->retour_type(); // *p est un élément de ton vecteur.
}

C'est déjà un peu plus compliqué à lire visuellement (encore que là c'est encore correct).
Alors si en plus on utilise un conteneur un peu plus compliqué exemple : une map de vecteur ça devient trop chargé.

**Kiroxas** · 01/06/2012, 11h35

En C++ l'un des principes est : ce que je n'utilise pas ne doit rien me coûter.

Evidemment je suis d'accord sur ce principe.

Suivant ce principe, le std::vector ne contient pas de compteur du nombre d'éléments contenus. Il doit donc parcourir l'intégralité du tableau.

Euh je ne suis pas ta logique du tout là, le vector doit (à mon avis mais je ne trouve pas l'implémentation des vector dans la STL, si quelqu'un a, je suis preneur) contenir sa propre taille (et c'est certainement ce qu'il fait pour disposer d'un size() constant.

Si on fait :

Code :

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

1
2
3
4
5
 
for(std::vector<...>iterator p = collect_tmp.begin(); p != collec_tmp.end(); ++p)
{
        (*p)->retour_type(); // *p est un élément de ton vecteur.
}

C'est déjà un peu plus compliqué à lire visuellement (encore que là c'est encore correct).
Alors si en plus on utilise un conteneur un peu plus compliqué exemple : une map de vecteur ça devient trop chargé.

Code :

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

1
2
3
4
5
6
7
 
for(std::vector<...>iterator p = collect_tmp.begin(), end = collec_tmp.end();
     p !=end; 
     ++p)
{
        (*p)->retour_type(); // *p est un élément de ton vecteur.
}

Mes boucles ont moi cette "forme" là, je trouve ça assez lisible, et même si c'est un peu moins lisible que ta version, que le scope de mes itérateurs soit limité à la boucle me semble un plus gros gain que la légère perte de visibilité (si vraiment le type des itérateurs est trop long, il y a aussi les typedef).
Après j'imagine que chacun ses préférences

.
Par contre écrire ceci : p != collec_tmp.end() en condition d'arrêt est plus chronophage que la différence i++/++i, appeler la méthode à chaque fin de boucle plutôt que de stocker cette valeur (Il faut bien sur que le vecteur ne soit pas redimensionné dans la boucle pour utiliser ceci).

**vbaddict44** · 01/06/2012, 12h09

Voila le code de identification_elt_structurel_actif comme demandé c'est assez long mais bon :

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
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
 
 
std::vector<Structure*> navireimpacteur::identification_elt_structurel_actif(double xpos , double beta ,bool etrave ,bool bulbe)
 {
     std::vector<Structure*> collec_tmp;
     std::vector<Structure*> collec_elem_impacte;
 
     //double elt;
     double x_tmp;
     double r1_tmp;
     double r2_tmp;
     double xG ;
     double intersect[4];
     double rayon[2];
 
     if(etrave && !bulbe)
     {
 
         collec_tmp=bowStruct->m_collec;
         xG=-GetGeometryBow().retour_R_longi_deck();
     }
     else if(bulbe && !etrave)
     {
         collec_tmp=bulbStruct->m_collec;
 
         xG= -GetGeometryBulb().retour_Length() - GetGeometryBulb().retour_R_height();
     }
     else
     {
         std::cout << "error: separer les calculs" << std::endl;
         exit(0);
     }
 
     for(size_t elt=0; elt < collec_tmp.size();elt++)
     {
        if(collec_tmp[elt]->retour_type() != "SideShell")
        {
            if(collec_tmp[elt]->retour_type()== "LongitudinalStiffener")
            {
                if(collec_tmp[elt]->retour_location() < 4 || collec_tmp[elt]->retour_location() >= 5)
                {
                    x_tmp = Library::sectionx(xpos,collec_tmp[elt]->retour_y_etoile(),beta);
                    if(x_tmp < collec_tmp[elt]->Xmax(*this,etrave,bulbe) && x_tmp > collec_tmp[elt]->retour_xmin())
                    {
                        collec_tmp[elt]->set_etat("IMPACTE");
                        collec_elem_impacte.push_back(collec_tmp[elt]);
                    }
                    else
                    {
                        collec_tmp[elt]->set_etat("NON IMPACTE");
                    }
                }
                else if(collec_tmp[elt]->retour_location() >= 4 || collec_tmp[elt]->retour_location() < 5)
                {
                   if((-xpos <= collec_tmp[elt]->Xmax(*this,etrave,bulbe)) && (etrave && !bulbe))
                    {
                        r1_tmp = Library::R_z_etrave(GetGeometryBow().retour_R_longi_deck(),GetGeometryBow().retour_R_longi_bottom(),0,-(GetGeometryBow().retour_Z_deck()-GetGeometryBow().retour_Z_bottom()),bowStruct->m_collec[elt]->retour_position());
                        r2_tmp = Library::R_z_etrave(GetGeometryBow().retour_R_transv_deck(),GetGeometryBow().retour_R_transv_bottom(),0,-(GetGeometryBow().retour_Z_deck()-GetGeometryBow().retour_Z_bottom()),bowStruct->m_collec[elt]->retour_position());
                        Library::Intersection(beta, xG, 0, -xpos, r1_tmp, r2_tmp,intersect);
                        if(collec_tmp[elt]->retour_side()==0)
                        {
                           x_tmp=intersect[0];
                        }
                        else
                        {
                           x_tmp=intersect[2];
                        }
                        if (x_tmp < collec_tmp[elt]->Xmax(*this,etrave,bulbe) && x_tmp > collec_tmp[elt]->retour_xmin())
                        {
                            collec_tmp[elt]->set_etat("IMPACTE");
                            collec_elem_impacte.push_back(collec_tmp[elt]);
                        }
                        else
                        {
                            collec_tmp[elt]->set_etat("NON IMPACTE");
                        }
 
                    }
                    else if((-xpos<=collec_tmp[elt]->Xmax(*this,etrave,bulbe)) && (!etrave && bulbe))
                    {
                        Library::Rayon_ellipsoide(xpos, xG, 0, -(GetGeometryBow().retour_Z_deck()-GetGeometryBow().retour_Z_bottom()) + GetGeometryBulb().retour_R_height(), GetGeometryBulb().retour_R_longi(), GetGeometryBulb().retour_R_transv(), GetGeometryBulb().retour_R_height(), "xy", collec_tmp[elt]->retour_position(),rayon);
                        Library::Intersection(beta, xG, 0, -xpos, rayon[0], rayon[1],intersect);
                        if(collec_tmp[elt]->retour_side()==0)
                        {
                            x_tmp = intersect[0];
                        }
                        else
                        {
                            x_tmp = intersect[2];
                        }
                        if(x_tmp < collec_tmp[elt]->Xmax(*this,etrave,bulbe) && x_tmp > collec_tmp[elt]->retour_xmin())
                        {
                            collec_tmp[elt]->set_etat("IMPACTE");
                            collec_elem_impacte.push_back(collec_tmp[elt]);
                        }
                         else
                        {
                            collec_tmp[elt]->set_etat("NON IMPACTE");
                        }
                    }
                }
 
 
            }
            else if(collec_tmp[elt]->retour_type() == "LongitudinalBulkhead")
            {
 
                x_tmp = Library::sectionx(xpos, collec_tmp[elt]->retour_y_etoile(), beta);
                if(x_tmp < collec_tmp[elt]->Xmax(*this,etrave,bulbe))
                {
                    collec_tmp[elt]->set_etat("IMPACTE");
                    collec_elem_impacte.push_back(collec_tmp[elt]);
                }
 
            }
            else if((collec_tmp[elt]->retour_type() == "WeatherDeck") || (collec_tmp[elt]->retour_type() == "InnerDeck"))
            {
               if((collec_tmp[elt]->retour_xmin() == -GetGeometryBow().retour_R_longi_deck()) || (collec_tmp[elt]->retour_xmin() == -GetGeometryBulb().retour_R_longi() - GetGeometryBulb().retour_Length()))
               {
                   if(-xpos <= collec_tmp[elt]->Xmax(*this,xpos,etrave,bulbe))
                   {
                       collec_tmp[elt]->set_etat("IMPACTE");
                       collec_elem_impacte.push_back(collec_tmp[elt]);
                   }
               }
               else if((-xpos < collec_tmp[elt]->Xmax(*this,xpos,etrave,bulbe)) && (-xpos > collec_tmp[elt]->retour_xmin()))
               {
                   collec_tmp[elt]->set_etat("IMPACTE");
                   collec_elem_impacte.push_back(collec_tmp[elt]);
               }
               else
               {
                   collec_tmp[elt]->set_etat("NON IMPACTE");
               }
 
            }
 
        }
 
     }
 
    return collec_elem_impacte;
 }

En reponse a Neckara :

Oui le destructeur est bien virtual, et voici les entetes :

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
 
#ifndef STRUCTURE_H_INCLUDED
#define STRUCTURE_H_INCLUDED
 
#include <vector>
#include "materiaux.h"
#include "Library.h"
 
 
 
class navireimpacteur;
 
class Structure
{
    public:

et pour une classe fille :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#ifndef WEATHERDECK_H_INCLUDED
#define WEATHERDECK_H_INCLUDED
 
#include "Structure.h"
 
class WeatherDeck : public Structure
{
 
    private:

pour le i++ en ++i et l'iterateur au lieu du for:

est-ce que cela peut causer le type de problème que j'ai ou c'est juste de l'optimisation ?

**vbaddict44** · 01/06/2012, 12h11

Envoyé par screetch

ajoute

Code :

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

1
2
#define _DEBUG 1
#include <crtdbg.h>

en haut de main.cpp
ajoute

Code :

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

_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_CHECK_ALWAYS_DF);

dans main() au tout tout debut.

crtdbg.h n'est pas trouvé

**Bousk** · 01/06/2012, 12h11

Envoyé par Neckara

Suivant ce principe, le std::vector ne contient pas de compteur du nombre d'éléments contenus. Il doit donc parcourir l'intégralité du tableau. (par contre je ne vois pas comment il fait pour avoir une complexité constante, il va falloir que je voye ça avec mon prof de C++ cet aprèm tiens)

http://www.cplusplus.com/reference/stl/vector/size/
std::vector::size est en temps constant. De même que vector::end et vector::begin et en regardant le header sous visual (2005 sous xp), on voit ceci

Code :

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

1
2
3
4
	size_type size() const
		{	// return length of sequence
		return (_Myfirst == 0 ? 0 : _Mylast - _Myfirst);
		}

Mais il peut être implementation depend. J'ai déjà travaillé avec des vector (maison) qui allaient à l'inverse et gardaient en mémoire le pointeur vers le premier élément et le nombre d'élément contenus puis calculait le last à partir de ça pour retourner end.
Le vector assurant que les éléments sont contigus en mémoire, ça fonctionne.

http://www.cplusplus.com/reference/stl/list/size/
std::list::size est plus souple sur son implémentation, le temps peut être constant (recommandé) ou linéaire.
begin et end sont aussi en temps constant. Mais une liste n'assure pas que ses élements sont contigus en mémoire.
Sous visual 2005 sous xp, j'ai ceci

Code :

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

1
2
3
4
	size_type size() const
		{	// return length of sequence
		return (_Mysize);
		}

Donc le temps est constant et le nombre d'éléments est clairement enregistré dans la list.

Choses auxquelles on ne pense pas forcément en réalisant ses propres containers pour de simples tests, mais la std est assez robuste à ce niveau.

**Neckara** · 01/06/2012, 13h30

est-ce que cela peut causer le type de problème que j'ai ou c'est juste de l'optimisation ?

C'est de l'optimisation et en même temps cela peut t'éviter des bugs futurs.

Code :

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

1
2
3
 
tab[i++]; <=> tab[i]; ++i;
tab[++i] <=> ++i; tab[i];

@Bousk : pour le vector, j'y ai pensé et j'ai édité à 11h47, je ne suis donc pas trompé, c'est bien pointeur_fin - pointeur_debut.

Pour la list je suis tout de même assez déçu d'avoir un temps constant recommandé (ie présence d'un compteur). Ceci va à l'encontre des principes fondamentaux du C++, si on n'utilise pas le compteur il ne devrait rien nous coûter or apparemment ce n'est pas le cas

Pour en revenir au problème initial :
@vbaddict44 : ta méthode identification_elt_structurel_actif est bien trop longue et presque illisible. Tu devrais diviser cette fonction en plusieurs méthodes.
D'ailleurs il est probable que cette méthode cache des erreurs.

Pour les en-tête, je voulais dire le .h ou .hpp complet.

**vbaddict44** · 01/06/2012, 14h18

Structure.h :

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
58
59
60
61
62
63
64
65
66
67
 
 
#ifndef STRUCTURE_H_INCLUDED
#define STRUCTURE_H_INCLUDED
 
#include <vector>
#include "materiaux.h"
#include "Library.h"
 
 
 
class navireimpacteur;
 
class Structure
{
    public:
//        std::map <int,WeatherDeck> weatherDecks;
//        std::map <int,SideShell> sideShells;
//        std::map <int,InnerDeck> innerDecks;
//        std::map <int,LongitudinalBulkhead> longitudinalBulkheads;
//        std::map <int,LongitudinalStiffener> longitudinalStiffeners;
        std::vector<Structure*> m_collec;
        //Structure(int id, materiaux mat);
        Structure();
        virtual ~Structure();
        int retour_id_struct();
        materiaux retour_material();
        std::string retour_val(){return val;};
        virtual std::string retour_type()=0;
        virtual double retour_location()=0;
        virtual double retour_y_etoile()=0;
        virtual double retour_xmin()=0;
        virtual double retour_side()=0;
        virtual double retour_position()=0;
        virtual double Xmax(navireimpacteur& ni,bool etrave, bool bulbe)=0;
        virtual double Xmax(navireimpacteur& ni,double wc,bool etrave, bool bulbe)=0;
        virtual double retour_zmax()=0;
        virtual double retour_zmin()=0;
        virtual double zmin_w(navireimpacteur& ni,double wb,double beta,bool etrave,bool bulbe)=0;
        virtual double zmax_bulbe(navireimpacteur& ni,double wb,double beta)=0;
        virtual double zmin_bulbe(navireimpacteur& ni,double wb,double beta)=0;
        virtual std::string retour_shape()=0;
        virtual double Y(bool etrave,bool bulbe)=0;
        virtual double Z(bool etrave,bool bulbe)=0;
        virtual double retour_web_height()=0;
        virtual double retour_flange_height()=0;
        virtual double retour_flange_thickness()=0;
        virtual double retour_web_thickness()=0;
        virtual double trouver_z_inf(navireimpacteur& ni,bool etrave , bool bulbe ,double hauteur,std::vector<Structure*> collec_raidisseur_pont, double wb, double beta)=0;
        virtual double trouver_z_sup(navireimpacteur& ni,bool etrave , bool bulbe ,double hauteur,std::vector<Structure*> collec_raidisseur_pont, double wb, double beta)=0;
        virtual double retour_thickness()=0;
 
 
        //virtual double Xmax(double xpos);
        std::string retour_etat();
        void set_etat(std::string et);
        void set_val(std::string v){val=v;};
        void setMaterial(materiaux mat){material = mat;};
 
 
   protected:
        materiaux material;
        int id_struct;
        std::string etat;
        std::string val;
};
#endif // STRUCTURE_H_INCLUDED

WeatherDeck.h :

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
 
#ifndef WEATHERDECK_H_INCLUDED
#define WEATHERDECK_H_INCLUDED
 
#include "Structure.h"
 
class WeatherDeck : public Structure
{
 
    private:
        //int weather_deck_ID;
        //materiaux material;
        double thickness;
        double position;
        std::string type;
 
    public:
        WeatherDeck(){};
        WeatherDeck(int weather_deck_ID_s,double thickness_wd_s,materiaux m,double position_wd_s);
        //int retour_weather_deck_ID(){return weather_deck_ID;};
        virtual double retour_thickness(){return thickness;};
        //materiaux retour_material(){return material;};
        virtual double retour_position(){return position;};
        virtual std::string retour_type(){return type;};
        virtual double Xmax(navireimpacteur& ni, double wc, bool etrave, bool bulbe);
 
 
        virtual double retour_location(){return -1;};
        virtual double retour_y_etoile(){return -1;};
        virtual double retour_xmin(){return -1;};
        virtual double retour_side(){return -1;};
        virtual double Xmax(navireimpacteur& ni,bool etrave, bool bulbe){return -1;};
        virtual double retour_zmax(){return -1;};
        virtual double retour_zmin(){return -1;};
        virtual double zmin_w(navireimpacteur& ni,double wb,double beta,bool etrave,bool bulbe){return -1;};
        virtual double zmax_bulbe(navireimpacteur& ni,double wb,double beta){return -1;};
        virtual double zmin_bulbe(navireimpacteur& ni,double wb,double beta){return -1;};
        virtual std::string retour_shape(){return "";};
        virtual double Y(bool etrave,bool bulbe){return -1;};
        virtual double Z(bool etrave,bool bulbe){return -1;};
        virtual double retour_web_height(){return -1;};
        virtual double retour_flange_height(){return -1;};
        virtual double retour_flange_thickness(){return -1;};
        virtual double retour_web_thickness(){return -1;};
        virtual double trouver_z_inf(navireimpacteur& ni,bool etrave , bool bulbe ,double hauteur,std::vector<Structure*> collec_raidisseur_pont, double wb, double beta){return -1;};
        virtual double trouver_z_sup(navireimpacteur& ni,bool etrave , bool bulbe ,double hauteur,std::vector<Structure*> collec_raidisseur_pont, double wb, double beta){return -1;};
 
 
};
 
#endif // WEATHERDECK_H_INCLUDED

**Neckara** · 01/06/2012, 14h33

Une chose saute aux yeux : ta classe est trop grande.

Tu dois faire plus de classes et faire de la délégation.

Plus tu as des classes et des méthodes/fonctions grandes et plus :
- Ton code sera illisible
- Ton code sera difficilement modifiable et modulable.
- Tu risque d'avoir des bugs difficile à corriger

**vbaddict44** · 01/06/2012, 14h48

Merci Neckara pour ton aide.

Je suis en stage, une grande partie de code était existant je ne peut pas me permettre de refaire toute la structure du code c'est un très gros projet.

Le soucis ne pourrait pas venir du compilateur ?
coté gestion de mémoire je pense avoir fait les choses comme il le faut.

**Bousk** · 01/06/2012, 14h51

Pour la list je suis tout de même assez déçu d'avoir un temps constant recommandé (ie présence d'un compteur). Ceci va à l'encontre des principes fondamentaux du C++, si on n'utilise pas le compteur il ne devrait rien nous coûter or apparemment ce n'est pas le cas

C'est vrai pour le code que tu écris toi-même, "malheureusement" là on parle de la STL qui doit rester générique malgré tout.

[/fin du HS ^-^']
---

Le problème est-il vraiment dû au push_back ? parce que je trouve ça.. étrange serait peu dire.
Le problème ne survient-il pas sur un parsing des éléments du vector ?

**vbaddict44** · 01/06/2012, 15h20

le push_back n'est plus remis en cause en effet, d'ailleurs je l'est mis en commentaire depuis, l’erreur survient a des endroit différent selon que je met en commentaire certaines parties du code ou non !!!!

**Bousk** · 01/06/2012, 15h40

Il te faut vérifier et noter où et quand ça arrive.
Si ça arrive lors du parsing, puisque ton vector contient des pointeurs que tu alloues toi-mêmes, il faut voir s'il contient pas à un moment un pointeur incorrect (déjà libéré typiquement)
Si ça arrive en dehors du parsing, il peut y avoir une corruption de mémoire, regarde alors du côté de l'allocation si tu n'as pas une allocation d'un tableau de taille 0, si tu n'es jamais hors normes du tableau.

Si tu es sûr que c'est cette classe qui est en cause, si possible enlève toute utilisation de cette classe. Si après l'avoir enlevé ça ne plante plus, ta classe est suspecte : ajoute au fur et à mesure les méthodes.

screetch · 01/06/2012, 15h40

ce que tu peux faire c'est mettre du code en commentaire avant le push_back pour voir si ca evite le crash.
Si il n'y a plus de crash alors tu sais que le code que tu viens de commenter est le code qui fera planter!

**vbaddict44** · 01/06/2012, 16h00

voila mon main :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 std::cout << listMat["S235"] <<std::endl;
 
            navireimpacteur strikingShip = InputXmlManager::recuperation_donnees_strikingship(cp.retour_strikingFilePath(),listMat);
            //ModSolveur modsolveur=ModSolveur();
            //modsolveur.resolution(cp,listMat,struckShip,strikingShip);
 
 
 
            std::cout<<std::endl<<" ";
            std::cout<<std::endl<<"*---------------*";
            std::cout<<std::endl<<"* Fin du solveur*";
            std::cout<<std::endl<<"*---------------*";
            std::cout<<std::endl<<" ";

voici le code de recuperation_donnees_strikingship où presque tout le code a été mis en commentaire :

Code :

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

1
2
3
4
5
6
7
8
 
navireimpacteur InputXmlManager::recuperation_donnees_strikingship(std::string fileName,std::map<std::string,materiaux> listMat)
{
    std::cout << "test " << std::endl;
    navireimpacteur ni;
    return ni;
 
}

malgrès cela ca plante je ne comprend plus rien

Code :

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

1
2
In __cxa_throw () ()
At c:/program files/codeblocks/mingw/bin/../lib/gcc/mingw32/4.4.1/include/c++/ext/new_allocator.h:89

push_back fait planter le programme

C++

Discussions similaires

Partager

Partager