Bonjour tout le monde !

Je connais les bases principales du C++, c'est-à-dire : les bases, les classes, le polymorphisme, la surcharge d'opérateur (et de n'importe quelle fonction), les pointeurs (là-dessus, j'ai peu d'expérience), attributs et méthodes statiques, l'amitié (peu d'expérience la-dessus aussi)...
ainsi qu'un peu le C : bases, chaînes de caractères, énumérations, structures, un peu d'allocation dynamique....
Mais je n'ai quand même pas un très bon niveau (enfin, je ne pense pas).

Bref, j'en viens à que je cherchais à m'entraîner et j'ai trouvé des exercices qui sont pas trop mals (sur les classes en tout cas), et j'ai commencé le premier en ajoutant des choses, pour utiliser l'héritage, le polymorphisme, la surcharge d'opérateur.


Je mets le code ici :
4 parties :
- les main :
main.h :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
 
#ifndef MAIN_H_INCLUDED
  #define MAIN_H_INCLUDED
 
  #include <iostream>
  #include "Rectangle.h"
  #include "Carre.h"
 
#endif // MAIN_H_INCLUDED
main.cpp :
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
 
#include "main.h"
 
using namespace std;
 
void UtFormes()
{
    Rectangle R1(2, 3);
    Carre C1 = 5;
 
    cout << C1;
 
    cout << R1;
}
 
int main()
{
    UtFormes();  // Exercice 1 sur les rectangles (que j'ai approfondi)
 
    return 0;
}
- Formes :
Forme.h :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
#ifndef FORME_H
  #define FORME_H
 
struct Forme
{
    virtual float perimetre() { return 0; }
    virtual float aire() { return 0; }
};
 
#endif // FORME_H
- Rectangles :
Rectangles.h :
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
 
#ifndef RECTANGLES_H_INCLUDED
  #define RECTANGLES_H_INCLUDED
 
#include <iostream>
#include <cstdlib>
#include "Forme.h"
 
class Rectangle : public Forme
{
    public:
 
        Rectangle(const float& Largeur = 0, const float& Longueur = 0);
 
        virtual float perimetre() const { return 2*(m_larg + m_long); }  // ou 2*m_larg + 2*m_long
        virtual float aire() const { return m_larg * m_long; }
 
        void changerLongeurs(const float& Largeur, const float& Longueur) { m_larg = Largeur, m_long = Longueur; }
        float&  largeur() { return m_larg; }
        float&  longueur() { return m_long; }
        float   largeur() const { return m_larg; }
        float   longueur() const { return m_long; }
 
        friend std::ostream& operator<<(std::ostream& o, const Rectangle& r);
 
    private:
 
        float m_larg, m_long;
};
 
std::ostream& operator<<(std::ostream& o, const Rectangle& r);
 
#endif // RECTANGLES_H_INCLUDED
Rectangles.cpp :
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
 
#include "Rectangle.h"
 
using namespace std;
 
Rectangle::Rectangle(const float& Largeur, const float& Longueur)
         : m_larg(Largeur), m_long(Longueur)
{}
 
ostream& operator<<(ostream& o, const Rectangle& r)
{
    o << "Rectangle de largeur " << r.m_larg << " et de longueur " << r.m_long << ".\nSon aire et son perimetre sont donc respectivement " << r.aire() << " et " << r.perimetre() << '.' << endl;
 
    return o;
}
- Carrés :
Carres.h :
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
 
#ifndef CARRES_H
  #define CARRES_H
 
#include <iostream>
#include <cstdlib>
#include "Forme.h"
 
class Carre : public Forme
{
    public:
 
        Carre(const float& Cote = 0);
 
        virtual float perimetre() const { return m_cote*4; }
        virtual float aire() const { return m_cote*m_cote; }
 
        float&  cote() { return m_cote; }
        float   cote() const { return m_cote; }
 
        friend std::ostream& operator<<(std::ostream& o, const Carre& c);
 
    private:
 
        float m_cote;
};
 
std::ostream& operator<<(std::ostream& o, const Carre& c);
 
#endif // CARRES_H
Carres.cpp :
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
 
#include "Carre.h"
 
using namespace std;
 
Carre::Carre(const float& Cote)
     : m_cote(Cote)
{}
 
ostream& operator<<(ostream& o, const Carre& c)
{
    o << "Carre de cote " << c.m_cote << ".\nSon aire et son perimetre sont donc respectivement " << c.aire() << " et " << c.perimetre() << '.' << endl;
 
    return o;
}
Si vous voulez, je peux poster le projet entier sous zip pour Code::Blocks (Windows), comme ça, ça vous évitera de faire du copier-coller si vous voulez compiler (enfin, pour ceux qu'utilisent Code::Blocks sous Windows).

Sortie :

http://www.mediafire.com/i/?gm1ty49dwj7cls7

Avant d'attaquer l'exercice sur les piles, j'aimerais faire une classe Cercle, mais je ne surchargerais pas l'opérateur d'injection, parce que dessiner un cercle, ça demande de travailler les équations que je viens de voir en maths, et bon... en console... heu... bref ! Je ne vais pas le surcharger. En SDL (ou en SFML, quand je serais allé la voir), je tenterais volontiers un jour.

Voilà, merci d'avance à tous ceux qui me feront avancer

Dernière édition du code : le 17/05/2012 à 13h43