Exercice : Structures et passage par référence

Exercice : Structures et passage par référence#

Considérons la définition ci-dessous du type structuré « Point », qui utilise deux champs $x$ et $y$ , qui sont les coordonnées d’un point dans le plan.

struct Point { 
    float x, y;
};

On va utiliser la procédure suivante qui permet de créer et de transmettre en résultat une variable de type Point, à partir de ses coordonnées lues auprès de l’utilisateur. Notez qu’au lieu de transmettre des float ou des int, on transmet un Point !!.

void litPoint (Point &p) {
    cout << "abscisse ? "; cin >> p.x ;
    cout << "ordonnee ? "; cin >> p.y ;
}

La notation pointée permet d’écrire dans les champs d’une structure, mais également d’accéder à ces champs, comme le montre la fonction suivante :

float abscisse(Point p) { 
    return p.x ;
}

Mettez dans un nouveau fichier la définition du type Point, puis définissez une fonction qui renvoie l’ordonnée d’un point.
Solution
```
float ordonnee(Point p) {
    return p.y;
}
```
Écrivez une procédure qui affiche les coordonnées d’un point puis réalisez un programme principal utilisant cette procédure.
Solution
```
void affichePoint(Point p) {
    cout << "abscisse = " <<  abscisse(p) << endl ;
    cout << "ordonnee = " <<  ordonnee(p) << endl ;
}
```

Réalisez une fonction distance qui renvoie la distance entre deux points donnés.

Rappel : $d i s t_{A B}$ = $\sqrt{(x_{B} - x_{A})^{2} + (y_{B} - y_{A})^{2}}$

Solution

float distance(Point a, Point b) {
    float dx, dy ;
    dx = b.x - a.x ;
    dy = b.y - a.y ;
    return sqrt(dx * dx + dy * dy);
}

Définissez une fonction qui étant donnés deux points $A$ et $B$ , renvoie true si les deux points ne sont pas confondus, et transmet en résultat le point situé au milieu du segment $A B$ .
Solution
```
bool milieu(Point a, Point b, Point &m){
    bool res = ((a.x != b.x) or (a.y != b.y));
    m.x = (x.a + x.b)/2 ;
    m.y = (y.a + y.b)/2 ;
    return res ;
}
```

Utilisez la fonction EgalApproché donnée ci-dessous pour vérifier dans le main que le milieu calculé par la fonction précédente est bien à égale distance des deux extrémités du segment.

const float e = 1e-6 ;
bool EgalApproche(float x, float y) {
    return (fabs(x-y) < e*fabs(x)) && (fabs(x-y) < e*fabs(y));
}

où fabs() est la fonction valeur absolue pour les réels.

Solution

int main () {
    Point pa, pb, pm; 
    litPoint(pa); litPoint(pb);
    if (not milieu(pa,pb,pm)) {
        cout << "vos 2 points sont confondus" << endl;
    } else {
        if (egalApproche(distance(pa, pm), distance(pb, pm))) {
            cout << " le milieu est en : " << endl;
            affichePoint(pm);
        } else {
            cout << "rate ! votre point est en : " << endl;
            affichePoint(pm);
        }
    }
}