Syntaxis:
Een unie is een type dat door de gebruiker wordt gedefinieerd en dat de opslag van diverse gegevenstypen binnen een gedeelde geheugenlocatie mogelijk maakt. Het gebruik van een unie volgt een syntaxis die identiek is aan een struct.
De fundamentele syntaxis is als volgt:
unie Unienaam {
// Ledenverklaringen
Gegevenstype1 lid1 ;
DataType2-lid2 ;
//...
} ;
Hier fungeert “UnionName” als de identificatie voor de unie, die een unieke naam biedt om te verwijzen naar dit specifieke, door de gebruiker gedefinieerde type. De gegevenstypen van de vakbondsleden worden aangeduid als “DataType1”, “DataType2”, enzovoort. Deze gegevenstypen duiden op de gevarieerde soorten informatie die binnen de unie kunnen worden opgeslagen. Elk lid binnen de vakbond, aangeduid met namen als “lid1”, “lid2”, enz., vertegenwoordigt een afzonderlijk stukje gegevens.
We begrijpen nu de basissyntaxis. Laten we nu een paar voorbeelden gebruiken om dit beter te begrijpen.
Voorbeeld 1: Basisgebruik van de Unie
Het eerste voorbeeld illustreert het basisgebruik van vakbonden in C++ en laat zien hoe ze het delen van geheugenruimte tussen verschillende gegevenstypen binnen een enkele structuur mogelijk maken.
Hier is een voorbeeld:
#include
namespace std; gebruiken ;
unie ArrayUnion {
int intArray [ 5 ] ;
vlot floatArray [ 5 ] ;
} ;
int voornaamst ( ) {
ArrayUnion arrayUnion ;
voor ( int i = 0 ; i < 5 ; ++ i ) {
arrayUnion. intArray [ i ] = i * 2 ;
}
uit << 'Int-array:' ;
voor ( int i = 0 ; i < 5 ; ++ i ) {
uit << ' ' << arrayUnion. intArray [ i ] ;
}
uit << eindl ;
voor ( int i = 0 ; i < 5 ; ++ i ) {
arrayUnion. floatArray [ i ] = i * 1,5 f ;
}
uit << 'Vlotterarray:' ;
voor ( int i = 0 ; i < 5 ; ++ i ) {
uit << ' ' << arrayUnion. floatArray [ i ] ;
}
uit << eindl ;
opbrengst 0 ;
}
In dit C++-codefragment gebruiken we een unie genaamd 'MyUnion' die drie verschillende gegevensleden bevat: een geheel getal (intValue), een drijvende-kommagetal (floatValue) en een teken (charValue). Slechts één van deze leden kan op een bepaald moment actief zijn vanwege het vermogen van een vakbond om een geheugenruimte te delen.
Binnen de functie “main” declareren we een instantie van de unie die “myUnion” is. Eerst stellen we de waarde van het gehele lid in op 42 en gebruiken we 'cout' om deze af te drukken. Vervolgens wijzen we de drijvende-kommawaarde van 3,14 toe aan het “floatValue” -lid en drukken deze af. Ten slotte wijzen we het teken “A” toe aan het lid “charValue” en drukken dit af. Het is essentieel om te onthouden dat, aangezien alle vakbondsleden dezelfde geheugenlocatie delen, het veranderen van één lid een impact kan hebben op de waarden van andere leden. De code eindigt met het retourneren van 0, wat een succesvolle uitvoering betekent.
Voorbeeld 2: Unie met structuur
Een struct is een gegevenstype in C++ dat gebruikers kunnen maken om de variabelen van verschillende typen onder één uniforme naam te combineren. Het combineren van een unie met een struct kan handig zijn als we een datastructuur willen creëren die verschillende soorten gegevens kan bevatten, en elk type is gekoppeld aan een specifiek veld. Deze koppeling maakt de ontwikkeling mogelijk van complexe datastructuren met diverse representaties.
Hier is een voorbeeld van het gebruik van een unie binnen een structuur in C++:
#includenamespace std; gebruiken ;
structureren Punt {
int s1 ;
int s2 ;
} ;
unie Vorm {
int zijkanten ;
vlot straal ;
Punt midden ;
} ;
int voornaamst ( ) {
Vorm vorm ;
vorm. zijkanten = 5 ;
uit << 'Zijkanten:' << vorm. zijkanten << eindl ;
vorm. straal = 6,0f ;
uit << 'Straal: ' << vorm. straal << eindl ;
vorm. centrum = { 10 , twintig } ;
uit << 'Midden: (' << vorm. centrum . s1 << ', ' << vorm. centrum . s2 << ')' << eindl ;
opbrengst 0 ;
}
In deze code definiëren we een C++-programma dat een unie en een struct gebruikt om verschillende aspecten van een geometrische vorm weer te geven. Eerst declareren we een “Punt”-structuur die bestaat uit twee gehele leden, “s1” en “s2”, die de coördinaten van een punt in een 2D-ruimte vertegenwoordigen. Vervolgens definiëren we een “vereniging” met de naam “Vorm” die uit drie leden bestaat: een geheel getal “zijden”, een drijvende komma “straal” en een “Punt”-structuur met de naam “centrum”. Als we verder gaan met de “main” -functie, instantiëren we een “Shape” -object met de naam “shape”. Vervolgens demonstreren we de veelzijdigheid van de vakbond door waarden toe te kennen aan de verschillende leden. In eerste instantie stellen we het aantal zijden in op 5 en printen we het resultaat. Vervolgens wijzen we een straal van 6,0 toe aan de vorm en voeren we de straal uit. Ten slotte wijzen we een middelpunt met coördinaten (10, 20) toe aan de vorm en drukken we de coördinaten van het middelpunt af.
Voorbeeld 3: Vereniging met Enum
In C++ dienen opsommingen, gewoonlijk opsommingen genoemd, voor het definiëren van een verzameling benoemde integrale constanten. Het combineren van enums met unies kan handig zijn in scenario's waarin we een variabele willen vertegenwoordigen die verschillende typen kan aannemen, elk geassocieerd met een specifieke enumwaarde.
Hier is een voorbeeld:
#includenamespace std; gebruiken ;
opsomming Data type {
GEHEEL GETAL ,
VLOT ,
KAAR
} ;
unie Gegevenswaarde {
int intWaarde ;
vlot floatWaarde ;
verkoold charWaarde ;
} ;
structureren Gegevens {
DataType-type ;
DataValue-waarde ;
} ;
int voornaamst ( )
{
Gegevensgegevens1 , gegevens2 , gegevens3 ;
gegevens1. type = GEHEEL GETAL ;
gegevens1. waarde . intWaarde = 42 ;
gegevens2. type = VLOT ;
gegevens2. waarde . floatWaarde = 3.14f ;
gegevens3. type = KAAR ;
gegevens3. waarde . charWaarde = 'A' ;
uit << 'Gegevens 1: ' << gegevens1. waarde . intWaarde << eindl ;
uit << 'Gegevens 2: ' << gegevens2. waarde . floatWaarde << eindl ;
uit << 'Gegevens 3: ' << gegevens3. waarde . charWaarde << eindl ;
opbrengst 0 ;
}
Voor dit voorbeeld hebben we een programma dat enums, unions en structs gebruikt om een flexibele datastructuur te creëren die verschillende soorten waarden kan bevatten. De opsomming 'DataType' is gedefinieerd om drie fundamentele gegevenstypen weer te geven: INTEGER, FLOAT en CHAR. De enum verbetert de leesbaarheid en onderhoudbaarheid van de code door een reeks benoemde integrale constanten aan te bieden.
Vervolgens maken we een unie met de naam “DataValue” met drie leden: “charValue” van het type char, “floatValue” van het type float en “intValue” van het type int. Met een vakbond delen deze leden een gemeenschappelijke geheugenlocatie waardoor de vakbond de waarden van verschillende typen onderling uitwisselbaar kan huisvesten. Vervolgens wordt de ‘Data’-structuur gemaakt die uit twee leden bestaat: een ‘DataType’-enumerator met de naam ‘type’ en een ‘DataValue’-unie met de naam ‘value’. Met deze structuur kunnen we een gegevenstype koppelen aan de bijbehorende waarde, waardoor een gestructureerde weergave ontstaat.
In de ‘main’-functie instantiëren we drie exemplaren van de ‘Data’-structuur: ‘data1’, ‘data2’ en ‘data3’. We wijzen de waarden aan deze instanties toe door het gegevenstype op te geven en de juiste waarde binnen de unie in te stellen. Aan “data1” wordt bijvoorbeeld het type INTEGER toegewezen met de waarde 42. Ten slotte gebruiken we de “cout”-instructies om de waarden af te drukken die in elke “Data”-instantie zijn opgeslagen. Het programma voert de gehele waarde van “data1” uit, de drijvende-kommawaarde van “data2” en de tekenwaarde van “data3”.
Dit voorbeeld illustreert hoe het combineren van de enums, unions en structs kan worden gebruikt om een veelzijdige en typeveilige gegevensrepresentatie in C++ te creëren.
Conclusie
C++-vakbonden bieden een krachtig en flexibel mechanisme voor het beheren van de diverse gegevenstypen binnen één enkele geheugenruimte. De voorbeelden die in dit artikel worden geïllustreerd, benadrukken het aanpassingsvermogen en de effectiviteit van vakbonden bij het aanpakken van een reeks scenario’s. Van de fundamentele toepassingen die de uitwisselbaarheid van datatypen demonstreren tot complexere toepassingen waarbij structuren en enums betrokken zijn, deze voorbeelden onderstrepen de efficiëntie en het aanpassingsvermogen die vakbonden bieden bij het programmeren in C++.