Discussion :

[Avatar36]

Bonjour,

Je fais appel à vous aujourd'hui car j'ai un problème peu banal. J'ai une variable tableau (segments) qui contient un certain nombre de valeur double. Je l'utilise dans mon code et plus bas il vaut autre chose!!! Qu'est-ce qui se passe? Je vous met le code (pas tout ce serait trop long) incriminé:

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
    double segments[nbSegments];
 
    for (int i=0;i<nbSegments;i++)
    {
        segments[i]= pow(pow(coordonnees[(i+1)*3+0]-coordonnees[i*3+0],2)+pow(coordonnees[(i+1)*3+1]-coordonnees[i*3+1],2)+pow(coordonnees[(i+1)*3+2]-coordonnees[i*3+2],2),0.5);
        //pow = fonction puissance
        qDebug()<<segments[i];
    }
    double centresGravite[(nbSegments+nbBuoyancy+2)*4];
 
    for (int i=0;i<nbSegments;i++)
    {
        for (int j=0; j<3; j++)
        {
            centresGravite[i*4+j]=(coordonnees[(i+1)*3+j]+coordonnees[i*3+j])/2 ;
        }
 
        centresGravite[i*4+3]=M_PI*(pow(p_dExterieur/2,2)-pow((p_dExterieur-2*p_epaisseur)/2,2))*segments[i]*p_masseVolumique
                +M_PI*(pow((p_dExterieur+2*p_epaisseurCoatingExt)/2,2)-pow(p_dExterieur/2,2))*segments[i]*p_rhoCoatingExt
                +M_PI*(pow((p_dExterieur-2*p_epaisseur)/2,2)-pow((p_dExterieur-2*p_epaisseur-2*p_epaisseurCoatingInt)/2,2))*segments[i]*p_rhoCoatingInt;
        masseTot = masseTot + centresGravite[i*4+3];
    }
 
    for(int i=0;i<nbBuoyancy;i++)
    {
        for (int j=0; j<3; j++)
        {
            centresGravite[(nbSegments+i)*4+j] = ui->tableWidget_3->item(i,j)->text().toDouble();
        }
        if(ui->tableWidget_3->item(i,3)->text().toDouble()==1)
        {
            centresGravite[(nbSegments+i)*4+3] = p_weightInAir1;
        }
        else
        {
            centresGravite[(nbSegments+i)*4+3] = p_weightInAir2;
        }
        masseTot = masseTot + centresGravite[(nbSegments+i)*4+3];
    }
 
    centresGravite[(nbSegments+nbBuoyancy+1)*4+0]= coordonnees[0+0];
    centresGravite[(nbSegments+nbBuoyancy+1)*4+1]= coordonnees[0+1];
    centresGravite[(nbSegments+nbBuoyancy+1)*4+2]= coordonnees[0+2];
    centresGravite[(nbSegments+nbBuoyancy+1)*4+3]= p_connectorWeight;
 
    centresGravite[(nbSegments+nbBuoyancy+2)*4+0]= coordonnees[(nbPoints-1)*3+0];
    centresGravite[(nbSegments+nbBuoyancy+2)*4+1]= coordonnees[(nbPoints-1)*3+1];
    centresGravite[(nbSegments+nbBuoyancy+2)*4+2]= coordonnees[(nbPoints-1)*3+2];
    centresGravite[(nbSegments+nbBuoyancy+2)*4+3]= p_connectorWeight;
 
    masseTot = masseTot + p_connectorWeight*2;
 
 
    CoG[0*3+0] = 0;
    CoG[0*3+1] = 0;
    CoG[0*3+2] = 0;
 
    for(int i=0; i<nbPoints+nbBuoyancy+2;i++)
    {
        CoG[0] = CoG[0] + centresGravite[i*4+3]*centresGravite[i*4+0];
        CoG[1] = CoG[1] + centresGravite[i*4+3]*centresGravite[i*4+1];
        CoG[2] = CoG[2] + centresGravite[i*4+3]*centresGravite[i*4+2];
    }
    CoG[0] = CoG[0]/masseTot;
    CoG[1] = CoG[1]/masseTot;
    CoG[2] = CoG[2]/masseTot;
 
    for(int i=0;i<nbPoints+nbBuoyancy+2;i++)
    {
        centresGravite[i]=0;
    }
qDebug()<<"---------";
    for (int i=0;i<nbSegments;i++)
    {
        qDebug()<<segments[i];
    }

En sortie:

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
5
5
16.5
5
3.5
6
2.091
20.034
3.6
25.2247
---------
3.6
3540
16.5
5
3.5
6
2.091
20.034
3.6
25.2247

Merci de votre aide

[Médinoc]

