<QApplicationStatic>

Documentation sur les macros

[since 6.3] Q_APPLICATION_STATIC(Type, VariableName, ...)

Cette macro étend la fonction ` Q_GLOBAL_STATIC ` et crée un objet global et statique de type ` QGlobalStatic`, nommé ` VariableName`, initialisé par les arguments variadiques, et qui se comporte comme un pointeur vers ` Type`, où la durée de vie effective du type est liée à ` QCoreApplication`. L’objet créé par Q_APPLICATION_STATIC s’initialise de lui-même lors de sa première utilisation, ce qui signifie qu’il n’augmentera pas le temps de chargement de l’application ou de la bibliothèque. De plus, l’objet est initialisé de manière sûre pour les threads sur toutes les plateformes.

Contrairement à ` Q_GLOBAL_STATIC `, où le type est uniquement destiné à être détruit à la sortie du programme, ici, la durée de vie effective du type est liée à celle de ` QCoreApplication`. Cela en fait la solution idéale pour stocker des `QObjects` semi-statiques, qui doivent également être détruits une fois que ` QCoreApplication ` est détruit. Cela signifie que le type sera supprimé dès que l’ QCoreApplication émettra le signal `destroyed`. L’objet peut être recréé lors d’un nouvel accès, si une nouvelle instance ` QCoreApplication ` a également été créée.

La valeur étant liée à l’ QCoreApplication, elle ne doit être consultée que s’il existe une QCoreApplication::instance() valide. L’accès à cet objet avant la création de QCoreApplication ou après sa destruction générera des avertissements et peut entraîner un comportement imprévisible.

L'utilisation typique de cette macro est la suivante, dans un contexte global (c'est-à-dire en dehors de tout corps de fonction) :

Q_APPLICATION_STATIC(MyQObjectType, staticType, "some string", function())

Notez que les arguments transmis de manière variadique à cette macro sont évalués à chaque fois que l’objet est construit ; ainsi, dans l’exemple ci-dessus, la fonction function sera appelée plusieurs fois si l’objet est recréé.

Hormis le fait que la valeur soit également liée à la durée de vie de ` QCoreApplication`, cette macro se comporte de manière identique à ` Q_GLOBAL_STATIC()`. Veuillez consulter la documentation de cette macro pour plus d’informations.

Garanties de multithreading

La macro Q_APPLICATION_STATIC garantit que l’objet n’est initialisé qu’une seule fois (par durée de vie d’un ` QCoreApplication`), même si plusieurs threads tentent d’accéder simultanément à l’objet. Pour ce faire, un mutex propre à chaque objet est fourni ; les développeurs d’applications et de bibliothèques doivent garder à l’esprit que leur objet sera construit avec ce mutex verrouillé et ne doivent donc pas réentrer dans l’initialisation du même objet, sous peine de provoquer un blocage.

Il n’y a aucune sécurité inter-thread lors de la destruction de l’objet : le code utilisateur ne doit pas accéder à cet objet une fois que le destructeur de ` QCoreApplication ` a commencé à s’exécuter. Le code utilisateur doit prendre les dispositions nécessaires pour s’assurer que cela ne se produise pas, par exemple en s’abstenant d’y accéder une fois que la boucle d’événements du thread principal s’est terminée.

Tout comme ` Q_GLOBAL_STATIC`, `Q_APPLICATION_STATIC` n’offre aucune garantie de sécurité inter-thread pour les accès à l’objet une fois sa création terminée. Il incombe au code utilisateur de s’assurer qu’aucun accès concurrentiel aux données ne se produise.

Si l’objet créé par cette opération est un ` QObject`, le thread qui lui est associé sera celui qui a réussi à le créer. Il sera détruit par le thread principal ; il est donc conseillé d’appeler ` moveToThread()` sur le thread principal ou sur aucun thread avant sa destruction. Effectuer cette opération depuis le constructeur de la classe en question est une solution judicieuse si l’on ne peut pas garantir que ce sera le thread principal qui initialisera l’objet.

Cette macro a été introduite dans Qt 6.3.

Voir également ` Q_GLOBAL_STATIC ` et ` QGlobalStatic`.