klasse ara::core::UnsynchronizedPoolResource

De declaratie van de copy constructor als verwijderd (=delete) in ara::core::UnsynchronizedPoolResource conform [SWS_CORE_00046] voorkomt elke duplicatie van een pool-instantie. Voor de objectcreatie staan in plaats daarvan specifieke constructors ter beschikking, zoals zonder argumenten [SWS_CORE_00063], met specificatie van een upstream-geheugenresource [SWS_CORE_00064], met PoolOptions [SWS_CORE_00068] of met beide parameters [SWS_CORE_00067].

Voor het gebruik en het runtimegedrag gelden de volgende randvoorwaarden:

• Aanroep en foutafhandeling: een kopieerpoging wordt al tijdens compileertijd door de compiler afgewezen als fout. Allocatiefouten bij het latere geheugengebruik via do_allocate leiden niet tot excepties, maar leveren nullptr op [SWS_CORE_00058], terwijl vrijgavefouten in do_deallocate stilzwijgend worden genegeerd [SWS_CORE_00059].
• Gelijktijdigheid: afzonderlijke geheugenoperaties op de instantie zijn als niet-draadveilig gedeclareerd [SWS_CORE_00058], [SWS_CORE_00059]. Interpretatie: het verwijderen van de copy constructor waarborgt vermoedelijk de exclusieve verantwoordelijkheid voor de beheerde geheugenblokken en voorkomt inconsistente toestanden bij parallel gebruik of voortijdige vrijgave via release [SWS_CORE_00065]. Vraag Q-d97dd87dddb2379d (open)
• Samenspel: de restrictie correspondeert met de eveneens verwijderde toekenningsoperator [SWS_CORE_00047]. De destructor van de klasse is niet virtueel uitgevoerd [SWS_CORE_00062], terwijl identiteitscontroles via do_is_equal [SWS_CORE_00060] kunnen worden uitgevoerd.

De kopietoewijzingsoperator van ara::core::UnsynchronizedPoolResource is conform [SWS_CORE_00047] expliciet gedeclareerd als verwijderd (=delete). Het toewijzen van de ene instantie aan de andere is daarmee syntactisch uitgesloten en leidt reeds tijdens compileertijd tot een compilerfout. Samen met de eveneens verwijderde kopieerconstructor [SWS_CORE_00046] waarborgt dit dat instanties van de resourceklasse noch gekopieerd, noch door toewijzing vermenigvuldigd kunnen worden. Interpretatie: dit zal vermoedelijk voorkomen dat interne geheugenblokken en beheergegevens meervoudig worden gerefereerd of foutief worden vrijgegeven. Vraag Q-75cee08bebc61976 (open)

Nieuwe instanties worden in plaats daarvan aangemaakt via de beschikbare constructors, bijvoorbeeld parameterloos via [SWS_CORE_00063], met upstream-resource via [SWS_CORE_00064] of onder opgave van PoolOptions via [SWS_CORE_00067] respectievelijk [SWS_CORE_00068]. De gekoppelde upstream-resource kan via [SWS_CORE_00056] en de configuratie-opties kunnen via [SWS_CORE_00057] worden opgevraagd. Beheerd geheugen kan met [SWS_CORE_00065] expliciet worden vrijgegeven voordat de levensduur met de niet-virtuele destructor [SWS_CORE_00062] eindigt.

Aangezien toewijzingen door [SWS_CORE_00047] zijn uitgesloten, moeten instanties desgewenst via referentie of pointer worden doorgegeven. Hierbij dient in acht te worden genomen dat allocaties via [SWS_CORE_00058] en deallocaties via [SWS_CORE_00059] gespecificeerd zijn als niet-thread-safe. Mislukt een geheugenaanvraag, dan wordt er geen exceptie geactiveerd, maar wordt nullptr geretourneerd [SWS_CORE_00058]; fouten bij de deallocatie worden stilzwijgend genegeerd [SWS_CORE_00059].

Gebruik

De methode upstream_resource() van de klasse ara::core::UnsynchronizedPoolResource retourneert synchroon een pointer naar de bovenliggende MemoryResource [SWS_CORE_00056]. De aanroep is parameterloos en gedeclareerd als const. Invoeging en typedefinities vinden plaats via het headerbestand #include "ara/core/memory_resource.h" [SWS_CORE_00056].

Foutafhandeling

