Tableau change tout seul de valeur

Version imprimable

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:

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:

Merci de votre aide

31/03/2015, 11h12
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.

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:

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:

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:

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:

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:

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.

31/03/2015, 14h08
Bousk

Tous ces double segments[nbSegments]; ce serait pas des VLA ? Si c'est le cas, c'est interdit en C++.
31/03/2015, 16h08
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.
31/03/2015, 16h10
Bousk

Citation:

Envoyé par Avatar36

(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. :aie: