Speichert typsicher genau einen Wert aus einer definierten Typmenge mit bedingter Ausnahmesicherheit.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 223b5b60b80cHerkunftOffene Fragen (2)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Speichert typsicher genau einen Wert aus einer definierten Typmenge mit bedingter Ausnahmesicherheit.
Die Template-Klasse ara::core::Variant dient als typsichere Union zur Speicherung und Verwaltung genau eines Wertes aus einer vorgegebenen Typenmenge [SWS_CORE_01649]. Sie unterstützt flexible Konstruktions-, Zuweisungs- und Emplace-Mechanismen und erlaubt die Bestimmung der aktiven Alternative über index()[SWS_CORE_01665]. Wichtigste Besonderheit gegenüber dem Standard sind die modifizierten, bedingten Noexcept-Spezifikationen sämtlicher modifizierender Operationen sowie die Absicherung gegen den Zustand valueless_by_exception()[SWS_CORE_01666].
Kontext
Die Template-Klasse ara::core::Variant stellt eine typsichere Union für die AUTOSAR Adaptive Platform dar, die über den Header ara/core/variant.h eingebunden wird. Sie kapselt die Verwaltung genau eines Wertes aus einer zur Übersetzungszeit definierten Typenliste (template <typename... Types> class Variant). Die Definition orientiert sich grundlegend am Verhalten von std::variant aus dem C++-Standard [variant], weist jedoch spezifische AUTOSAR-Abweichungen hinsichtlich der Ausnahmespezifikation auf. Die Beschreibung der Klasse verweist im Metadatenbestand auf [basic.string]; Interpretation: hierbei dürfte es sich um eine redaktionelle Unstimmigkeit handeln, da sämtliche Anforderungen konsistent den Standardabschnitt [variant] referenzieren. Frage Q-809de1af74fcb689 (offen)
Lebenszyklus
Eine Instanz von ara::core::Variant durchläuft deterministische Lebenszyklusphasen von der Initialisierung über Wertwechsel bis zur Zerstörung. Die Erzeugung erfolgt entweder über den parameterlosen Default-Konstruktor [SWS_CORE_01649], der die erste Alternative initialisiert, über Kopier- und Verschiebekonstruktoren [SWS_CORE_01650], [SWS_CORE_01651] oder über direkte Wertübergabe [SWS_CORE_01652]. Zudem stehen Überladungen für die In-Place-Konstruktion mittels in_place_type_t[SWS_CORE_01653], [SWS_CORE_01654] sowie in_place_index_t[SWS_CORE_01655], [SWS_CORE_01656] zur Verfügung, auch in Kombination mit Initialisierungslisten.
Im regulären Zustand hält das Objekt stets eine gültige Alternative, deren nullbasierter Index mit der Methode index() ermittelt werden kann [SWS_CORE_01665]. Scheitert ein Wertwechsel während einer Konstruktion oder Zuweisung durch das Auslösen einer Ausnahme, geht die Instanz in den Zustand valueless_by_exception() über [SWS_CORE_01666]. Das Objekt verbleibt in diesem Zustand, bis durch eine erfolgreiche Neuinitialisierung wieder eine gültige Alternative belegt wird. Der Destruktor zerstört das aktuell gehaltene Objekt ordnungsgemäß und ist bedingt ausnahmesicher deklariert [SWS_CORE_01657].
Ein typischer Nutzungsablauf umfasst die Instanziierung, das Zuweisen oder Ersetzen des Inhalts, die Abfrage des Zustands und den Werteaustausch:
Initialisierung: Erzeugung einer Instanz über einen der Konstruktoren, beispielsweise per direkter Wertübergabe [SWS_CORE_01652] oder explizit typbezogen mittels in_place_type_t[SWS_CORE_01653].
Zustandsprüfung: Abfrage des aktiven Typindex über index()[SWS_CORE_01665] sowie Absicherung gegen vorherige Fehler über valueless_by_exception()[SWS_CORE_01666].
Objekttausch: Effizienter Austausch zweier Variant-Instanzen über die Elementfunktion swap()[SWS_CORE_01667].
Da das vorliegende Spezifikations-Record-Set ausschließlich Elementfunktionen umfasst, fehlen direkte Leseoperationen wie ein Wertzugriff; vermutlich werden Zugriffs- und Besuchsfunktionen (analog zu std::get oder std::visit) als freie Hilfsfunktionen im Namensraum ara::core bereitgestellt. Frage Q-75847ac18088da57 (offen)
Fehlerszenarien
Im Zentrum der Fehlerbehandlung steht die Eigenschaft der bedingten Ausnahmesicherheit (conditionally exception safe). Während die Standardbibliothek für std::variant feste Noexcept-Regeln vorsieht, weicht AUTOSAR gezielt ab: Sämtliche Konstruktoren [SWS_CORE_01650], [SWS_CORE_01653], Zuweisungsoperatoren [SWS_CORE_01658], emplace-Operationen [SWS_CORE_01661], [SWS_CORE_01663], die Tauschfunktion swap()[SWS_CORE_01667] sowie der Destruktor [SWS_CORE_01657] sind bedingt noexcept. Ihre Ausnahmegarantie hängt direkt von den Noexcept-Eigenschaften der zugrundeliegenden Typkonstruktoren ab.
Wirft die Konstruktion eines neuen Wertes während einer Zuweisung oder eines emplace-Aufrufs eine Ausnahme, kann die Variante in einen ungültigen Zwischenzustand geraten. Dieser wird über valueless_by_exception() signalisiert [SWS_CORE_01666]. Ausschließlich die beiden Abfragefunktionen index()[SWS_CORE_01665] und valueless_by_exception()[SWS_CORE_01666] bieten eine uneingeschränkte noexcept-Garantie und sind vollständig ausnahmesicher.
Dieser Leitfaden basiert auf der AUTOSAR-Spezifikation für die Adaptive Platform (Release R25-11, Modul core) und wurde durch einen KI-Kurations-Assistenten aufbereitet.
As per corresponding usage in [variant] except for the following deviations: 1. Function is conditionally noexcept
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 0fe1e0b61069HerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die Elementfunktion emplace konstruiert einen alternativen Wert des Typs T direkt in einer bestehenden Instanz von ara::core::Variant[SWS_CORE_01661]. Die Funktion wird über die Header-Datei #include "ara/core/variant.h" bereitgestellt und synchron ausgeführt [SWS_CORE_01661]. Als Parameter übernimmt sie Weiterleitungsreferenzen args..., die an den Konstruktor des Zieltyps T übergeben werden, und gibt eine Referenz auf das neu erzeugte Objekt zurück [SWS_CORE_01661].
Bezüglich der Fehlerbehandlung ist die Operation als bedingt ausnahmesicher („conditionally exception safe“) deklariert [SWS_CORE_01661]. Sie folgt dem Standardverhalten von variant, weicht jedoch durch eine bedingte noexcept-Spezifikation ab: Eine Ausnahme wird genau dann ausgeschlossen, wenn std::is_nothrow_constructible<T, Args...>::value erfüllt ist [SWS_CORE_01661]. Spezifische AUTOSAR-Fehlercodes oder Meldungen an DET oder DEM sind für diese Basisfunktion nicht definiert.
Hinsichtlich Nebenläufigkeit und Aufrufkontext nennt die Spezifikation keine abweichenden Garantien. Interpretation: Der gleichzeitige schreibende Zugriff mehrerer Threads auf dieselbe Variant-Instanz via emplace dürfte ohne externe Synchronisation nicht threadsicher sein, da AUTOSAR auf die Standardsemantik von variant verweist. Frage Q-4d9d118b9916a3dc (offen)
As per corresponding usage in [variant] except for the following deviations: 1. Function is conditionally noexcept
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: a346c9068921HerkunftOffene Fragen (2)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die Elementfunktion emplace von ara::core::Variant aus dem Header ara/core/variant.h dient der synchronen Erzeugung einer Alternative vom Typ T direkt im Speicher der bestehenden Instanz [SWS_CORE_01662]. Hierbei werden eine std::initializer_list<U> sowie weitergeleitete Argumente Args&&... args an den Konstruktor des Typs übergeben. Als Rückgabewert liefert die Funktion eine lvalue-Referenz T& auf das neu initialisierte Objekt [SWS_CORE_01662].
Hinsichtlich der Fehlerbehandlung und Ausnahmebehandlung weicht die Funktion von der Standarddefinition in [variant] ab: Sie ist als bedingt ausnahmesicher (conditionally exception safe) eingestuft und verfügt über eine bedingte noexcept-Spezifikation [SWS_CORE_01662]. Ein Aufruf garantiert Ausnahmefreiheit, sofern std::is_nothrow_constructible<T, std::initializer_list<U>&, Args&&...>::value zu true evaluiert [SWS_CORE_01662]. Spezifische AUTOSAR-Fehlercodes oder Meldekanäle an DET und DEM existieren für dieses Element nicht.
In Bezug auf Nebenläufigkeit und Randbedingungen gilt: Da emplace den Zustand der Variant-Instanz verändert, dürfte ein nebenläufiger Aufruf ohne externe Synchronisation nicht threadsicher sein. Interpretation: Vor der Konstruktion des neuen Objekts wird ein zuvor enthaltener Wert zerstört, wie es dem allgemeinen Verhalten von [variant] entspricht. Frage Q-548c84cc1d327030 (offen)
Im Zusammenspiel mit verwandten Schnittstellen bildet die Funktion das typbasierte Gegenstück zur Überladung ohne Initialisierungsliste [SWS_CORE_01661] sowie zu den indexbasierten Alternativen [SWS_CORE_01663] und [SWS_CORE_01664]. Ähnliche Schnittstellenkonzepte finden sich bei ara::core::Optional[SWS_CORE_01120] sowie bei Containern wie ara::core::Vector[SWS_CORE_01366] oder ara::core::Map[SWS_CORE_01458], wobei Container-Emplace-Operationen im Unterschied hierzu nicht ausnahmesicher sind.
Dieser Nutzungshinweis wurde automatisch auf Basis der Spezifikationsdaten von AUTOSAR R25-11 erstellt.
template <std::size_t I, typename... Args> variant_alternative_t< I, Variant< Types... > > & emplace (Args &&... args) noexcept({<cond-noexcept-11>});
As per corresponding usage in [variant] except for the following deviations: 1. Function is conditionally noexcept
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: f8cbed1f17b1HerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die Elementfunktion emplace der Klasse ara::core::Variant ([SWS_CORE_01663]) aus der Header-Datei ara/core/variant.h dient der direkten Konstruktion der durch den Template-Index I bestimmten Alternative im bestehenden Speicher des Objekts. Als Parameter werden die Argumente Args&&... args übergeben. Der Aufruf erfolgt synchron und liefert eine Referenz auf den neu erzeugten Wert vom Typ variant_alternative_t<I, Variant<Types...>> zurück ([SWS_CORE_01663]). Das Verhalten richtet sich nach der Definition in [variant] ([SWS_CORE_01663]).
Fehlerbehandlung und Exception-Sicherheit
Die Spezifikation definiert als Abweichung vom C++-Standard eine bedingte noexcept({<cond-noexcept-11>})-Klausel sowie die Eigenschaft conditionally exception safe ([SWS_CORE_01663]). Vermutlich hängt das Auslösen von Ausnahmen davon ab, ob der Konstruktor der Zielalternative für die weitergereichten Typen Args... ausnahmesicher ist. Frage Q-189fe417e9ef4980 (offen) Spezifische Fehlercodes, Rückgabewerte im Fehlerfall oder Benachrichtigungen an DET oder DEM sind für diese Funktion nicht spezifiziert.
Zusammenspiel und Alternativen
Innerhalb des Moduls core und des Typs ara::core::Variant ist die Funktion in ein System weiterer Überladungen eingebettet:
Indexbasierte Initialisierung mit einer std::initializer_list unter [SWS_CORE_01664].
Typbasierte Erzeugung einer Alternative über den Typnamen T mittels [SWS_CORE_01661] bzw. in Kombination mit std::initializer_list via [SWS_CORE_01662].
template <std::size_t I, typename U, typename... Args> variant_alternative_t< I, Variant< Types... > > & emplace (std::initializer_list< U > il, Args &&... args) noexcept( {<cond-noexcept-12>});
As per corresponding usage in [variant] except for the following deviations: 1. Function is conditionally noexcept
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: a600ca3cb60dHerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die Elementfunktion emplace aus ara/core/variant.h konstruiert synchron einen neuen Alternativwert direkt an Ort und Stelle innerhalb einer bestehenden Instanz von ara::core::Variant[SWS_CORE_01664]. Der anzusprechende Typ wird dabei fest über den Template-Index I bestimmt. Der Aufruf nimmt eine Initialisiererliste il des Typs std::initializer_list<U> sowie optionale Argumente args entgegen und liefert eine Referenz auf den neu erzeugten Wert vom Typ variant_alternative_t<I, Variant<Types...>>& zurück [SWS_CORE_01664].
Für die Fehlerbehandlung ist die Operation als bedingt ausnahmesicher (conditionally exception safe) eingestuft und mit einem bedingten noexcept versehen [SWS_CORE_01664]. Die Auswertung der Bedingung {<cond-noexcept-12>} dürfte vermutlich davon abhängen, ob der Konstruktor des Zieltyps mit il und args keine Exceptions wirft. Frage Q-87f90253fc61c883 (offen) Spezifische Fehlercodes sowie Meldungen an DET oder DEM sind in der Spezifikation nicht definiert; das Verhalten bei Ausnahmen folgt bis auf die noexcept-Deklaration dem Standardverhalten von [variant][SWS_CORE_01664].
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: fb0fc41b4094HerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die Elementfunktion index der Klasse ara::core::Variant dient zur synchronen Abfrage des nullbasierten Index des aktuell gehaltenen Typs gemäß Spezifikation [SWS_CORE_01665]. Sie verhält sich analog zur entsprechenden Verwendung im Standard-C++-Typ std::variant („As per corresponding usage in [variant]“), nimmt keine Parameter entgegen und liefert den aktuellen Index als std::size_t zurück. Deklariert ist sie im Header ara/core/variant.h und als constexpr sowie noexcept qualifiziert.
Hinsichtlich der Fehlerbehandlung und Ausnahme-Sicherheit ist die Methode als exception safe spezifiziert [SWS_CORE_01665]. Da sie als noexcept deklariert ist, wirft sie selbst keine Ausnahmen und löst keine Fehlerbedingungen aus. Aufrufer können den zurückgegebenen Index auswerten, um vor dem Zugriff auf alternative Werte sicherzustellen, welcher Typ im ara::core::Variant aktiv ist.
Im Zusammenspiel mit den typisierten Zugriffsfunktionen ara::core::get spielt index eine zentrale Rolle: Die Überladungen von get für lvalues und rvalues prüfen explizit die Bedingung variant.index() != I gemäß [SWS_CORE_01613], [SWS_CORE_01614], [SWS_CORE_01615] und [SWS_CORE_01616]. Stimmt der Index nicht mit dem angeforderten Positionsindex I überein, wird abweichend von std::bad_variant_access die Verletzung IsoStdBadVariantAccessViolation ausgelöst. Ein vorheriger Abgleich mittels index() verhindert diesen fehlerhaften Zugriff zur Laufzeit.
Bezüglich der Nebenläufigkeit ist die Methode als const-Operation für nebenläufige Lesezugriffe auf denselben Variant sicher, solange keine konkurrierenden Modifikationen stattfinden; eine interne Synchronisation gegen parallele Schreibzugriffe dürfte nicht vorliegen. Frage Q-12e0dad0a6b8c5d0 (offen)
Dieser Text wurde von einer KI auf Basis der Spezifikation AUTOSAR R25-11 generiert.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 015c4319d2b5HerkunftOffene Fragen (2)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die Elementfunktion valueless_by_exception der Klasse ara::core::Variant wird im Modul core über die Header-Datei #include "ara/core/variant.h" bereitgestellt ([SWS_CORE_01666]). Entsprechend ihrer Signatur constexpr bool valueless_by_exception () const noexcept; erfordert sie keine Aufrufparameter und liefert synchron einen Wahrheitswert zurück ([SWS_CORE_01666]). Die funktionale Bedeutung richtet sich nach der üblichen Semantik von [variant] („As per corresponding usage in [variant]“) ([SWS_CORE_01666]). Interpretation: Der zurückgegebene Status true signalisiert dem Aufrufer vermutlich, dass eine vorherige Wertzuweisung oder Typänderung durch das Auftreten einer Ausnahme abgebrochen wurde und das Variant-Objekt daher temporär keinen gültigen Zustand repräsentiert. Frage Q-af7c00c7eb4ef5a1 (offen)
Fehlerbehandlung und Exception-Sicherheit
Hinsichtlich des Fehlerverhaltens ist die Methode als noexcept deklariert und formal als exception safe eingestuft ([SWS_CORE_01666]). Ein eigener Fehlerfall existiert bei der Abfrage nicht; die Funktion wirft keine C++-Exceptions ([SWS_CORE_01666]). Spezifische Fehlercodes, Rückmeldebeschreibungen oder Meldungen an Diagnose- und Fehlerüberwachungsinstanzen wie DET oder DEM sind für dieses Element nicht definiert ([SWS_CORE_01666]).
Nebenläufigkeit und Einschränkungen
Da valueless_by_exception als const- und constexpr-Methode spezifiziert ist, erfolgen während der Ausführung keinerlei modifizierende Zugriffe auf den internen Zustand des Objekts ([SWS_CORE_01666]). Interpretation: Gleichzeitige lesende Abfragen derselben Instanz aus mehreren Threads dürften ohne gesonderte Synchronisation sicher ausführbar sein, solange konkurrierende Schreiboperationen ausgeschlossen bleiben. Frage Q-5c28f8cef1c1f097 (offen)
Dieser Nutzungshinweis wurde automatisiert auf Basis von AUTOSAR R25-11 generiert.
gemini-3.8-flash-medium· 2026-10-13