Freestanding and hosted implementations

La norme C++ définit deux types d'implémentations : hosted et freestanding . Pour les implémentations hosted , l'ensemble des en-têtes de bibliothèque standard requis par la norme C++ est beaucoup plus important que pour les implémentations freestanding . Dans une implémentation freestanding , l'exécution peut se produire sans système d'exploitation.

Le type de l'implémentation est défini par l'implémentation. La macro prédéfinie __STDC_HOSTED__ est développée en 1 pour les implémentations hébergées et en ​ 0 ​ pour les implémentations autonomes. (depuis C++11)

Table des matières 1 Exigences relatives aux exécutions multithread et aux courses de données 2 Exigences relatives à la fonction main 3 Exigences relatives aux en-têtes de la bibliothèque standard 3.1 En-têtes requis pour une implémentation autonome 4 Notes 5 Références 6 Rapports de défauts 7 Voir aussi Exigences relatives aux exécutions multithread et aux courses de données autonome hébergé Dans une implémentation autonome , il est défini par l'implémentation si un programme peut avoir plus d'un thread d'exécution . Dans une implémentation hébergée , un programme C++ peut avoir plus d'un thread s'exécutant simultanément.

(depuis C++11)

Exigences relatives à la fonction main

freestanding

hosted

Dans une implémentation freestanding , il est défini par l'implémentation si un programme doit définir une fonction main . Le démarrage et la terminaison sont définis par l'implémentation ; le démarrage contient l'exécution des constructors pour les objets de namespace scope avec une durée de stockage statique ; la terminaison contient l'exécution des destructors pour les objets avec une storage duration statique.

Dans une implémentation hosted , un programme doit contenir une fonction globale appelée main . L'exécution d'un programme démarre un thread of execution principal dans lequel la fonction main est invoquée, et dans lequel les variables de storage duration statique peuvent être initialisées et détruites.

Exigences concernant les en-têtes de la bibliothèque standard

Une implémentation autonome possède un ensemble d'en-têtes défini par l'implémentation. Cet ensemble inclut au moins les en-têtes du tableau suivant.

Pour les en-têtes partiellement autonomes, les implémentations autonomes doivent uniquement fournir une partie des entités dans la synopsis correspondante :

• Si une entité est commentée // freestanding , il est garanti qu'elle est fournie.

Si une entité (fonction ou modèle de fonction) est commentée // freestanding-deleted , il est garanti qu'elle soit soit fournie soit supprimée.

(depuis C++26)

• Si une entité est déclarée dans un en-tête dont la synopsis commence par all freestanding ou // mostly freestanding , il est garanti qu'elle est fournie si l'entité elle-même n'est pas commentée.

En-têtes requis pour une implémentation autonome

1. ↑ La prise en charge des types atomiques entiers toujours sans verrouillage et la présence des alias de type std::atomic_signed_lock_free et std::atomic_unsigned_lock_free sont définies par l'implémentation dans une implémentation autonome. (depuis C++20)

Notes

Certains fournisseurs de compilateurs peuvent ne pas prendre entièrement en charge l'implémentation autonome. Par exemple, GCC libstdc++ a connu des problèmes d'implémentation et de compilation avant la version 13, tandis que LLVM libcxx et MSVC STL ne prennent pas en charge le mode autonome.

En C++23, de nombreuses fonctionnalités sont rendues autonomes avec des en-têtes partiels. Cependant, il est encore en discussion au sein du WG21 si certains en-têtes seront rendus autonomes dans les futures normes. Quoi qu'il en soit, les conteneurs comme vector , list , deque , et map ne seront jamais autonomes en raison de leurs dépendances aux exceptions et au tas.

GCC 13 fournit davantage d'en-têtes, tels que <optional> , <span> , <array> , et <bitset> , pour l'environnement autonome, bien que ces en-têtes puissent ne pas être portables ou offrir les mêmes capacités qu'une implémentation hébergée. Il est préférable d'éviter de les utiliser dans un environnement autonome, même si la chaîne d'outils les fournit.

Macro de test de fonctionnalité	Valeur	Norme	Fonctionnalité
__cpp_lib_freestanding_feature_test_macros	202306L	(C++26)	macros de test de fonctionnalités autonomes
__cpp_lib_freestanding_algorithm	202311L	(C++26)	algorithme autonome <algorithm>
	202502L	(C++26)	davantage de fonctionnalités autonomes dans <algorithm>
__cpp_lib_freestanding_array	202311L	(C++26)	autonome <array>
__cpp_lib_freestanding_char_traits	202306L	(C++26)	autonome std::char_traits
__cpp_lib_freestanding_charconv	202306L	(C++26)	autonome <charconv>
__cpp_lib_freestanding_cstdlib	202306L	(C++26)	autonome <cstdlib>
__cpp_lib_freestanding_cstring	202311L	(C++26)	autonome <cstring>
__cpp_lib_freestanding_cwchar	202306L	(C++26)	autonome <cwchar>
__cpp_lib_freestanding_errc	202306L	(C++26)	environnement autonome std::errc
__cpp_lib_freestanding_execution	202502L	(C++26)	exécution autonome <execution>
__cpp_lib_freestanding_expected	202311L	(C++26)	autonome <expected>
__cpp_lib_freestanding_functional	202306L	(C++26)	autonome <functional>
__cpp_lib_freestanding_iterator	202306L	(C++26)	itérateur autonome <iterator>
__cpp_lib_freestanding_mdspan	202311L	(C++26)	autonome <mdspan>
__cpp_lib_freestanding_memory	202306L	(C++26)	autonome <memory>
	202502L	(C++26)	davantage de fonctionnalités autonomes dans <memory>
__cpp_lib_freestanding_numeric	202311L	(C++26)	autonome <numeric>
	202502L	(C++26)	davantage de fonctionnalités autonomes dans <numeric>
__cpp_lib_freestanding_optional	202311L	(C++26)	autonome <optional>
__cpp_lib_freestanding_random	202502L	(C++26)	autonome <random>
__cpp_lib_freestanding_ranges	202306L	(C++26)	autonome <ranges>
__cpp_lib_freestanding_ratio	202306L	(C++26)	autonome <ratio>
__cpp_lib_freestanding_string_view	202311L	(C++26)	autonome <string_view>
__cpp_lib_freestanding_tuple	202306L	(C++26)	autonome <tuple>
__cpp_lib_freestanding_utility	202306L	(C++26)	autonome <utility>
__cpp_lib_freestanding_variant	202311L	(C++26)	autonome <variant>

Références

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR	Appliqué à	Comportement tel que publié	Comportement correct
CWG 1938	C++98	une implémentation n'avait pas besoin de documenter si elle est hébergée	a rendu le type d'implémentation défini par l'implémentation (nécessite donc une documentation)
LWG 3653 ( P1642R11 )	C++20	<coroutine> est autonome, mais utilise std::hash qui ne l'était pas	a rendu <functional> partiellement autonome

Voir aussi

Documentation C pour Conformité