push_back fait planter le programme

Version imprimable

Voir 40 message(s) de cette discussion en une page

31/05/2012, 11h01
Arzar

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...
31/05/2012, 12h56
screetch
ajoute
Code:

1 2 #define _DEBUG 1 #include <crtdbg.h>
en haut de main.cpp
ajoute

Code:

_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_CHECK_ALWAYS_DF);

dans main() au tout tout debut.
31/05/2012, 18h28
mitkl

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

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:

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:

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

N'est-il pas plus efficace de faire :
Code:

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:

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:

1 2 for(size_t i = 0; i <collec_tmp.size() ; i++ )
Si tu veux parcourir un vecteur :
Code:

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?

Salut,

Citation:

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 :aie: !

Code:

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.
Citation:
Envoyé par Neckara
Code:

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 :ccool:
Désolé, c'est un peu hors sujet :pastaper: !

01/06/2012, 10h07
Neckara
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é.

Citation:

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:

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é.
01/06/2012, 10h35
Kiroxas
Citation:

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.

Citation:

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.
Citation:
Si on fait :

Code:

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:

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 :D .
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).

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

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
 
 
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:

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:

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 ?

01/06/2012, 11h11
vbaddict44
Citation:
Envoyé par screetch

ajoute

Code:

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

en haut de main.cpp
ajoute

Code:

_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_CHECK_ALWAYS_DF);

dans main() au tout tout debut.
crtdbg.h n'est pas trouvé
01/06/2012, 11h11
Bousk
Citation:

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:

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:

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. :zoubi:
01/06/2012, 12h30
Neckara
Citation:

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:

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.

Structure.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
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:

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

01/06/2012, 13h33
Neckara

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
01/06/2012, 13h48
vbaddict44

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.
01/06/2012, 13h51
Bousk

Citation:

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 ?
01/06/2012, 14h20
vbaddict44

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 !!!! :cry::roll::(:calim2:
01/06/2012, 14h40
Bousk

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.
01/06/2012, 14h40
screetch

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!

voila mon main :

Code:

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:

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:

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

Voir 40 message(s) de cette discussion en une page