Stelt een sequentiële container met vaste grootte en typeveilige bereikcontrole beschikbaar voor AUTOSAR Adaptive.
DOOR AI GEGENEREERDongecontroleerdModel: gemini-3.8-flash-medium · Inspanning: medium · Temperatuur: niet regelbaar · Prompt: c3e86159274fHerkomstOpen vragen (2)
vertaald uit de Duitse handleidinggemini-3.8-flash-low · 2026-10-13 · Duits origineel
Stelt een sequentiële container met vaste grootte en typeveilige bereikcontrole beschikbaar voor AUTOSAR Adaptive.
De template-klasse ara::core::Array dient als sequentiële container met vaste grootte voor elementen van het type T en adapteert het gedrag van std::array voor AUTOSAR Adaptive Platform-toepassingen. Aanroepers initialiseren de container met een vast aantal elementen, manipuleren inhoud via methoden zoals fill() en benaderen deze naar keuze ongecontroleerd via operator[] of met bereikcontrole via at()[SWS_CORE_01273]. Als veiligheidsrelevante randvoorwaarde leidt een bereikoverschrijding bij at() tot de specifieke schending IsoStdOutOfRangeViolation in plaats van std::out_of_range, terwijl aanroepen van front() of back() op lege instanties reeds tijdens compilatietijd mislukken [SWS_CORE_01267].
Context
De template-klasse ara::core::Array kapselt een sequentiële container in met een statisch tijdens compilatietijd vastgelegde grootte N voor elementen van het type T. Deze implementeert het gestandaardiseerde type std::array in de module core van het AUTOSAR Adaptive Platform en vormt een typeveilige abstractie voor aaneengesloten geheugenblokken. Door het beschikbaar stellen van gestandaardiseerde type-aliassen zoals value_type ([SWS_CORE_01216]), size_type ([SWS_CORE_01214]), difference_type ([SWS_CORE_01215]) alsmede pointertypen ([SWS_CORE_01217], [SWS_CORE_01218]) en referentietypen ([SWS_CORE_01210], [SWS_CORE_01211]) fungeert de klasse als interoperabele interactiepartner voor generieke C++-algoritmen en platforminterne datastromen.
Levenscyclus
Het aanmaken en vernietigen van een array-instantie volgt de standaardregels voor aggregaat- en waardetypen: de impliciet gedeclareerde speciale lidfuncties van de ISO-C++-standaard worden gebruikt en niet afzonderlijk opnieuw gedeclareerd. De array bevat zijn elementen direct inline in hetzelfde geheugengebied. De levensduur van de opgenomen elementen is bijgevolg onlosmakelijk gekoppeld aan de levensduur van het omsluitende array-object; er vindt vermoedelijk geen dynamische allocatie op de heap plaats, wat zorgt voor een deterministisch tijds- en geheugengedrag. Vraag Q-945fdce67844d6a6 (open)
De container bevindt zich steeds in een geldige toestand en beheert exact N elementen. Of de array elementen kan opnemen of als bijzonder geval met N = 0 voorliegt, kan worden geëvalueerd via empty() ([SWS_CORE_01264]), size() ([SWS_CORE_01262]) en max_size() ([SWS_CORE_01263]). Wat betreft gelijktijdigheid mag worden aangenomen dat gelijktijdige leestoegangen zonder synchronisatie veilig zijn, terwijl parallelle schrijfwijzigingen externe coördinatie door de aanroeper vereisen. Vraag Q-7abd5842b7560a04 (open)
Gebruikspad
In typische usecases doorloopt ara::core::Array een opeenvolging van initialisatie, vullen met elementen, willekeurige of sequentiële toegang en eventueel uitwisseling van inhoud:
Initialisatie en vullen: De gehele databuffer kan via fill() ([SWS_CORE_01241]) uniform van een vooraf opgegeven waarde worden voorzien.
Pointertoegang en uitwisseling: Het onderliggende geheugengebied kan via data() ([SWS_CORE_01271], [SWS_CORE_01272]) als pointer worden overgedragen. Twee gelijk gedimensioneerde arrays kunnen met behulp van swap() ([SWS_CORE_01242]) worden uitgewisseld.
De specificatie definieert strikte pre- en postcondities voor grens- en foutsituaties:
Bereikschending bij geïndexeerde toegang: Wanneer bij at() de index n buiten de arraygrenzen ligt (n >= size()), wordt IsoStdOutOfRangeViolation geactiveerd in plaats van de standaard C++-exceptie std::out_of_range ([SWS_CORE_01273], [SWS_CORE_01274]). Beide overladen versies zijn gedeclareerd met noexcept.
Ongedefinieerd gedrag bij iterators: Het derefereren van de door begin() geretourneerde iterator op een lege array levert ongedefinieerd gedrag op ([SWS_CORE_01250], [SWS_CORE_01251]).
Speciaal geval bij pointeropvraag: Indien de grootte van de array 0 is, levert de lidfunctie data() dwingend nullptr op ([SWS_CORE_01271], [SWS_CORE_01272]).
Voorwaardelijke exceptieveiligheid: De operatie swap() is alleen dan noexcept wanneer aan de typegerelateerde voorwaarde ara::core::is_nothrow_swappable<T>::value is voldaan ([SWS_CORE_01242]). Overeenkomstig wordt de noexcept-eigenschap van fill() bepaald via std::is_nothrow_copy_assignable<T>::value ([SWS_CORE_01241]).
Deze handleiding is gebaseerd op de AUTOSAR Adaptive-specificatie voor de functionele Core-klasse ara::core::Array en is geautomatiseerd gegenereerd.
As per corresponding usage in [array] except for the following deviations: 1. if (n >= size()) IsoStdOutOfRangeViolation is raised instead of std:: out_of_range
DOOR AI GEGENEREERDongecontroleerdModel: gemini-3.8-flash-medium · Inspanning: medium · Temperatuur: niet regelbaar · Prompt: 795454c939dfHerkomstOpen vragen (1)
vertaald uit de Duitse handleidinggemini-3.8-flash-low · 2026-10-13 · Duits origineel
De elementfunctie at van de klasse ara::core::Array maakt synchrone lees- en schrijftoegang tot een array-element op de opgegeven positie n met impliciete grenswaardecontrole [SWS_CORE_01273] mogelijk. De functie retourneert een modificeerbare referentie (reference) naar het geadresseerde element en kan tijdens compile-time worden geëvalueerd (constexpr) [SWS_CORE_01273].
In geval van een fout, wanneer de gevraagde index de containergrens bereikt of overschrijdt (n >= size()), wijkt het gedrag af van de standaard C++-container std::array: in plaats van een uitzondering van het type std::out_of_range wordt een IsoStdOutOfRangeViolation geactiveerd [SWS_CORE_01273]. Omdat de signatuur als noexcept is gedeclareerd en als uitzonderingsveilig is geclassificeerd, worden er geen reguliere C++-excepties geworpen [SWS_CORE_01273]. Interpretatie: het activeren van deze schending leidt in een noexcept-context vermoedelijk direct tot de gecontroleerde beëindiging van de uitvoering. Vraag Q-72c19d096572f6bc (open)
Voor alleen-lezen instanties bestaat de complementaire constante overbelasting [SWS_CORE_01274], die een constante referentie levert. Dezelfde foutsemantiek door middel van IsoStdOutOfRangeViolation wordt consistent ook toegepast in verwante containers zoals ara::core::Vector ([SWS_CORE_01354], [SWS_CORE_01355]) en ara::core::StringView[SWS_CORE_02133].
Deze tekst is gegenereerd door een AI en dient als oriëntatiehulp. Doorslaggevend is de AUTOSAR-specificatie.
As per corresponding usage in [array] except for the following deviations: 1. if (n >= size()) IsoStdOutOfRangeViolation is raised instead of std:: out_of_range
DOOR AI GEGENEREERDongecontroleerdModel: gemini-3.8-flash-medium · Inspanning: medium · Temperatuur: niet regelbaar · Prompt: 8616a34d04dcHerkomstOpen vragen (1)
vertaald uit de Duitse handleidinggemini-3.8-flash-low · 2026-10-13 · Duits origineel
De lidfunctie at van de klasse ara::core::Array (header #include "ara/core/array.h") maakt geïndiceerde, lezende toegang tot een afzonderlijk array-element mogelijk [SWS_CORE_01274]. Deze accepteert de index n van het type size_type en levert een constante referentie (const_reference) naar het geadresseerde element op [SWS_CORE_01274]. Door de declaratie als constexpr en noexcept is de functie bruikbaar voor constante expressies tijdens compileertijd en gespecificeerd als uitzonderingsveilig (exception safe) [SWS_CORE_01274]. Voor modificerende toegang staat de niet-constante overload ter beschikking [SWS_CORE_01273].
In geval van een fout wijkt de semantiek af van std::array: overschrijdt de index de containergrootte (n >= size()), dan wordt er geen std::out_of_range gegenereerd, maar wordt de schending IsoStdOutOfRangeViolation gemeld [SWS_CORE_01274]. Omdat de functie gekwalificeerd is met noexcept, leidt het melden van deze schending vermoedelijk tot beëindiging van het programma via het platformbrede abort-mechanisme, waarvoor door de gebruiker gedefinieerde handlers kunnen worden geregistreerd [SWS_CORE_00054]. Vraag Q-f73299f375ef3a1f (open)
Dit foutafhandelingspatroon wordt uniform ook in andere containers van ara::core toegepast, zoals bij ara::core::Vector[SWS_CORE_01354], ara::core::Map[SWS_CORE_01456] en ara::core::StringView[SWS_CORE_02133]. Terwijl ara::core::Vector en ara::core::BasicString bij at echter niet als uitzonderingsveilig gelden [SWS_CORE_01354][SWS_CORE_03063], garandeert ara::core::Array uitzonderingsveiligheid [SWS_CORE_01274].
Deze tekst is opgesteld door een AI; deze vervangt geen controle van de officiële specificatie.
DOOR AI GEGENEREERDongecontroleerdModel: gemini-3.8-flash-medium · Inspanning: medium · Temperatuur: niet regelbaar · Prompt: 8c9d3976ab7aHerkomstOpen vragen (1)
vertaald uit de Duitse handleidinggemini-3.8-flash-low · 2026-10-13 · Duits origineel
De lidfunctie crbegin van de klasse ara::core::Array uit het headerbestand #include "ara/core/array.h" levert een constante reverse-iterator naar het laatste element van de array conform standaard containergedrag [SWS_CORE_01260]. De methode wordt synchroon en parameterloos aangeroepen en retourneert een const_reverse_iterator. Vanwege de specificatie als constexpr en const kan de functie zowel tijdens runtime als in compile-time evaluaties en op constante array-instanties worden ingezet [SWS_CORE_01260].
Wat de foutafhandeling betreft, is de operatie gedeclareerd als noexcept en heeft deze de classificatie exception safe[SWS_CORE_01260]. De aanroep garandeert zodoende volledige uitzonderingsveiligheid; specifieke foutcodes, terugmeldingen via DET of DEM of fouttoestanden bestaan niet voor deze sequentiële toegang.
Op het gebied van gelijktijdigheid genereert de zuivere leestoegang geen neveneffecten, waardoor gelijktijdige aanroepen van crbegin op dezelfde instantie vermoedelijk thread-safe en zonder externe synchronisatie uitvoerbaar zijn. Vraag Q-02554ec002069925 (open) Voor de aanroepcontext gelden geen bijzondere beperkingen of strikte volgordevoorschriften, zolang de onderliggende array is geïnitialiseerd.
In samenspel met de gehele Core-bibliotheek volgt de methode het gestandaardiseerde iteratorontwerp. Vergelijkbare interfaces voor omgekeerde constante iteratie zijn te vinden in de geassocieerde vereisten voor ara::core::Vector[SWS_CORE_01342], ara::core::Map[SWS_CORE_01450], ara::core::BasicString[SWS_CORE_03049] en voor niet-bezittende views zoals ara::core::Span[SWS_CORE_01978] en ara::core::StringView[SWS_CORE_02126].
Deze gebruiksinstructie is geautomatiseerd opgesteld op basis van de AUTOSAR-specificatie voor Adaptive Core R25-11.
DOOR AI GEGENEREERDongecontroleerdModel: gemini-3.8-flash-medium · Inspanning: medium · Temperatuur: niet regelbaar · Prompt: 95338f6bd6a6HerkomstOpen vragen (2)
vertaald uit de Duitse handleidinggemini-3.8-flash-low · 2026-10-13 · Duits origineel
De lidfunctie crend van de containerklasse ara::core::Array wordt via de header #include "ara/core/array.h" ter beschikking gesteld [SWS_CORE_01261]. Deze heeft de signatuur constexpr const_reverse_iterator crend () const noexcept;, accepteert geen parameters en retourneert synchroon een constante reverse-iterator van het type const_reverse_iterator[SWS_CORE_01261]. Dankzij de declaratie als constexpr kan de aanroep ook tijdens compileertijd worden geëvalueerd [SWS_CORE_01261]. Interpretatie: Volgens de vermelding “As per corresponding usage in [array]” duidt de iterator vermoedelijk het logische einde aan van een achterwaartse iteratie over een constant gegevensveld [SWS_CORE_01261]. Vraag Q-d247b385b426784f (open)
Voor de foutafhandeling is de methode gespecificeerd als noexcept en geclassificeerd als uitzonderingsveilig (exception safe), zodat er geen excepties optreden en er geen fouten via DET of DEM worden gemeld [SWS_CORE_01261]. Interpretatie: Aangezien het om een neveneffectvrije const-instantiemethode gaat, zijn gelijktijdige leestoegangen van meerdere threads op dezelfde instantie vermoedelijk veilig en re-entrant, zolang er geen concurrerende modificatie plaatsvindt [SWS_CORE_01261]. Vraag Q-8cd440a3f36846f9 (open)
DOOR AI GEGENEREERDongecontroleerdModel: gemini-3.8-flash-medium · Inspanning: medium · Temperatuur: niet regelbaar · Prompt: d20612515608HerkomstOpen vragen (2)
vertaald uit de Duitse handleidinggemini-3.8-flash-low · 2026-10-13 · Duits origineel
Gebruik
De lidfunctie fill van de klasse ara::core::Array dient ertoe om alle in de array aanwezige elementen te voorzien van een uniforme waarde [SWS_CORE_01241]. Als parameter accepteert deze een constante referentie const T &u naar het toe te wijzen object en levert geen retourwaarde (void). Het gedrag oriënteert zich aan het gebruik in [array], zodat vermoedelijk alle elementen synchroon door middel van kopieertoewijzing op de waarde u worden gezet. Vraag Q-927b1702cfa40906 (open)
Foutafhandeling en exception-veiligheid
Volgens de specificatie is de functie geclassificeerd als voorwaardelijk uitzonderingsveilig (conditionally exception safe) [SWS_CORE_01241]. Dit wordt gerealiseerd via de aanduiding noexcept(std::is_nothrow_copy_assignable<T>::value). Specifieke foutcodes, een foutstatus als retourwaarde of DET-/DEM-meldingen zijn niet voorzien; excepties treden alleen op wanneer de kopieertoewijzing van het type T faalt en niet als noexcept is gedeclareerd.
Gelijktijdigheid en integratie
Voor integratie moet de header #include "ara/core/array.h" worden geïncludeerd [SWS_CORE_01241]. Aangezien fill de toestand van het aanroepende object modificeert, is bij gelijktijdige toegang door meerdere threads vermoedelijk externe synchronisatie noodzakelijk om dataconflikten te vermijden. Vraag (open)
Deze tekst is gecureerd door een AI en is uitsluitend gebaseerd op de specificatiegegevens van 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 · Duits origineel