Bonjour,

J'ai deux classe "Cartésien" et "Polaire" qui dérive tous les deux de la classe "Point".

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
class Cartesien : public Point
{
    private:
        double _x, _y;
 
    public:
        Cartesien();
        Cartesien(double, double);
        Cartesien(const Polaire & inPointPolaire);
};
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
class Polaire : public Point
{
    private:
        double _r, _theta;
 
    public:
        Polaire();
        Polaire(double, double);
        Polaire(const Cartesien & inC);
};
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
class Point
{
    public:
        Point();
};

J'ai une classe "Nuage" qui contient un ensemble de "Point" :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
 
class Nuage
{
    private:
        std::vector<Point *> _tabPoint;
 
    public:
        Nuage();
 
        void calculBarycentre();
        void ajouterPoint(const Point & inP);
};


Le but est de calculer le barycentre du nuage :

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
void Nuage::calculBarycentre()
{
    double x = 0., y = 0., Gx, Gy;
    std::vector<Point *>::iterator it;
 
    for (it = _tabPoint.begin(); it != _tabPoint.end(); ++it)
    {
 
    }
 
    Gx = x / _tabPoint.size();
    Gy = y / _tabPoint.size();
 
    std::cout << "Gx = " << Gx << ", Gy = " << Gy << std::endl;
}
Ma question : Comment accéder aux cordonnées cartésiennes de tous les points (sachant que j'ai tous les accesseurs nécessaires).

J'ai des opérateurs de conversion :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
Cartesien::operator Polaire()
{
    double r, theta;
 
    r     = sqrt(_x * _x + _y * _y);
    theta = atan(_y / _x);
 
    return Polaire(r, theta);
}
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
Polaire::operator Cartesien()
{
    double x, y;
 
    x = _r * sin(_theta);
    y = _r * cos(_theta);
 
    return Cartesien(x, y);
}
Merci.