Discussion :

[sythpen]

Bonjour,
J'ai un soucis avec un passage d'argument par référence. J'ai une fonction maillage qui prend en argument une référence sur une liste de points (classe Points) ainsi qu'une référence sur une liste de triangles (classe Triangles).
Juste avant de sortir de ma fonction, j'affiche la liste de points et de triangles. Les deux sont correctes. Mais une fois de retour dans mon main(), la liste de points est correcte et les triangles sont complètement faux (liste composée de chiffres en 10 à la puissance +/-308 ou +/-207)...

Voici mes classes :

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
 
class Point
{
  public:
    Point() : x1(0),x2(0),onGamma(false) {};
    Point(const Point &P) : x1(P.x1),x2(P.x2),onGamma(P.onGamma) {};
    Point(double x1,double x2, bool Gamma=false) : x1(x1),x2(x2),onGamma(Gamma) {};
  private:
    double  x1,x2;
    bool    onGamma;
};
 
class Points
{
  public:
    Points() : nb_pts(0) {};
    Points(Point P) : nb_pts(1) { vect_pts.push_back(P); };
    Points(Points& P) { nb_pts = P.nb_points(); for(int i=0; i<P.nb_points(); ++i) vect_pts.push_back(P[i]); };
    ~Points()  { nb_pts = 0; vect_pts.clear(); };
  private:
    int            nb_pts;
    vector<Point>  vect_pts;
};
 
class Triangle
{
  public:
    Triangle(Point P, Point Q, Point R) : P1(P),P2(Q),P3(R) {};
  private:
    Point  P1,P2,P3;
};
 
class Triangles
{
  public:
    Triangles()  : nb_tri(0) {};
    Triangles(Triangle T) : nb_tri(1) { vect_triangles.push_back(T); };
    ~Triangles() { nb_tri = 0; vect_triangles.clear(); };
  private:
    int               nb_tri;
    vector<Triangle>  vect_triangles;
};

Et voila le prototype de ma fonction :

Code :

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

1
2
 
void maillage ( Points& maillage, Triangles& triangles )

Quelqu'un voit d'où cela pourrait provenir ?

[Feriaman]

Quelqu'un voit d'où cela pourrait provenir ?

Très probablement : tu édite des variables de portée locale qui ne sont plus définie en sortie.

Exemple :

Code :

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

1
2
3
4
5
6
7
8
9
Triangle* m(){
    Triangle t1;
    t1.coté = 4;
    return &t1; // ici t1 est défini
}
 
...
Triangle* t2 = m();
// ici t1 n'est plus défini, la mémoire est libérée et du coup t2 pointe sur une zone mémoire qui ne contient rien sur quoi tu puisse compter.

Ce qu'il nous faudrait c'est plutôt le code de la méthode maillage.

[Feriaman]

Bon, j'ai relu ton code et effectivement, il est difficile de comprendre comment ce que je propose comme explication peut s'appliquer (puisque tu passes tes conteneurs en référence lors de l'appel).

J'ai répondu trop vite.

Cela dit le symptôme est assez clair (pointage sur mémoire non-allouée), et l'erreur assez classique.

Je te propose de quand même nous poster ta méthode maillage pour qu'on puisse se faire une idée.

[EDIT]Peut-être que tu ne remplis pas vraiment l'objet que tu crois, mais une copie locale.[/EDIT]

[sythpen]

Précision : mon domaine à mailler est constitué de 3 zones.

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
144
145
146
147
148
149
150
151
152
 
void maillage ( Points&    maillage,
                       Triangles& triangles,
                       int        nombre_de_points,
                       double     entree,
                       double     longueur_marche,
                       double     longueur_totale,
                       double     sortie )
{
    double aire_totale = longueur_totale*sortie + longueur_marche*(entree-sortie);
    int nb_pts_1 = floor(longueur_marche*entree/aire_totale*nombre_de_points);
    int nb_pts_2 = floor((longueur_totale-longueur_marche)*entree/aire_totale*nombre_de_points);
    int nb_pts_3 = floor((longueur_totale-longueur_marche)*(sortie-entree)/aire_totale*nombre_de_points);
 
    double coef_1     = longueur_marche/entree;
    double coef_2     = (longueur_totale-longueur_marche)/entree;
    double coef_3     = (longueur_totale-longueur_marche)/(sortie-entree);
 
    int nb_colonnes_2 = floor(sqrt(nb_pts_2*4/3*coef_2));
    int nb_colonnes_1 = floor(nb_colonnes_2*longueur_marche/(longueur_totale-longueur_marche));
    int nb_colonnes_3 = nb_colonnes_2;
 
    int nb_lignes_2   = floor(sqrt(nb_pts_2*2/coef_2));
    while (nb_lignes_2*nb_colonnes_2 < nb_pts_2)
        nb_lignes_2++;
    int nb_lignes_1   = nb_lignes_2;
    int nb_lignes_3   = floor(sqrt(nb_pts_3*2/coef_3));
    while (nb_lignes_3*nb_colonnes_3 < nb_pts_3)
        nb_lignes_3++;
 
    double delta_x_1 = longueur_marche/(nb_colonnes_1-1);
    double delta_y_1 = entree/(nb_lignes_1-1);
    double delta_x_2 = (longueur_totale-longueur_marche)/(nb_colonnes_2-1);
    double delta_y_2 = delta_y_1;
    double delta_x_3 = delta_x_2;
    double delta_y_3 = (sortie-entree)/(nb_lignes_3-1);
 
 
    double x    = 0;
    double y    = 0;
    bool gamma  = false;
 
    for(int i=0; i<nb_colonnes_1-1; ++i)
    {
        for(int j=0; j<nb_lignes_1-1; ++j)
        {
            x = i*delta_x_1;
            y = j*delta_y_1;
            if (x==0 || y==0 || y==entree) gamma = true;
            Point P(x,y,gamma);
 
            x = (i+1)*delta_x_1;
            y = j*delta_y_1;
            if (x==0 || y==0 || y==entree) gamma = true;
            Point Q(x,y,gamma);
 
            x = i*delta_x_1;
            y = (j+1)*delta_y_1;
            if (x==0 || y==0 || y==entree) gamma = true;
            Point R(x,y,gamma);
 
            x = (i+1)*delta_x_1;
            y = (j+1)*delta_y_1;
            if (x==0 || y==0 || y==entree) gamma = true;
            Point S(x,y,gamma);
 
            maillage.ajout(P);
            maillage.ajout(Q);
            maillage.ajout(R);
            Triangle T1( maillage[maillage.nb_points()-1], maillage[maillage.nb_points()-2], maillage[maillage.nb_points()-3] );
            triangles.ajout_simple(T1);
 
            maillage.ajout(S);
            Triangle T2( maillage[maillage.nb_points()-1], maillage[maillage.nb_points()-2], maillage[maillage.nb_points()-3] );
            triangles.ajout_simple(T2);
        }
    }
    for(int i=0; i<nb_colonnes_2-1; ++i)
    {
        for(int j=0; j<nb_lignes_2-1; ++j)
        {
            x = i*delta_x_2+longueur_marche;
            y = j*delta_y_2;
            if (x==longueur_totale || y==entree) gamma = true;
            Point P(x,y,gamma);
 
            x = (i+1)*delta_x_2+longueur_marche;
            y = j*delta_y_2;
            if (x==longueur_totale || y==entree) gamma = true;
            Point Q(x,y,gamma);
 
            x = i*delta_x_2+longueur_marche;
            y = (j+1)*delta_y_2;
            if (x==longueur_totale || y==entree) gamma = true;
            Point R (x,y,gamma);
 
            x = (i+1)*delta_x_2+longueur_marche;
            y = (j+1)*delta_y_2;
            if (x==longueur_totale || y==entree) gamma = true;
            Point S (x,y,gamma);
 
            maillage.ajout(P);
            maillage.ajout(Q);
            maillage.ajout(R);
            Triangle T1( maillage[maillage.nb_points()-1], maillage[maillage.nb_points()-2], maillage[maillage.nb_points()-3] );
            triangles.ajout_simple(T1);
 
            maillage.ajout(S);
            Triangle T2( maillage[maillage.nb_points()-1], maillage[maillage.nb_points()-2], maillage[maillage.nb_points()-3] );
            triangles.ajout_simple(T2);
        }
    }
    for(int i=0; i<nb_colonnes_3-1; ++i)
    {
        for(int j=0; j<nb_lignes_3-1; ++j)
        {
            x = i*delta_x_3+longueur_marche;
            y = j*delta_y_3*(-1);
            if (x==longueur_totale || x==longueur_marche || y==-(sortie-entree)) gamma = true;
            Point P(x,y,gamma);
 
            x = (i+1)*delta_x_3+longueur_marche;
            y = j*delta_y_3*(-1);
            if (x==longueur_totale || x==longueur_marche || y==-(sortie-entree)) gamma = true;
            Point Q(x,y,gamma);
 
            x = i*delta_x_3+longueur_marche;
            y = (j+1)*delta_y_3*(-1);
            if (x==longueur_totale || x==longueur_marche || y==-(sortie-entree)) gamma = true;
            Point R (x,y,gamma);
 
            x = (i+1)*delta_x_3+longueur_marche;
            y = (j+1)*delta_y_3*(-1);
            if (x==longueur_totale || x==longueur_marche || y==-(sortie-entree)) gamma = true;
            Point S (x,y,gamma);
 
            maillage.ajout(P);
            maillage.ajout(Q);
            maillage.ajout(R);
            Triangle T1( maillage[maillage.nb_points()-1], maillage[maillage.nb_points()-2], maillage[maillage.nb_points()-3] );
            triangles.ajout_simple(T1);
 
            maillage.ajout(S);
            Triangle T2( maillage[maillage.nb_points()-1], maillage[maillage.nb_points()-2], maillage[maillage.nb_points()-3] );
            triangles.ajout_simple(T2);
        }
    }
    cout << "\tnombre de points : " << maillage.nb_points() << endl;
    cout << "\tnombre de triangles : " << triangles.nb_triangles() << endl;
 
    //cout << triangles << endl;
}

[Feriaman]

Bon ben voilà

Est-ce que

Code :

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

Triangles::ajout_simple

fait une copie de l'objet ?
Ou est-ce qu'elle stocke une référence ?

Si elle stocke une référence, cette référence est faite à un objet de portée locale à la fonction, qui n'est donc pas défini en dehors de la fonction.

Attention ! tu as peut-être le même problème dans Points, mais il se trouve que "par hasard", la mémoire n'est pas réécrite.

[sythpen]

Je retape ma classe Triangle

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
class Triangle
{
  public:
    Triangle(Point P, Point Q, Point R) : P1(P),P2(Q),P3(R) {};
 
    friend bool     operator==  (Triangle T1,Triangle T2);
    friend bool     operator<   (Triangle T1,Triangle T2);
    friend ostream& operator<<  (ostream& out, Triangle T);
           Point    operator[]  (int i) { if(i==1) return P1;
                                          if(i==2) return P2;
  private:
    Point  P1,P2,P3;
};

Et voici ma classe Triangles avec la fonction ajout_simple

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
class Triangles
{
  public:
    Triangles() : nb_tri(0) {};
    Triangles(Triangle T)  : nb_tri(1) { vect_triangles.push_back(T); };
    ~Triangles() { nb_tri = 0; vect_triangles.clear(); };
 
    friend ostream&  operator<<  (ostream& out, Triangles T);
           Triangle  operator[]  (int i) { return vect_triangles[i]; };
 
    void ajout_simple(Triangle T) { vect_triangles.push_back(T); nb_tri++; };
    int nb_triangles() { return nb_tri; };
 
  private:
    int               nb_tri;
    vector<Triangle>  vect_triangles;
};

Vu que un Triangle est défini par 3 points, je pensais qu'en faisant Triangles::ajout_simple(Triangle T) il recopiait T dans la liste.

[jblecanard]

Vu que un Triangle est défini par 3 points, je pensais qu'en faisant Triangles::ajout_simple(Triangle T) il recopiait T dans la liste.

Tu penses juste, c'est censé être recopié... est ce qu'on peut voir le constructeur par copie et l'opérateur d'affectation de Triangle ?