Fournit un conteneur séquentiel de taille fixe avec vérification de limites à sûreté de typage pour AUTOSAR Adaptive.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : c3e86159274fProvenanceQuestions ouvertes (2)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Fournit un conteneur séquentiel de taille fixe avec vérification de limites à sûreté de typage pour AUTOSAR Adaptive.
La classe modèle ara::core::Array sert de conteneur séquentiel à taille fixe pour des éléments de type T et adapte le comportement de std::array pour les applications AUTOSAR Adaptive Platform. Les appelants initialisent le conteneur avec un nombre fixe d'éléments, manipulent les contenus via des méthodes telles que fill() et accèdent au choix de manière non vérifiée via operator[] ou avec vérification de limites via at() à [SWS_CORE_01273]. En tant que contrainte relative à la sécurité, un dépassement de limites lors de at() déclenche la violation spécifique IsoStdOutOfRangeViolation au lieu de std::out_of_range, tandis que les appels de front() ou back() sur des instances vides échouent dès la compilation [SWS_CORE_01267].
Contexte
La classe modèle ara::core::Array encapsule un conteneur séquentiel d'une taille N définie statiquement à la compilation pour des éléments de type T. Elle implémente le type standardisé std::array dans le module core de l'AUTOSAR Adaptive Platform et constitue une abstraction à sûreté de typage pour des blocs de mémoire contigus. En fournissant des alias de type standardisés tels que value_type ([SWS_CORE_01216]), size_type ([SWS_CORE_01214]), difference_type ([SWS_CORE_01215]) ainsi que des types pointeurs ([SWS_CORE_01217], [SWS_CORE_01218]) et des types références ([SWS_CORE_01210], [SWS_CORE_01211]), la classe agit comme un partenaire d'interaction interopérable pour les algorithmes C++ génériques et les flux de données internes à la plateforme.
Cycle de vie
La création et la destruction d'une instance de tableau suivent les règles standard applicables aux agrégats et aux types valeurs : les fonctions membres spéciales implicitement déclarées de la norme ISO C++ sont utilisées et ne sont pas redéclarées séparément. Le tableau possède ses éléments directement en ligne dans la même zone mémoire. La durée de vie des éléments contenus est par conséquent indissociable de la durée de vie de l'objet tableau englobant ; il n'y a probablement aucune allocation dynamique sur le tas (heap), ce qui garantit un comportement temporel et mémoire déterministe. Question Q-945fdce67844d6a6 (ouverte)
Le conteneur se trouve toujours dans un état valide et gère exactement N éléments. Le fait que le tableau puisse accueillir des éléments ou qu'il se présente comme un cas particulier avec N = 0 peut être évalué via empty() ([SWS_CORE_01264]), size() ([SWS_CORE_01262]) ainsi que max_size() ([SWS_CORE_01263]). Concernant la concurrence, la règle suivante devrait s'appliquer : les accès concurrents en lecture sont sûrs sans synchronisation, tandis que les modifications parallèles en écriture nécessitent une coordination externe par l'appelant. Question Q-7abd5842b7560a04 (ouverte)
Parcours d'utilisation
Dans les cas d'utilisation typiques, ara::core::Array traverse une séquence d'initialisation, de remplissage d'éléments, d'accès aléatoire ou séquentiel ainsi que, le cas échéant, d'échange de contenu :
Initialisation et remplissage : L'ensemble du tampon de données peut être rempli uniformément avec une valeur prédéfinie via fill() ([SWS_CORE_01241]).
Accès par pointeur et échange : La zone mémoire sous-jacente peut être transmise sous forme de pointeur via data() ([SWS_CORE_01271], [SWS_CORE_01272]). Deux tableaux de mêmes dimensions peuvent être échangés au moyen de swap() ([SWS_CORE_01242]).
Diagramme de séquence : Ordre d'appel typique pour le remplissage, la vérification de limites et l'échange d'instances de tableau. Sources : [SWS_CORE_01241], [SWS_CORE_01273], [SWS_CORE_01242].
Scénarios d'erreur
La spécification définit des préconditions et postconditions strictes pour les situations limites et d'erreur :
Violation de limites lors d'un accès indexé : Si, lors de at(), l'indice n se situe en dehors des limites du tableau (n >= size()), IsoStdOutOfRangeViolation est déclenché au lieu de l'exception standard C++ std::out_of_range ([SWS_CORE_01273], [SWS_CORE_01274]). Les deux surcharges sont déclarées avec noexcept.
Accès à des instances vides : L'appel de front() ou back() sur un tableau vide (empty() == true, c'est-à-dire N = 0) entraîne obligatoirement une erreur de compilation (Compile-Time Error) ([SWS_CORE_01267], [SWS_CORE_01268], [SWS_CORE_01269], [SWS_CORE_01270]).
Comportement indéfini avec les itérateurs : Le déréférencement de l'itérateur renvoyé par begin() sur un tableau vide constitue un comportement indéfini ([SWS_CORE_01250], [SWS_CORE_01251]).
Cas particulier de récupération du pointeur : Si la taille du tableau est 0, la fonction membre data() fournit impérativement nullptr ([SWS_CORE_01271], [SWS_CORE_01272]).
Sécurité conditionnelle face aux exceptions : L'opération swap() n'est noexcept que si la condition relative au type ara::core::is_nothrow_swappable<T>::value est remplie ([SWS_CORE_01242]). De manière correspondante, la propriété noexcept de fill() est déterminée par std::is_nothrow_copy_assignable<T>::value ([SWS_CORE_01241]).
Ce guide est basé sur la spécification AUTOSAR Adaptive pour la classe fonctionnelle Core ara::core::Array et a été généré automatiquement.
As per corresponding usage in [array] except for the following deviations: 1. if (n >= size()) IsoStdOutOfRangeViolation is raised instead of std:: out_of_range
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 795454c939dfProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction membre at de la classe ara::core::Array permet l'accès synchrone en lecture et en écriture à un élément de tableau à la position spécifiée n avec contrôle implicite des limites [SWS_CORE_01273]. La fonction renvoie une référence modifiable (reference) vers l'élément adressé et peut être évaluée au moment de la compilation (constexpr) [SWS_CORE_01273].
En cas d'erreur, lorsque l'indice demandé atteint ou dépasse la limite du conteneur (n >= size()), le comportement s'écarte du conteneur C++ standard std::array : au lieu d'une exception de type std::out_of_range, un IsoStdOutOfRangeViolation est déclenché [SWS_CORE_01273]. La signature étant déclarée comme noexcept et classée comme sûre vis-à-vis des exceptions, aucune exception C++ ordinaire n'est levée [SWS_CORE_01273]. Interprétation : le déclenchement de cette violation devrait entraîner directement, dans un contexte noexcept, la terminaison contrôlée de l'exécution. Question Q-72c19d096572f6bc (ouverte)
Pour les instances en lecture seule, il existe la surcharge constante complémentaire [SWS_CORE_01274], qui fournit une référence constante. La même sémantique d'erreur au moyen de IsoStdOutOfRangeViolation est également appliquée de manière cohérente dans des conteneurs apparentés tels que ara::core::Vector ([SWS_CORE_01354], [SWS_CORE_01355]) ainsi que ara::core::StringView[SWS_CORE_02133].
Ce texte a été généré par une IA et sert de guide d'orientation. La spécification AUTOSAR fait foi.
As per corresponding usage in [array] except for the following deviations: 1. if (n >= size()) IsoStdOutOfRangeViolation is raised instead of std:: out_of_range
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 8616a34d04dcProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction membre at de la classe ara::core::Array (en-tête #include "ara/core/array.h") permet l'accès en lecture indexé à un élément individuel de tableau [SWS_CORE_01274]. Elle prend l'indice n de type size_type et renvoie une référence constante (const_reference) sur l'élément adressé [SWS_CORE_01274]. Grâce à sa déclaration en tant que constexpr et noexcept, la fonction est utilisable pour des expressions constantes au moment de la compilation et est spécifiée comme sûre face aux exceptions (exception safe) [SWS_CORE_01274]. Pour les accès en modification, la surcharge non constante est disponible [SWS_CORE_01273].
En cas d'erreur, la sémantique s'écarte de std::array : si l'indice dépasse la taille du conteneur (n >= size()), aucun std::out_of_range n'est levé, mais la violation IsoStdOutOfRangeViolation est signalée [SWS_CORE_01274]. La fonction étant qualifiée par noexcept, le signalement de cette violation conduit probablement à l'arrêt du programme via le mécanisme d'abandon à l'échelle de la plateforme, pour lequel des gestionnaires personnalisés peuvent être enregistrés [SWS_CORE_00054]. Question Q-f73299f375ef3a1f (ouverte)
Ce patron de traitement des erreurs est également appliqué de manière uniforme dans d'autres conteneurs de ara::core, par exemple avec ara::core::Vector[SWS_CORE_01354], ara::core::Map[SWS_CORE_01456] et ara::core::StringView[SWS_CORE_02133]. Cependant, alors que ara::core::Vector et ara::core::BasicString ne sont pas considérés comme sûrs face aux exceptions avec at[SWS_CORE_01354][SWS_CORE_03063], ara::core::Array garantit la sécurité face aux exceptions [SWS_CORE_01274].
Ce texte a été généré par une IA ; il ne remplace pas une vérification de la spécification officielle.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 8c9d3976ab7aProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction membre crbegin de la classe ara::core::Array du fichier d'en-tête #include "ara/core/array.h" renvoie un itérateur inverse constant sur le dernier élément du tableau conformément au comportement standard d'un conteneur [SWS_CORE_01260]. La méthode est appelée de manière synchrone et sans paramètre, et renvoie un const_reverse_iterator. En raison de sa spécification comme constexpr et const, la fonction peut être utilisée aussi bien au moment de l'exécution que lors d'évaluations au moment de la compilation, ainsi que sur des instances constantes de tableaux [SWS_CORE_01260].
Concernant le traitement des erreurs, l'opération est déclarée comme noexcept et possède la classification exception safe[SWS_CORE_01260]. L'appel garantit ainsi une sécurité totale vis-à-vis des exceptions ; aucun code d'erreur spécifique, aucun retour via DET ou DEM ou état d'erreur n'existe pour cet accès séquentiel.
En matière de concurrence, l'accès en lecture pure ne génère aucun effet secondaire, raison pour laquelle des appels simultanés de crbegin sur la même instance sont probablement thread-safe et exécutables sans synchronisation externe. Question Q-02554ec002069925 (ouverte) Aucune restriction particulière ni exigence d'ordonnancement stricte ne s'applique au contexte d'appel, tant que le tableau sous-jacent est initialisé.
En interaction avec l'ensemble de la bibliothèque Core, la méthode suit la conception d'itérateur standardisée. Des interfaces similaires pour l'itération constante inverse se trouvent dans les exigences associées pour ara::core::Vector[SWS_CORE_01342], ara::core::Map[SWS_CORE_01450], ara::core::BasicString[SWS_CORE_03049] ainsi que pour des vues sans possession telles que ara::core::Span[SWS_CORE_01978] et ara::core::StringView[SWS_CORE_02126].
Cette note d'utilisation a été générée automatiquement sur la base de la spécification AUTOSAR pour Adaptive Core R25-11.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 95338f6bd6a6ProvenanceQuestions ouvertes (2)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction membre crend de la classe conteneur ara::core::Array est mise à disposition via l'en-tête #include "ara/core/array.h"[SWS_CORE_01261]. Elle possède la signature constexpr const_reverse_iterator crend () const noexcept;, n'accepte aucun paramètre et renvoie de manière synchrone un itérateur inverse constant de type const_reverse_iterator[SWS_CORE_01261]. Grâce à sa déclaration comme constexpr, l'appel peut également être évalué au moment de la compilation [SWS_CORE_01261]. Interprétation : conformément à l'indication « As per corresponding usage in [array] », l'itérateur devrait désigner la fin logique d'une itération vers l'arrière sur un champ de données constant [SWS_CORE_01261]. Question Q-d247b385b426784f (ouverte)
Pour le traitement des erreurs, la méthode est spécifiée comme noexcept et classée comme sûre vis-à-vis des exceptions (exception safe), de sorte qu'aucune exception ne se produit et qu'aucune erreur n'est signalée via DET ou DEM [SWS_CORE_01261]. Interprétation : s'agissant d'une méthode d'instance const sans effet secondaire, des accès simultanés en lecture de plusieurs threads à la même instance devraient être sûrs et réentrants, à condition qu'aucune modification concurrente n'ait lieu [SWS_CORE_01261]. Question Q-8cd440a3f36846f9 (ouverte)
En interaction avec d'autres composants de la bibliothèque Core, ara::core::Array offre une interface d'itérateur uniforme [SWS_CORE_01261]. Des fonctions crend équivalentes pour les fins d'itération inverse existent pour ara::core::Vector[SWS_CORE_01343], ara::core::Map[SWS_CORE_01451], ara::core::Span[SWS_CORE_01979], ara::core::StringView[SWS_CORE_02127] ainsi que ara::core::BasicString[SWS_CORE_03050].
Ce texte a été généré par une IA et s'appuie sur la version spécifiée d'AUTOSAR R25-11.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : d20612515608ProvenanceQuestions ouvertes (2)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation
La fonction membre fill de la classe ara::core::Array sert à affecter une valeur uniforme à tous les éléments contenus dans le tableau [SWS_CORE_01241]. En tant que paramètre, elle prend une référence constante const T &u vers l'objet à assigner et ne renvoie aucune valeur de retour (void). Le comportement s'inspire de l'utilisation dans [array], de sorte que tous les éléments sont vraisemblablement définis de manière synchrone sur la valeur u par assignation par copie. Question Q-927b1702cfa40906 (ouverte)
Gestion des erreurs et sécurité vis-à-vis des exceptions
Selon la spécification, la fonction est classée comme conditionnellement sûre face aux exceptions (conditionally exception safe) [SWS_CORE_01241]. Ceci est mis en œuvre via l'identifiant noexcept(std::is_nothrow_copy_assignable<T>::value). Aucun code d'erreur spécifique, aucun statut d'erreur comme valeur de retour ni aucun message DET/DEM ne sont prévus ; des exceptions ne surviennent que si l'assignation par copie du type T échoue et n'est pas déclarée comme noexcept.
Concurrence et intégration
Pour l'intégration, l'en-tête #include "ara/core/array.h" doit être inclus [SWS_CORE_01241]. Étant donné que fill modifie l'état de l'objet appelant, une synchronisation externe devrait être nécessaire en cas d'accès concurrent par plusieurs threads afin d'éviter les conflits de données. Question (ouverte)
Ce texte a été organisé par une IA et repose exclusivement sur les données de spécification d'AUTOSAR Adaptive R25-11.
As per corresponding usage in [array] except for the following deviations: 1. ara::core::is_nothrow_swappable shall be used in place of the std:: implementation
gemini-3.8-flash-low· 2026-10-13 · Original allemand