Discussion :

[Joe Askr]

Bonjour,

Je conçoit actuellement mon premier programme en C++ et je me pose pas mal de questions concernant les "bonnes pratiques" de conception liées à ce langage afin d'écrire du code robuste et utilisable professionnellement.

Histoire de me lancer, je transpose un utilitaire de diagnostic multi-OS que j'avais développé en C.

Voici l’implémentation basique, n'hésitez pas à me corriger si je fais fausse route :

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
/* Une classe abstraite représentant un OS quelconque */
 
// Une classe basique, un errcode et un getter/setter
#include "GenericException.h"
 
class GenericOs
{
    public:
        std::string GetManufacturer() { return m_manufacturer; }
        // [...] accesseurs pour toutes les propriétés communes
 
    protected:
        std::string m_manufacturer;
        // [...]
 
        virtual void initializeOsInfo(void) = 0;
}

Cette classe n'a ni constructeur ni implémentation concrète dans un .cpp, est-ce un problème ?

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
 /* Classe héritée spécifique à Windows */
 
class WindowsOs : public GenericOs
{
    public:
        WindowsOs();
 
    protected:
        virtual void initializeOsInfo(void);
 
    private:
        OSVERSIONINFOEX m_win32_osInfo;  
}
 
// Implémentation .cpp :
 
WindowsOs::WindowsOs()
{
    initializeOsInfo();
}
 
void WindowsOs::initializeOsInfo(void)
{
    memset(&m_win32_osInfo, 0, sizeof(OSVERSIONINFOEX));
    m_win32_osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
 
    if (GetVersionEx( (OSVERSIONINFO*)&m_win32_osInfo ) == 0)
    {
        GenericException ex;
        ex.SetErrorCode(1);
 
        throw(ex);
    }
 
    // [...]
}

La création de l'objet doit donc se faire dans un bloc try, bonne solution ? Je dois aussi systématiquement créer un objet GenericException pour lever une exception, ne vaut il pas mieux en faire un singleton voir une classe statique ?

Une fois le programme achevé (avec par exemple des classes GenericUnix:GenericOs, LinuxOS:GenericUnix, BSD et consorts), quelle sera la "meilleure" méthode pour utiliser la classe adéquate ?
J'imagine des directives de préproc/Makefile qui vont bien pour la compilation, mais existe il une méthode pour appeler le (logiquement seul) descendant de GenericOs implémenté comme j'ai cru (sans certitude) le voir en Java ou en C# ?

Merci d'avance d'éclairer ma lanterne.

[themadmax]

Cette classe n'a ni constructeur ni implémentation concrète dans un .cpp, est-ce un problème ?

Non pas de problème bien qu'il soit préférable de créer des fichiers cpp pour l’implémentation des fonctions, pour que le compilateur ne re-compile pas a chaque fois.

La création de l'objet doit donc se faire dans un bloc try, bonne solution ?

L'utilisation des exceptions est a réservé uniquement pour la gestion des erreurs [Bjarne Stroustrup, The C++ Programming Language] ce qui est ton cas donc bon choix.

L’instanciation d'une classe spécifique est appelé une "Factory", mais dans ton cas cela n'est pas applicable. Car ton code Win32 ne pourra pas compilé sur une autre plateforme. Mon avis serai d'utilisé des constantes pré-processeur, comme généralement utilisé dans les codes open-source :

Code :

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

1
2
3
4
5
6
7
GenericOs =
#ifdef _WIN32 
new WindowsOs();
#endif
#ifdef __APPLE__
new SteeveOs();
#endif

[jblecanard]

ne vaut il pas mieux en faire un singleton voir une classe statique ?

Maheureux, non ! Lis donc cet article.

Mon avis serai d'utilisé des constantes pré-processeur, comme généralement utilisé dans les codes open-source :

Code :

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

1
2
3
4
5
6
7
GenericOs =
#ifdef _WIN32 
new WindowsOs();
#endif
#ifdef __APPLE__
new SteeveOs();
#endif

J'ai déjà expérimenté cette méthode et je la trouve particulièrement inélégante.

Je préfère la technique qui consiste à mettre l'implémentation de la factory dans des *.cpp différents selon la plateforme. Ensuite, je confie le soin à mon outil de compilation (j'aime CMake mais c'est faisable avec tous !) de choisir le bon *.cpp pour la plateforme sur laquelle il compile. C'est dans ce genre de situation que la séparation *.h et *.cpp se révèle utile. Si on ne fait pas ça, on doit encadrer tous les blocs codes "plateforme dépendants" par des directives pré-processeurs, et on a vite fait d'arriver à un truc bien dégueu.

[Joel F]

Je préfère la technique qui consiste à mettre l'implémentation de la factory dans des *.cpp différents selon la plateforme.

un bon gros +10000 sur cette solution. C'est *exactement* le use case de factory.

[Joe Askr]

Merci à vous pour vos réponses. En effet ce pattern s'impose de lui même.

Ah et merci pour l'article jb, j'adore ce genre de lecture.