explication sur les classes

Version imprimable

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#ifndef POINT_H
#define POINT_H
 
class Point
{
  public:
    double x,y;
    double distance(const Point &P);
    Point milieu(const Point &P); 
};
#endif
 
 
#include "Point.h"
#include <cmath>

c'est à partir d'ici que je ne comprend pas . Pourquoi (x - P.x) le x il fait quoi quelqu'un peut m'expliquer en detail

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
double Point::distance(const Point &P)
{
    double dx,dy;
    dx = x - P.x;
    dy = y - P.y;
    return sqrt(dx*dx + dy*dy); 
}
 
 
Point Point::milieu(const Point &P)
{
    Point M;
    M.x = (P.x+x) /2;
    M.y = (P.y+y) /2;
    return M;
}

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
 
#include <iostream> 
using namespace std;
#include "Point.h"
 
 
 
int main() 
{ 
    Point A, B, C;
    double d;
    cout << "SAISIE DU POINT A" << endl;
    cout << "Tapez l'abscisse : "; cin >> A.x;
    cout << "Tapez l'ordonnée : "; cin >> A.y;
    cout << endl;
    cout << "SAISIE DU POINT B" << endl;
    cout << "Tapez l'abscisse : "; cin >> B.x;
    cout << "Tapez l'ordonnée : "; cin >> B.y;
    C = A.milieu(B);
    d = A.distance(B);
    cout << endl;
    cout << "MILIEU DE AB" << endl;
    cout << "L'abscisse vaut : " << C.x << endl;
    cout << "L'ordonnée vaut : " << C.y << endl;
    cout << endl;
    cout << "La distance AB vaut :" << d << endl;
    return 0;
}

01/10/2008, 06h54
méphistopheles

bonjour

dx est la distance entre les deux absices x.

x- P.x veut dire: Abscisse (la notre, celle de l'objet dont on appele laméthode distance)-abscisse du point P (passé en paramètre).

Je pense que c'est relativement simple...

bonne chance

Code:

1 2 3 4 5 6 7 double Point::distance(const Point &P) { double dx,dy; dx = x - P.x; dy = y - P.y; return sqrt(dx*dx + dy*dy); }
En C++, lorsque tu rentre dans Point::distance, tu a un paramètre implicite qui est l'objet sur lequel la méthode s'applique. Donc 'x' tout seul lit la valeur associée à cet objet et P.x lit la valeur associée au paramètre P.
Exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 Point P0; Point P1; P0.x = 12; P0.y = 1; P1.x = 43; P1.y = -23; // cas 1 P0.distance(P1); // cas 2 P1.distance(P0);
Dans le premier cas, l'objet sur lequel s'applique la méthode est P0 et le paramètre est P1. On aura donc:
Code:

1 2 3 4 5 6 7 double Point::distance(const Point &P) // this==P0 et P == P1 { double dx,dy; dx = x - P.x;// x ==12 et P.x == 43 dy = y - P.y;// y==1 et P.y ==-23 return sqrt(dx*dx + dy*dy); }
Dans le second cas, on inverse: l'objet sur lequel s'applique la méthode est P1 et le paramètre est P0:
Code:

1 2 3 4 5 6 7 double Point::distance(const Point &P) // this==P1 et P == P0 { double dx,dy; dx = x - P.x;// x ==43 et P.x == 12 dy = y - P.y;// y==-23 et P.y ==1 return sqrt(dx*dx + dy*dy); }

01/10/2008, 09h39
Médinoc

Ça correspond à dx = this->x - P.x. En clair, un bète calcul de différence membre à membre entre deux structures.
01/10/2008, 10h14
newk++

:D Merci c'est compris l'explication :D