De functie is gespecificeerd als noexcept en exception safe [SWS_CORE_00056]. Deze genereert geen excepties en meldt noch specifieke foutcodes noch DET- of DEM-gebeurtenissen. Mocht de voorafgaande initialisatie via constructors mislukken, dan zijn deze deels niet uitzonderingsveilig [SWS_CORE_00063], terwijl de opvraag zelf altijd foutloos blijft.

Gelijktijdigheid en beperkingen

De methode upstream_resource() is expliciet geclassificeerd als thread-safe [SWS_CORE_00056]. Dit staat in tegenstelling tot de interne allocatieroutines do_allocate() [SWS_CORE_00058] en do_deallocate() [SWS_CORE_00059], die gespecificeerd zijn als not thread-safe. Bovendien zijn de kopieerconstructor en toewijzingsoperator van de klasse verwijderd [SWS_CORE_00046], [SWS_CORE_00047].

Samenspel

De methode werkt nauw samen met de constructors van UnsynchronizedPoolResource, waaraan optioneel een bovenliggende MemoryResource kan worden meegegeven [SWS_CORE_00064], [SWS_CORE_00067]. Interpretatie: de geretourneerde pointer verwijst vermoedelijk exact naar de bij de instantiëring vastgelegde instantie van MemoryResource. Vraag Q-aefbc7d0f7d085d1 (open) Verdere eigenschappen van de pool-resource kunnen via options() worden opgevraagd [SWS_CORE_00057], terwijl gealloceerd geheugen via release() kan worden vrijgegeven [SWS_CORE_00065].

Gebruik

De lidfunctie options() van de klasse ara::core::UnsynchronizedPoolResource dient voor het synchroon opvragen van de geheugenpoolconfiguratie [SWS_CORE_00057]. De methode is gedeclareerd in #include "ara/core/memory_resource.h", verwacht geen overdrachtsparameters en retourneert een instantie van het type PoolOptions als waarde [SWS_CORE_00057]. Als const-gekwalificeerde functie modificeert zij het object niet en gedraagt zij zich conform de specificatie in [mem.res.pool] [SWS_CORE_00057].

Foutafhandeling en uitzonderingsveiligheid

De interface is gedefinieerd als noexcept en garandeert volledige uitzonderingsveiligheid (exception safe) [SWS_CORE_00057]. Er worden geen exceptions geworpen en er bestaan geen foutretourwaarden; het opvragen van de opties slaagt altijd foutloos.

Gelijktijdigheid en beperkingen

In de specificatie is options() aangeduid als thread-veilig (thread-safe) [SWS_CORE_00057]. Dit staat in contrast met allocatiefuncties van dezelfde klasse zoals do_allocate [SWS_CORE_00058] en do_deallocate [SWS_CORE_00059], die expliciet niet thread-veilig zijn. De methode kan zodoende gelijktijdig met toestandsopvragingen worden uitgevoerd.

Samenspel

De geretourneerde PoolOptions weerspiegelen vermoedelijk de parameters waarmee de pool-resource via overeenkomstige constructors is geparametriseerd [SWS_CORE_00067], [SWS_CORE_00068], of representeren de standaardopties bij gebruik van default-constructors [SWS_CORE_00063], [SWS_CORE_00064]. Vraag Q-19fa8ad6e3e6b1c6 (open) Naast options() staat voor inspectie ook de functie upstream_resource() ter beschikking [SWS_CORE_00056], terwijl kopieeroperaties van de resource door verwijderde operatoren worden verhinderd [SWS_CORE_00046], [SWS_CORE_00047].

Gebruik

De methode do_allocate van de klasse ara::core::UnsynchronizedPoolResource allokeert geheugen voor de gevraagde bytegrootte (bytes) en uitlijning (alignment) [SWS_CORE_00058]. Interpretatie: aangezien de methode is gespecificeerd met beschermde zichtbaarheid (protected), wordt deze in de reguliere afloop vermoedelijk niet rechtstreeks vanuit applicatiecode aangeroepen, maar indirect via de allocatie-interface van de basisklasse. Vraag Q-5a702813496f8071 (open) De declaratie vindt plaats via het headerbestand #include "ara/core/memory_resource.h" [SWS_CORE_00058].

Foutafhandeling