Essaie en remplaçant les tableaux par des vecteurs et les tabl[x] par vect.at(x), cela te permettra de déceler les débordements éventuels.

[ternel]

Tu as plein de suite d'instructions du type tab[1] = tab[1] + 17. il y a plusieurs moyen d'améliorer ca:
une boucle pour ne pas donner explicitement chaque ligne (y compris pour trois itérations).
utiliser l'opérateur combiné.
Ainsi, le bloc suivant:

Code :

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

1
2
3
4
5
6
7
8
9
for(int i=0; i<nbPoints+nbBuoyancy+2;i++)
    {
        CoG[0] = CoG[0] + centresGravite[i*4+3]*centresGravite[i*4+0];
        CoG[1] = CoG[1] + centresGravite[i*4+3]*centresGravite[i*4+1];
        CoG[2] = CoG[2] + centresGravite[i*4+3]*centresGravite[i*4+2];
    }
    CoG[0] = CoG[0]/masseTot;
    CoG[1] = CoG[1]/masseTot;
    CoG[2] = CoG[2]/masseTot;

Deviendrait:

Code :

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

1
2
3
4
5
6
7
8
for(int i=0; i<nbPoints+nbBuoyancy+2;i++) {
    for(int c=0; c<3; ++c) {
        CoG[0] += centresGravite[i*4+3]*centresGravite[i*4+c];
    }
}
for(int c=0; c<3; ++c) {
    CoG[0] /=masseTot;
}

Et la, soudain, tu réalises qu'en pratique, tu manipules des positions spatiales, et que tout deviendrait tellement plus limpide avec une classe de point, et une de vecteur.

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
namespace geometry {
template <typename T>
struct vector;
 
template <typename T, typename P = T>
struct point {
    typedef T position_type;
    typedef P precision_type;
 
    position_type x, y, z;
 
    point() : x(0), y(0), z(0) {}
    point(position_type x, position_type y, position_type z) : x(x), y(y), z(z) {}
 
    point& operator+=(vector const&);
    point& operator-=(vector const&);
 
    point& operator*=(precision_type s) {x*=s; y*=s; z*=s; return *this;}
    point& operator/=(precision_type s) {x/=s; y/=s; z/=s; return *this;}
};
 
template <typename T>
struct vector {
    typedef T deplacement_type;
    deplacement_type dx, dy, dz;
 
    vector() : dx(0), dy(0), dz(0) {}
    vector(deplacement_type dx, deplacement_type dy, deplacement_type dz) : dx(dx), dy(dy), dz(dz) {}
 
    vector operator-() const;
 
    vector& operator+=(vector const&);
    vector& operator-=(vector const&);
    vector& operator*=(deplacement_type);
    vector& operator/=(deplacement_type);
};
 
template <typename T>
vector<T> operator-(point<T> const& a, point<T> const& b);
 
template <typename T>
point<T> operator+(point<T> const& p, vector<T> const& v) {return point<T>(p)+=v;}
 
template <typename T>
point<T> operator+(vector<T> const& v, point<T> const& p) {return p+v;}
}//geometry::

De la, il est facile de coder une classe d'objet physique:

Code :

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

1
2
3
4
5
6
7
namespace physique{
struct objet {
    point<double> position;
    double masse;
    objet();
    objet (point<double> const& position, double masse) : position(position), masse(masse) {}
};

Et ta fonction devient:

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
//It est un itérateur sur des physique::objet;
namespace physique {
template <typename It>
objet barycentre(It it, It const& end) {
    assert(it!=end);
 
    point<double> position;
    double masse = 0;
 
    for(; it!=end; ++it) {
        position += it->masse * it->position;
        masse += it->masse;
    }
    return objet(position/masse, masse);
}
 
}//physique::

Ce que tu peux encore raccourcir, si tu définis une fonction dans objet pour aggréger les masses de deux objets.
Je ne l'ai pas fait, parce que je trouve que ca n'a pas vraiment de sens.

[Bousk]

Tous ces double segments[nbSegments]; ce serait pas des VLA ? Si c'est le cas, c'est interdit en C++.

[Avatar36]

Je viens de remplacer les tableaux par des vecteurs et ça semble marcher. Effectivement je dépassais du tableau centresGravite (bizarre d'ailleurs que ça ait compilé quand même). Maintenant ça a l'air de fonctionner.
@Kleternel: effectivement c'est plus clair comme ça mais j'ai pas compris grand chose à ton code. J'y réfléchirai plus tard à tête reposée.

[Bousk]

(bizarre d'ailleurs que ça ait compilé quand même)

Rien de bizzare, le langage permet de faire (quasi)n'importe quoi, y compris un suicide mémoire.