Discussion :

[loukiluk]

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

[Neckara]

Pas de code exécutable dans un .h ! (Sauf avec les templates mais là c'est une autre histoire)

[loukiluk]

Ah ? heu, bonjour !

D'accord, c'est un peu... concis comme façon.
Ok, je modifie le code.

Mais sinon, pas d'autres commentaires ?
Par exemple, qu'est-ce qui est habile/maladroit, simplifiable, bien/mal pensé...
Qu'est-ce que tu (ou tout le monde) trouves bien fait, à refaire, etc... ?

Merci d'avance.

[Neckara]

Pourquoi des static ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
static float perimetreDe(const Forme& forme) { return forme.perimetre(); };
static float aireDe(const Forme& forme) { return forme.aire(); };

Une méthode virtuelle serait mieux je pense.

Sinon, pour l'affichage, tu peux redéfinir l'opérateur<<


Tu peux aussi définir ta fonction d'affichage dans la classe mère.

[Ekleog]

Neckara: Il est parfaitement possible de mettre une fonction inline !

Sinon, en lecture superficielle, je remarque la présence de mélanges de struct et de class ; ainsi qu'un attribut statique public (m_nbrFormes). Ce qui est très déconseillé. Attribut public, la norme s'habitue à dire que c'est le mal, même si des fois ça peut avoir sa raison d'être. Pas ici. Attribut statique, c'est en général très mauvais pour (plus tard) le multi-thread. Donc, en général, il faut éviter.

Aussi, la présence de m_larg et m_long en protected. Que devrait en faire une classe héritante ?

Aussi, la méthode afficheTout, méthode horrible par excellence, qui me révulse à chaque fois que je la vois. (Oui, je vais mieux maintenant, merci.)

Aussi, l'implémentation de ostream << Rectangle est ... originale ? (Pourquoi 177 ?)

Enfin, je dirais qu'il y a peut-être une sur-représentation des fonctions virtuelles publiques. Voir peut-être NVI (Non Virtual Interface), qui pourrait être avantageux.

Voilà, je pense que c'est tout !

[Neckara]

Neckara: Il est parfaitement possible de mettre une fonction inline !

?? Je n'ai jamais dit qu'on ne peut pas définir de fonctions inline.

Enfin, je dirais qu'il y a peut-être une sur-représentation des fonctions virtuelles publiques. Voir peut-être NVI (Non Virtual Interface), qui pourrait être avantageux.

Je ne connaissais pas^^

http://cpp.developpez.com/faq/cpp/?p...e#HERITAGE_NVI

[David Fleury]

Il ne manquerait pas des constructeurs par copie, et des opérateur d'affectations ? (pour éviter des bugs sur les compteurs de nombres de forms, ...)

[oodini]

Sinon, en lecture superficielle, je remarque la présence de mélanges de struct et de class

En quoi cela est-il un problème ?