In afwijking van het standaardgedrag volgens [mem.res.pool] is de functie gedeclareerd als noexcept en werpt bij allocatiefouten geen uitzondering zoals std::bad_alloc [SWS_CORE_00058]. In plaats daarvan retourneert deze in het geval van mislukking dwingend nullptr [SWS_CORE_00058]. Aanroepende code moet het resultaat bijgevolg altijd expliciet controleren op een null-pointer.

Gelijktijdigheid en beperkingen

De functie is geclassificeerd als not thread-safe [SWS_CORE_00058]. Parallelle aanroepen op dezelfde instantie van UnsynchronizedPoolResource zijn zonder externe synchronisatie niet toegestaan. Copy constructor en toekenningsoperator van de klasse zijn verwijderd (delete), zodat instanties niet kunnen worden gekopieerd ([SWS_CORE_00046], [SWS_CORE_00047]).

Samenspel

Voor het vrijgeven van geheugen bestaat de tegenhanger do_deallocate, die eveneens beschermd, noexcept en niet-draadveilig is ontworpen en fouten stilzwijgend negeert [SWS_CORE_00059]. De pool gebruikt intern de bij de instantiëring geconfigureerde upstream-resource ([SWS_CORE_00056], [SWS_CORE_00064], [SWS_CORE_00067]). Met release() kan het door de pool verkregen geheugen gebundeld worden vrijgegeven [SWS_CORE_00065].

Gebruik

