Le modèle singleton est couramment utilisé lorsque vous avez besoin d'une ressource partagée unique accessible globalement, comme une connexion à une base de données, un enregistreur ou un gestionnaire de configuration. En appliquant une seule instance, il permet à plusieurs parties du programme d'accéder et de modifier le même objet, favorisant ainsi la cohérence des données et réduisant le besoin de variables globales. Singleton peut être utilisé comme cache d'objets où les objets fréquemment utilisés ou coûteux à créer sont stockés et réutilisés dans toute l'application. Cette approche permet d'améliorer les performances en évitant la création et l'initialisation d'objets redondants.
Dans cet article, nous expliquerons la création d'un singleton et démontrerons un exemple de stylisation d'un singleton dans un programme C++.
Exemple 1 : Création d'un singleton simple avec une initialisation hâtive
Un simple singleton avec initialisation précoce est un modèle de conception qui garantit qu'une seule instance d'une classe est créée, et elle est créée avec impatience lors de l'initialisation statique.
Nous allons démontrer l'extrait de code de base pour la création d'un singleton simple avec une initialisation rapide. Commençons par le programme :
#include
classe Singleton {
privé :
statique Singleton * exemple ;
Singleton ( ) { }
publique :
statique Singleton * obtenirInstance ( ) {
retour exemple ;
}
} ;
Singleton * Singleton :: exemple = nouveau singleton ( ) ;
int principal ( ) {
Singleton * singletonInstance1 = Singleton :: obtenirInstance ( ) ;
Singleton * singletonInstance2 = Singleton :: obtenirInstance ( ) ;
norme :: cout << 'singletonletonInstance1 : ' << singletonInstance1 << norme :: fin ;
norme :: cout << 'singletonletonInstance2 : ' << singletonInstance2 << norme :: fin ;
retour 0 ;
}
Le code inclut l'en-tête
Après avoir inclus le fichier d'en-tête, nous définissons la classe « Singleton » qui représente l'implémentation du modèle singleton. Il a un constructeur privé et une variable membre statique privée nommée « instance ».
Ensuite, la fonction getInstance() est implémentée en tant que fonction membre statique publique de la classe « Singleton ». Il renvoie l'instance du singleton stockée dans l'instance de variable membre statique. L'instance de variable membre statique est définie et initialisée en dehors de la classe avec « Singleton* Singleton::instance = new Singleton(); ». Cette ligne initialise avec impatience l'instance de la classe « Singleton » lors de l'initialisation statique.
Dans la fonction main(), nous déclarons deux pointeurs, « singletonInstance1 » et « singletonInstance2 », et attribuons la valeur renvoyée en appelant Singleton :: getInstance (). Puisque l’instance est initialisée avec impatience, les deux pointeurs pointent vers la même instance. Les instructions « std :: cout » impriment les adresses mémoire de « singletonInstance1 » et « singletonInstance2 » sur la console à l'aide de l'opérateur « << » et « std :: endl ».
Le code se termine par un « retour 0 » qui indique une exécution réussie du programme.
Lorsque vous exécutez ce code, le résultat ressemble à ceci :
La sortie affiche les adresses mémoire de « singletonInstance1 » et « singletonInstance2 ». Étant donné que les deux pointeurs reçoivent la même instance que celle obtenue à partir de Singleton::getInstance(), ils ont la même adresse mémoire. Cela montre comment le modèle singleton garantit qu'il existe une seule instance de la classe et que les futurs appels à getInstance() aboutissent toujours à la même instance.
Exemple 2 : implémentation d'un modèle singleton avec initialisation paresseuse
Cette démonstration explique l'implémentation du modèle singleton avec initialisation paresseuse et montre son utilisation dans la fonction main(). L'explication étape par étape de l'extrait de code est fournie après ce programme :
#includeclasse Singleton {
privé :
statique Singleton * exemple ;
Singleton ( ) {
norme :: cout << 'Instance singleton créée.' << norme :: fin ;
}
publique :
statique Singleton * obtenirInstance ( ) {
si ( exemple == nullptr ) {
exemple = nouveau singleton ( ) ;
}
retour exemple ;
}
vide voir le message ( ) {
norme :: cout << 'Bonjour de Singleton!' << norme :: fin ;
}
~Célibataire ( ) {
norme :: cout << 'Instance Singleton détruite.' << norme :: fin ;
}
} ;
Singleton * Singleton :: exemple = nullptr ;
int principal ( ) {
Singleton * singletonInstance1 = Singleton :: obtenirInstance ( ) ;
singletonInstance1 -> voir le message ( ) ;
Singleton * singletonInstance2 = Singleton :: obtenirInstance ( ) ;
singletonInstance2 -> voir le message ( ) ;
retour 0 ;
}
Le programme commence par ajouter le fichier d'en-tête
Chaque fois que le constructeur de la classe « Singleton » est appelé, il génère une instance de la classe « Singleton ». Il affiche le message « Instance Singleton créée » sur la console en utilisant « std::cout << … << std::endl; ». Le constructeur n'a aucun paramètre car il s'agit d'un constructeur par défaut. Il est défini comme Singleton() sans aucun argument. Nous le déclarons comme privé, ce qui signifie qu'il ne peut être invoqué que depuis l'intérieur de la classe. Cela empêche une instanciation directe de la classe « Singleton » et garantit que le seul moyen d'obtenir une instance est via la fonction getInstance().
La méthode getInstance() de la classe « Singleton » est déclarée comme fonction membre statique publique. Il a pour rôle d’établir et d’accorder l’accessibilité à l’instance singleton. À l’intérieur de getInstance(), il vérifie si l’instance est « nullptr ». Si c'est le cas, signifiant que l'instance n'est pas déjà présente, il utilise le constructeur privé pour instancier un nouvel objet de la classe « Singleton ».
La fonction showMessage() est une fonction membre simple qui affiche le message « Bonjour de Singleton ! » message. Le destructeur de singleton est défini. Il est appelé implicitement lorsque le programme se termine et imprime « l'instance Singleton détruite ». message qui indique que l'instance singleton est détruite. L'instance de variable membre statique est initialement définie comme « nullptr ».
Le int main() démarre la définition de la fonction main(). Ensuite, le « Singleton* singletonInstance1 = Singleton::getInstance(); » appelle la fonction getInstance() de la classe « Singleton » pour obtenir un pointeur vers l'instance singleton. Il attribue ce pointeur à la variable « singletonInstance1 ».
Après cela, le « singletonInstance1->showMessage(); » utilise l'opérateur flèche (->) pour appeler la fonction showMessage() sur le pointeur « singletonInstance1 ». Cette fonction affiche le message qui y est spécifié sur la console. Ensuite, le « Singleton* singletonInstance2 = Singleton::getInstance(); » appelle à nouveau la fonction getInstance(), obtenant un autre pointeur vers l'instance singleton. Cette fois, il attribue le pointeur sur la variable « singletonInstance2 ». Le « singletonInstance2->showMessage(); » appelle la fonction showMessage() sur le pointeur « singletonInstance2 ». Cette fonction affiche le message « Bonjour de Singleton ! » message à nouveau à la console.
Enfin, « return 0 ; » signifie la fin de la fonction main() et le programme renvoie la valeur 0, ce qui signifie une exécution réussie du programme.
Voici le résultat de l’extrait de code expliqué précédemment :
Ce résultat confirme que la classe « Singleton » assure la création d'une seule instance et que les appels ultérieurs à la fonction getInstance() génèrent de manière fiable la même instance.
Conclusion
Créer un singleton en C++ est un concept très utile. Dans cet article, nous avons initialement couvert la section d'introduction de singleton. De plus, deux exemples sont produits pour implémenter le singleton en C++. La première illustration montre l’implémentation de l’initialisation singleton impatiente. Alors que l'implémentation de l'initialisation paresseuse du modèle singleton est fournie dans le deuxième exemple de cet article. De plus, les instantanés de la sortie produite sont également affichés pour les programmes correspondants.