Application d'une question de conception basée sur des règles

Question

Je n'ai pas lu le livre Modern C++ Design mais j'ai trouvé l'idée d'injection de comportement à travers des modèles intéressante. J'essaie maintenant de l'appliquer moi-même.

J'ai une classe qui a un enregistreur que je pensais pouvoir être injecté comme politique. L'enregistreur a une méthode log() qui prend un std :: string ou std :: wstring en fonction de sa politique:

// basic_logger.hpp 
template<class String> 
class basic_logger 
{ 
public: 
    typedef String string_type; 

    void log(const string_type & s) { ... } 
}; 
typedef basic_logger<std::string> logger; 
typedef basic_logger<std::wstring> wlogger; 

// reader.hpp 
template<class Logger = logger> 
class reader 
{ 
public: 
    typedef Logger logger_type; 

    void read() 
    { 
     _logger.log("Reading..."); 
    } 

private: 
    logger_type _logger; 
}; 

Maintenant, le est des quêtes, devrait prendre le lecteur un enregistreur comme argument, comme ci-dessus, ou devrait-il prendre une chaîne, puis instancier un basic_logger en tant que variable d'instance? Comme ceci:

template<class String> 
class reader 
{ 
public: 
    typedef String string_type; 
    typedef basic_logger<string_type> logger_type; 

    // ... 

private: 
    logger_type _logger; 
}; 

Quelle est la procédure à suivre?

Answer 1

Pour utiliser réellement une classe de stratégie, la stratégie doit être un paramètre de modèle. Un exemple est le paramètre char_traits de basic_string, même si cela est implémenté différemment des politiques de MC++ D, qui utilisent l'héritage pour utiliser l'optimisation de classe de base vide et pour faciliter l'ajout à l'interface publique d'une classe (bien mieux que envelopper chaque méthode possible, encore une fois, lire MC++ D). Vous pouvez toujours fournir une valeur par défaut:

template<class String, class Logger=basic_logger<String> > 
struct reader : Logger { 
    void read() { 
    this->log("Reading..."); 
    } 
}; 

Answer 2

La question doit-elle être paramétrée sur le type de son enregistreur ou sur le type de chose qu'il lit? Si c'est la question, j'aurais pensé que la réponse était évidente - la dernière.

Le problème avec cette question IMHO est que ni String ni Logger sont en fait des politiques. Une politique dit à la compilation, comment quelque chose comme un logger devrait être utilisé pour la journalisation - votre code fournit simplement un type de logger au lecteur, ce qui pourrait aussi bien avoir été fait à l'exécution, en utilisant l'héritage.

Answer 3

Les stratégies sont normalement des paramètres qui affectent le comportement de la classe.

Il est effectivement assez difficile d'extraire les politiques d'une classe, et le plus difficile est que les politiques doivent couvrir les concepts orthogonaux afin que vous puissiez en changer un sans affecter les autres ... ce qui est assez difficile comme vous pouvez l'imaginer .

Si vous voulez voir un bon exemple d'utilisation de la politique, recherchez Loki::Singleton qui est entièrement démontré dans le livre.

template 
< 
    typename T, 
    template <class> class CreationPolicy = CreateUsingNew, 
    template <class> class LifetimePolicy = DefaultLifetime, 
    template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL, 
    class MutexPolicy = LOKI_DEFAULT_MUTEX 
> 
class SingletonHolder; 

Impressionnant, n'est-ce pas? Le principe de la conception basée sur des règles est que vous essayez de décomposer les différentes actions de votre classe afin de pouvoir les raisonner de manière indépendante.

Eh bien, maintenant, je dois admettre que je ne suis pas tout à fait à l'aise avec l'idée d'exiger la classe avec un certain nombre de paramètres du modèle, personnellement, j'aurais préféré quelque chose le long:

template 
< 
    class T, 
    class CreationPolicy = CreateUsingNew<T>, 
    class LifetimePolicy = DefaultLifeTime<T>, 
    class MutexPolicy = LOKI_DEFAULT_MUTEX, 
    template <class, class> class ThreadingModel = LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL 
> 
class SingletonHolder; 

Le dernier ne peut pas vraiment être aidé , vous êtes censé passer la classe SingletonHolder elle-même.

Cependant je trouve plus facile d'échanger des politiques ici, il me permet de définir des politiques comme:

template <class T, size_t Param> MyCreationPolicy; 

Et utiliser directement, sans avoir à envelopper pour une valeur donnée de param afin qu'elle corresponde à la signature.