dodo7263
Messages postés616Date d'inscriptionmercredi 10 septembre 2008StatutMembreDernière intervention 9 février 2017
-
27 janv. 2016 à 11:57
cptpingu
Messages postés3837Date d'inscriptiondimanche 12 décembre 2004StatutModérateurDernière intervention28 mars 2023
-
27 janv. 2016 à 14:13
Bonjour à tous,
Alors voila je vous expose mon léger soucis. Je suis en train de construire un logiciel de simulation (sous forme de librairie partagée) qui est découpé en plusieurs "modules" (classes).
Exemple :
1) Module microclimate
2) module plante
3) Module sol
etc...
Tous ces modules (classes C++) me servent pour construire une solution de modélisation. Et pour chacun de ces modules, il y a un certain nombre de paramètres d'entrées (avec des valeurs qui ne bougent pas durant l’exécution mais que l'utilisateur peut modifier avant de lancer la simulation) nécessaires au fonctionnement de la simulation. On peut voir cela comme des constantes.
Mon "problème" est que je n'arrive pas à trouver un design satisfaisant. Est ce que je traite ces constantes directement au sein de chacune de mes classes (via des namespaces par exemple) ? ou alors puis-je les "externaliser" dans un header que je pourrais par la suite inclure dans chacune de mes classes ? Sachant que des paramètres d'entrée de ma classe Microclimate par exemple peuvent être utilisés dans ma classe Plante.
Voilà. J'espère avoir été le plus clair possible. Si vous avez des questions n'hésitez surtout pas, je me ferais un plaisir de préciser ce que je cherche à faire.
Pour moi, dès le moment où tu modifies la valeur d'une variable (même "une seule fois"), ce n'est plus une constante. Pour des constantes, je les aurais effectivement mis dans un namespace particulier, toutes dans le même fichier header que j'aurais inclus partout.
Pour des variables de conf "globales", je créerais un singleton sur une structure de conf publique, accessible partout. Je mettrais à jour cette structure une seule fois, dans le "main", puis l'utiliserais partout en mode "read-only" (ce qui donne l'assurance de ne pas nécessiter de section critique en cas de multi-threading).
Du style:
Singleton.hh
#ifndef CORE_SINGLETON_HH
# define CORE_SINGLETON_HH
namespace Core
{
/**
* @brief this template is an helper to make a singleton.
*
* This template is an helper to make a singleton.
* How to use it:
* @code
* class MyClass : public Singleton<MyClass>
* {
* // ...
* };
* @endcode
*/
template <typename T>
class Singleton
{
public:
/** Retrives the instance. */
static T & instance();
};
} // Core
# include "Singleton.hxx"
#endif /* !CORE_SINGLETON_HH */
Singleton.hxx
namespace Core
{
template <typename T>
T &
Singleton<T>::instance()
{
static T instance_;
return instance_;
}
}
Conf.hh
#ifndef CONF_HH
# define CONF_HH
# include <core/Singleton.hh>
# include <boost/noncopyable.hpp>
# include <string>
class Conf : public Core::Singleton<Conf>, boost::noncopyable
{
public:
Conf()
: is_something(false),
path_("default_value")
{
}
bool is_something_;
std::string path_;
};
#endif /* !CONF_HH */