De virtuele lidfunctie do_deallocate is gedeclareerd als protected binnen de scope van ara::core::UnsynchronizedPoolResource (header #include "ara/core/memory_resource.h") [SWS_CORE_00059]. Deze verzorgt de synchrone deallocatie van een geheugenblok aan de hand van de meegegeven parameters p (pointer naar het geheugengebied), bytes (grootte in bytes) en alignment (uitlijning). Interpretatie: als beschermde methode vindt de aanroep vermoedelijk typisch indirect plaats via de publieke interface van de geheugenresource. Vraag Q-f4992f515c10ee01 (open)

Foutafhandeling

Ten opzichte van het standaardgedrag in [mem.res.pool] vertoont de functie twee specifieke afwijkingen: deze is gedeclareerd als noexcept en daarmee uitzonderingsveilig [SWS_CORE_00059]. Mislukt de deallocatie, dan worden fouten stilzwijgend genegeerd (errors will be silently ignored); er bestaat noch een foutcode noch een afzonderlijke foutmelding.

Gelijktijdigheid en beperkingen

De operatie is expliciet aangemerkt als niet-draadveilig (not thread-safe) [SWS_CORE_00059]. Worden geheugengebieden van dezelfde resource-instantie vanuit meerdere threads vrijgegeven, dan moet de toegang dwingend extern worden gesynchroniseerd.

Samenspel

De methode complementeert do_allocate [SWS_CORE_00058], die eveneens is gespecificeerd als noexcept en niet-draadveilig en bij mislukking nullptr retourneert. Om het volledige gereserveerde geheugen van de pool integraal vrij te geven, staat de draadveilige methode release ter beschikking [SWS_CORE_00065]. Instanties van de klasse zijn niet kopieerbaar, aangezien copy constructor [SWS_CORE_00046] en toekenningsoperator [SWS_CORE_00047] zijn verwijderd.

De protected memberfunctie do_is_equal van de klasse ara::core::UnsynchronizedPoolResource voert de gelijkheidsvergelijking voor geheugenbronnen conform [SWS_CORE_00060] uit. Ze wordt via de header ara/core/memory_resource.h beschikbaar gesteld. Aangezien de methode de zichtbaarheid protected heeft, is ze bedoeld voor de interne aanroep via de basisklasse MemoryResource ([SWS_CORE_00060]). Ze vergelijkt de huidige instantie synchroon met een meegegeven referentie van het type MemoryResource en retourneert een bool-waarde ([SWS_CORE_00060]). Conform [mem.res.pool] controleert de vergelijking typisch op de identiteit van beide bronnen (this == &other), aangezien geheugenpools geïsoleerd opereren. Vraag Q-679a5e17d2e2903f (open)

De methode is gedeclareerd als noexcept en heeft de specificatie exception safe ([SWS_CORE_00060]). Ze genereert geen uitzonderingen en gebruikt geen DET- of DEM-foutmeldingen.

Met betrekking tot gelijktijdigheid is do_is_equal geclassificeerd als thread-safe ([SWS_CORE_00060]). Omdat ze als constante memberfunctie uitsluitend lezend werkt, kan ze gelijktijdig door meerdere threads worden aangeroepen. Dit staat in tegenstelling tot allocatie-operaties zoals do_allocate ([SWS_CORE_00058]) en do_deallocate ([SWS_CORE_00059]), die expliciet niet thread-veilig zijn.

In het samenspel van de geheugenbronnen is de klasse noch kopieerbaar, noch toewijsbaar ([SWS_CORE_00046], [SWS_CORE_00047]). Instanties kunnen worden geïnitialiseerd via constructors zoals [SWS_CORE_00063], [SWS_CORE_00064], [SWS_CORE_00067] of [SWS_CORE_00068]. Bovenliggende geheugenbronnen kunnen worden opgevraagd met upstream_resource() ([SWS_CORE_00056]), terwijl vóór het vernietigen ([SWS_CORE_00062]) het bezette geheugen kan worden vrijgegeven middels release() ([SWS_CORE_00065]).

De destructor ~UnsynchronizedPoolResource() ([SWS_CORE_00062]) beëindigt de levensduur van een instantie van de geheugenklasse ara::core::UnsynchronizedPoolResource uit de header ara/core/memory_resource.h. De aanroep verloopt synchroon en is gedeclareerd als noexcept, waarmee de operatie uitzonderingsveilig is ([SWS_CORE_00062]).

De semantiek komt in principe overeen met het poolgebruik in [mem.res.pool], maar vertoont een wezenlijke afwijking: de destructor is niet virtueel ([SWS_CORE_00062]). Interpretatie: uit het niet-virtueel zijn van de destructor volgt vermoedelijk dat instanties niet polymorf via een basisklassepointer naar MemoryResource mogen worden vrijgegeven. Vraag Q-5578b2bf008b98c5 (open)

Wat betreft de levenscyclus en het samenspel gelden de volgende voorwaarden:

• Resourcebeheer: bij vernietiging van de instantie wordt het beheerde geheugen vrijgegeven, analoog aan de expliciete vrijgave via release() ([SWS_CORE_00065]) in de richting van de bovenliggende resource ([SWS_CORE_00056]).
• Concurrency: hoewel de destructor zelf als thread-safe is geclassificeerd ([SWS_CORE_00062]), zijn de interne allocatieroutines do_allocate ([SWS_CORE_00058]) en do_deallocate ([SWS_CORE_00059]) aangeduid als niet thread-safe. De aanroep van de destructor mag daarom niet gelijktijdig plaatsvinden met allocatieprocessen van dezelfde instantie.
• Aanmaak en kopiëren: instanties kunnen met of zonder opties en upstream-resource worden geconstrueerd ([SWS_CORE_00063], [SWS_CORE_00064], [SWS_CORE_00067], [SWS_CORE_00068]). Copy constructor en copy assignment operator zijn verwijderd ([SWS_CORE_00046], [SWS_CORE_00047]).

De parameterloze standaardconstructor [SWS_CORE_00063] initialiseert een instantie van ara::core::UnsynchronizedPoolResource volgens de semantiek uit [mem.res.pool]. Interpretatie: hierbij worden vermoedelijk standaard pool-opties en een standaard upstream-geheugenresource gebruikt, die later via [SWS_CORE_00057] en [SWS_CORE_00056] kunnen worden opgevraagd. Vraag Q-d76bae1c251fa516 (open)

Wat betreft de levenscyclus en het gebruik gelden de volgende randvoorwaarden:

• Kopieerbeveiliging en overbelasting: Copy constructor [SWS_CORE_00046] en toekenningsoperator [SWS_CORE_00047] zijn verwijderd (delete). Naast de parameterloze instantiëring staan overbelaste constructors met expliciete pool-opties of upstream-resources ter beschikking ([SWS_CORE_00064], [SWS_CORE_00067], [SWS_CORE_00068]).
• Foutafhandeling en exception-veiligheid: De constructor is gedeclareerd als niet-uitzonderingsveilig (not exception safe) [SWS_CORE_00063]. Bij later geheugengebruik wijken de geheugenbewerkingen af van standaarduitzonderingen: do_allocate levert in geval van een fout nullptr in plaats van een exceptie [SWS_CORE_00058], terwijl do_deallocate fouten stilzwijgend negeert [SWS_CORE_00059].
• Concurrency: De constructoraanroep zelf is thread-safe [SWS_CORE_00063]. De latere toekennings- en vrijgavebewerkingen van de aangemaakte instantie (do_allocate, do_deallocate) zijn echter expliciet gespecificeerd als niet thread-safe (not thread-safe) ([SWS_CORE_00058], [SWS_CORE_00059]).
• Resourcevrijgave en destructie: Toegewezen geheugen kan via [SWS_CORE_00065] worden vrijgegeven. De destructor is noexcept, maar niet-virtueel geïmplementeerd [SWS_CORE_00062].

Gebruik en doel

De constructor explicit UnsynchronizedPoolResource (MemoryResource *upstream) initialiseert een instantie van de klasse ara::core::UnsynchronizedPoolResource uit het headerbestand #include "ara/core/memory_resource.h" conform [mem.res.pool] [SWS_CORE_00064]. Via de parameter upstream wordt de bovenliggende geheugenresource doorgegeven, die later via de methode upstream_resource() kan worden opgevraagd [SWS_CORE_00056]. Als alternatieven zijn een parameterloze standaardconstructor [SWS_CORE_00063] en overbelastingen met PoolOptions beschikbaar [SWS_CORE_00067], [SWS_CORE_00068].

Foutafhandeling en uitzonderingsgedrag

De instantiëring is gespecificeerd als not exception safe [SWS_CORE_00064], zodat tijdens de constructie uitzonderingen kunnen optreden. Voor nageschakelde geheugenallocaties gelden afwijkende regels: de interne allocatiefunctie do_allocate werpt geen exceptie op, maar retourneert bij mislukkingen nullptr [SWS_CORE_00058], terwijl fouten bij do_deallocate stilzwijgend worden genegeerd [SWS_CORE_00059].

Gelijktijdigheid en beperkingen

De constructoraanroep zelf geldt als thread-safe [SWS_CORE_00064]. Kopieerbewerkingen zijn uitgesloten, aangezien zowel de copy-constructor [SWS_CORE_00046] als de toewijzingsoperator [SWS_CORE_00047] zijn verwijderd. Na de constructie zijn de allocatie- en deallocatiebewerkingen niet thread-safe [SWS_CORE_00058], [SWS_CORE_00059]. Bovendien is de destructor niet-virtueel gedeclareerd [SWS_CORE_00062]. Bezet geheugen kan via release() voortijdig worden vrijgegeven [SWS_CORE_00065]. Interpretatie: aangezien er een native pointer upstream wordt doorgegeven, moet de gerefereerde upstream-resource vermoedelijk gedurende de gehele levensduur van de pool-instantie geldig blijven. Vraag Q-3e6c23bae834b912 (open)

Gebruik

De lidfunctie release() behoort tot de scope van de klasse ara::core::UnsynchronizedPoolResource en wordt gedeclareerd via het headerbestand ara/core/memory_resource.h [SWS_CORE_00065]. De functie heeft geen overdrachtsparameters en geen retourwaarde (void). Haar functionele semantiek richt zich naar de C++-standaard [mem.res.pool] [SWS_CORE_00065]; de verwijzing betekent vermoedelijk dat de functie synchroon al het geheugen dat via de pool-instantie is gealloceerd, teruggeeft aan de voorgeschakelde geheugenresource (upstream_resource()) [SWS_CORE_00056]. Vraag Q-e0c7e00cde5d5a34 (open)

Foutafhandeling

De functie is gedefinieerd als noexcept en als exception safe [SWS_CORE_00065]. Deze genereert bij de uitvoering geen uitzonderingen. Aangezien de specificatie geen specifieke foutcodes of DET-/DEM-meldingen vermeldt, vindt bij fouten tijdens de geheugenvrijgave geen expliciete foutterugmelding via release() plaats.

Gelijktijdigheid en beperkingen

Volgens de specificatie is release() geclassificeerd als thread-safe [SWS_CORE_00065]. Dit staat in contrast met de interne geheugenbeheerfuncties van de klasse: zowel de allocatie door middel van do_allocate [SWS_CORE_00058] als de deallocatie via do_deallocate [SWS_CORE_00059] zijn expliciet aangemerkt als not thread-safe.

Samenspel

De methode interageert nauw met verdere eigenschappen en eisen van de UnsynchronizedPoolResource:

• Geheugenresources: deze geeft het geheugen terug aan de geconfigureerde upstream-resource [SWS_CORE_00056], zonder dat het pool-object zelf hoeft te worden vernietigd, zoals gebeurt bij de destructor ~UnsynchronizedPoolResource() [SWS_CORE_00062].
• Configuratie: het gedrag en de chunk-groottes van de pool zijn afhankelijk van de opties die bij de instantiëring zijn ingesteld [SWS_CORE_00057], [SWS_CORE_00067], [SWS_CORE_00068].
• Kopieerbeveiliging: een duplicatie van de pool is niet toegestaan, aangezien copy constructor [SWS_CORE_00046] en toekenningsoperator [SWS_CORE_00047] verwijderd (delete) zijn.

De constructor [SWS_CORE_00067] initialiseert een instantie van ara::core::UnsynchronizedPoolResource met specifieke pool-opties (opts) en een bovenliggende geheugenresource (upstream). De aanroep vindt synchroon plaats en is gespecificeerd als noexcept, waarmee de objectcreatie uitzonderingsveilig is. Het kopiëren van de instantie is uitgesloten, aangezien zowel de kopieerconstructor [SWS_CORE_00046] als de toewijzingsoperator [SWS_CORE_00047] verwijderd (=delete) zijn.

De opgeslagen instellingen en upstream-resources kunnen tijdens runtime via options() [SWS_CORE_00057] en upstream_resource() [SWS_CORE_00056] worden uitgelezen. Als alternatieven zijn een standaardconstructor [SWS_CORE_00063] en overloads beschikbaar die uitsluitend upstream [SWS_CORE_00064] of opts [SWS_CORE_00068] accepteren. Het bezette geheugen kan via release() [SWS_CORE_00065] of de destructor [SWS_CORE_00062] worden vrijgegeven, waarbij de destructor in afwijking van de standaard niet virtueel is.

Wat betreft gelijktijdigheid is de constructie zelf als thread-safe gedeclareerd [SWS_CORE_00067]. De eigenlijke geheugenbeheerfuncties van de instantie – do_allocate [SWS_CORE_00058] en do_deallocate [SWS_CORE_00059] – zijn daarentegen uitdrukkelijk niet-thread-safe („not thread-safe”) en vereisen bij parallelle toegang externe beveiligingsmechanismen. Fouten worden daarbij zonder excepties verwerkt: mislukte allocaties leveren nullptr [SWS_CORE_00058] op, terwijl deallocatiefouten stilzwijgend worden genegeerd [SWS_CORE_00059]. Interpretatie: het doorgegeven upstream-object moet vermoedelijk gedurende de gehele levenscyclus van de pool geldig blijven. Vraag Q-2439ec8f9fb8bb3e (open)

De constructor [SWS_CORE_00068] dient voor de synchrone initialisatie van een ara::core::UnsynchronizedPoolResource onder vermelding van specifieke configuratieparameters via de parameter opts (type PoolOptions). Het gedrag richt zich naar de standaard [mem.res.pool] uit het headerbestand ara/core/memory_resource.h. De doorgegeven instellingen kunnen na de instantiëring met options() [SWS_CORE_00057] worden opgevraagd, terwijl de voorgeschakelde geheugenbeheerder bereikbaar is via upstream_resource() [SWS_CORE_00056].

Wat betreft de foutafhandeling is de functie gespecificeerd als niet-uitzonderingsveilig („not exception safe”) [SWS_CORE_00068]. Interpretatie: als de interne toewijzing van beheerstructuren bij de instantiëring mislukt, wordt er vermoedelijk een uitzondering gegenereerd, waarmee deze aanroep verschilt van de noexcept-variant [SWS_CORE_00067]. Vraag Q-479a016f4e0ddde7 (open) Terwijl de constructor zelf is geclassificeerd als thread-safe („thread-safe”) [SWS_CORE_00068], zijn latere geheugenbewerkingen van de resulterende instantie zoals do_allocate [SWS_CORE_00058] en do_deallocate [SWS_CORE_00059] uitdrukkelijk niet thread-safe („not thread-safe”); ze mogen daarom niet onbeschermd gelijktijdig worden uitgevoerd.

In samenspel met de levenscyclus van de klasse moet in acht worden genomen dat kopieerconstructie [SWS_CORE_00046] en toewijzingsoperator [SWS_CORE_00047] zijn verwijderd (delete). Gealloceerd geheugen blijft in de pool totdat het via release() [SWS_CORE_00065] wordt vrijgegeven of het object via de niet-virtuele destructor [SWS_CORE_00062] wordt vernietigd.