Bonjour, pour un travail, je dois faire un programme avec les classes point, carré et cube. Je dois faire un programme utilisant la composition et un programme avec l'héritage.
J'ai terminé la partie composition mais j'ai de la difficulté à transférer vers l'héritage. Il est difficile pour moi de faire le lien entre les classes.

Merci beaucoup! N'hésitez pas si vous avez des questions.

Voici la partie composition:

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
#include <iostream>
#include <math.h>
 
using namespace std;
 
class Point {
    public: //declarer la fonction set_values
        void set_values (int x, int y){ //Les coordonnees des points sont des int
            this->x=x; this->y=y;
        }
        int getX(){return this->x;} //pointers vers les valeurs
        int getY(){return this->y;}
    private:
        int x,y; //les coordonnes sont des int
};
 
class Carre {
    public:
        void set_points(Point p1, Point p2) //La fonction qui set les 2 points du carres, car un carre peut se faire a partir de 2 pts
        {
            this->p1 = p1;
            this->p2 = p2;
        }
        float length(){return  sqrt(((p2.getY() - p1.getY()) * (p2.getY() - p1.getY())) + ((p2.getX() - p1.getX()) * (p2.getX() - p1.getX())));} //Derive du theoreme de Pythagore pour trouver la distance entre 2 pts
 
        float aire() //Utilisation de float pour la precision avec les racines carres
        {return  length() * length();} //Le cote multiplier par lui-meme donne l'aire
    private:
        Point p1,p2;
};
 
class Cube{
    public:
        void set_carre(Carre carre){this->carre = carre;}
        float volume()
        {return  carre.aire() * carre.length();} //Le volume est length au cube ou aire*length
    private:
        Carre carre;
};
 
int main()
{
 
 cout << "***** Point, carre et cube en heritage *****" << endl;
 cout << endl;
 
int a,b,c,d; //L'utilisateur entre les coordonnes
 cout <<"Coordonner en X du premier point: "; cin>>a;
 cout <<"Coordonner en Y du premier point: "; cin>>b;
 cout <<"Coordonner en X du deuxieme point: "; cin>>c;
 cout <<"Coordonner en Y du deuxieme point: "; cin>>d;
 
 Point p1,p2;
 Carre carre1;
 Cube cube1;
 
 p1.set_values(a,b); //Les valeurs sont mis pour les points, le carre et le cube
 p2.set_values(c,d);
 carre1.set_points(p1,p2);
 cube1.set_carre(carre1);
 
 cout << endl;
 cout <<"********************************************" << endl;
 //cout  le resultat
 cout << "L'aire du carre est de " <<carre1.aire() << endl;
 cout << "Le volume du cube est de "<<cube1.volume() << endl;
 
return 0;
 
}



Et voici ou j'en suis avec l'héritage:

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
#include <iostream>
#include <math.h>
 
using namespace std;
 
class Point {
    public:
        void set_values (int x, int y){
            this->x=x; this->y=y;
        }
        int getX(){return this->x;}
        int getY(){return this->y;}
    private:
        int x,y;
};
 
class Figure {
    private:
        Point[] points = {point1,point2,point3,point4};
    public:
        figure(4){points = Point[nbPoints];}
        void set_points(Point[] points){this->points = points;}
 
        void longueur()
        {return point4.x-point1.x;}
 
        void largeur()
        {return point2.y-point1.y;}
 
};
 
class Carre: public Figure {
 
    private:
 
    public:
        void aire()
        {return longueur()*largeur();}
 
};
 
class Cube: public Carre {
    private:
 
    public:
        void volume()
        {return aire()*longueur();}
};
 
int main()
{
    Point point1,point2,point3,point4;
    point1.set_values(0,0)
    point2.set_values(0,5)
    point3.set_values(5,5)
    point4.set_values(5,0)
 
}