structure ara::core::variant_size< Variant< Types... > >

Le template ara::core::variant_size< Variant< Types... > > sert de trait de compilation dans le module core pour déterminer le nombre de types alternatifs d'un ara::core::Variant. La spécialisation fournit cette information de type aux algorithmes génériques et aux assertions statiques, sans nécessiter la création d'instances à l'exécution. En tant que contrainte essentielle, l'ensemble de l'évaluation est réalisé de manière purement statique par le compilateur, raison pour laquelle il n'existe ni erreurs d'exécution ni cycles de vie dynamiques.

plus ›

Contexte

Le template de classe ara::core::variant_size< Variant< Types... > > représente une spécialisation partielle de la structure de trait générale ara::core::variant_size pour le type ara::core::Variant au sein du module core d'AUTOSAR Adaptive Platform. Le rôle de cette spécialisation consiste à fournir à la compilation des informations sur le nombre de types alternatifs déclarés dans le template variadique Variant< Types... >. Les partenaires d'interaction sont principalement des algorithmes génériques, des bibliothèques de métaprogrammation par templates ainsi que des développeurs qui implémentent une logique dépendante du type pour des unions à sûreté de typage. Conformément à la description générale, le comportement s'aligne sur l'utilisation correspondante dans la norme C++ pour les variants. La spécialisation devrait ainsi servir de passerelle d'intégration afin de mettre à disposition pour ara::core::Variant les mêmes interfaces de compilation et modèles de métaprogrammation que ceux que les développeurs connaissent dans les environnements C++ modernes. Question Q-755dac46e27ba347 (ouverte)

Cycle de vie

En tant que pur construit de compilation, ara::core::variant_size< Variant< Types... > > ne possède aucun cycle de vie dynamique pendant l'exécution du programme. Il n'existe ni processus de création en mémoire dynamique, ni phases de destruction, ni transitions d'état. La structure n'encapsule vraisemblablement aucune donnée membre modifiable et agit purement en tant que constante de compilation ou métafonction. Question (ouverte) Comme l'ensemble des évaluations est déjà exécuté pendant la compilation par le compilateur, la concurrence, la sécurité des threads à l'exécution et les relations de possession explicites ne jouent aucun rôle. Les instances de la structure n'ont pas besoin d'être créées à l'exécution ; le code appelant accède plutôt typiquement au résultat d'évaluation via des constantes membres statiques ou des définitions d'alias de type. La durée de vie des valeurs dérivées correspond ainsi à l'unité de traduction et demeure sous forme de métainformation statique dans le code compilé.

Parcours d'utilisation

Le chemin d'utilisation typique de ara::core::variant_size< Variant< Types... > > s'effectue entièrement au sein d'expressions de template ou d'assertions statiques. Dans un déroulement représentatif, une application ou un module déclare d'abord un type Variant concret, par exemple avec plusieurs types de données utiles alternatifs. Un algorithme générique accède ensuite à ara::core::variant_size avec ce type Variant en paramètre afin de déterminer le nombre total d'alternatives. L'interprétation de cet accès est que la structure fournit la valeur entière constante du nombre de types par l'intermédiaire d'un élément de données statique. Cette valeur est habituellement employée dans des boucles statiques, des fonctions templates récursives ou des vérifications static_assert, par exemple pour s'assurer qu'un index d'accès se situe dans les limites autorisées de la liste de types du variant. Le déroulement ne requiert aucune initialisation préalable et n'entraîne aucun surcoût à l'exécution.

Scénarios d'erreur

Comme ara::core::variant_size< Variant< Types... > > est exclusivement évalué au moment de la compilation, les erreurs d'exécution classiques, les codes d'erreur tels que ara::core::ErrorCode ou les exceptions dynamiques ne surviennent pas. Les scénarios d'erreur possibles se limitent à la phase de compilation. Si le trait est instancié avec des arguments de type qui ne représentent pas un ara::core::Variant valide ou qui contiennent des définitions de type incomplètes, le compilateur refuse la compilation. Selon l'interprétation, une utilisation erronée en dehors de l'interface de template prévue devrait entraîner des erreurs explicites du compilateur, par exemple lors d'un accès à des éléments inexistants ou d'une violation des limites d'index en combinaison avec d'autres auxiliaires de trait. Les préconditions d'utilisation consistent essentiellement en ce que le type Variant transmis soit déclaré de manière bien formée. Les postconditions se présentent sous la forme d'une disponibilité fiable de la valeur de décompte déterminée au moment de la compilation. Question Q-03a26a0bd31b942d (ouverte)