Syntax:
Ang unyon ay isang uri na tinukoy ng user, na nagbibigay-daan sa pag-imbak ng magkakaibang uri ng data sa loob ng isang nakabahaging lokasyon ng memorya. Ang paggamit ng unyon ay sumusunod sa isang syntax na kapareho ng isang struct.
Ang pangunahing syntax ay ang mga sumusunod:
unyon Pangalan ng Unyon {
// Mga deklarasyon ng miyembro
DataType1 miyembro1 ;
DataType2 miyembro2 ;
//...
} ;
Dito, ang 'UnionName' ay nagsisilbing identifier para sa unyon na nagbibigay ng natatanging pangalan upang i-reference ang partikular na uri na tinukoy ng user. Ang mga uri ng data ng mga miyembro ng unyon ay tinutukoy bilang 'DataType1', 'DataType2', at iba pa. Ang mga uri ng data na ito ay nagpapahiwatig ng iba't ibang uri ng impormasyon na maaaring maimbak sa loob ng unyon. Ang bawat miyembro sa loob ng unyon, na itinalaga ng mga pangalan tulad ng 'member1', 'member2', atbp., ay kumakatawan sa isang natatanging piraso ng data.
Naiintindihan na namin ngayon ang pangunahing syntax. Gumamit tayo ngayon ng ilang pagkakataon para mas maunawaan ito.
Halimbawa 1: Pangunahing Paggamit ng Unyon
Ang unang halimbawa ay naglalarawan ng pangunahing paggamit ng mga unyon sa C++, na nagpapakita kung paano nila pinapagana ang pagbabahagi ng memory space sa iba't ibang uri ng data sa loob ng isang istraktura.
Narito ang isang halimbawa:
#include
gamit ang namespace std ;
unyon ArrayUnion {
int intArray [ 5 ] ;
lumutang floatArray [ 5 ] ;
} ;
int pangunahing ( ) {
ArrayUnion arrayUnion ;
para sa ( int i = 0 ; i < 5 ; ++ i ) {
arrayUnion. intArray [ i ] = i * 2 ;
}
cout << 'Int Array:' ;
para sa ( int i = 0 ; i < 5 ; ++ i ) {
cout << '' << arrayUnion. intArray [ i ] ;
}
cout << endl ;
para sa ( int i = 0 ; i < 5 ; ++ i ) {
arrayUnion. floatArray [ i ] = i * 1.5f ;
}
cout << 'Float Array:' ;
para sa ( int i = 0 ; i < 5 ; ++ i ) {
cout << '' << arrayUnion. floatArray [ i ] ;
}
cout << endl ;
bumalik 0 ;
}
Sa C++ code snippet na ito, gumagamit kami ng unyon na pinangalanang 'MyUnion' na nagsasama ng tatlong magkakaibang miyembro ng data: isang integer (intValue), isang floating-point number (floatValue), at isang character (charValue). Isa lang sa mga miyembrong ito ang maaaring maging aktibo sa anumang partikular na punto dahil sa kakayahan ng unyon na magbahagi ng memory space.
Sa loob ng 'pangunahing' function, ipinapahayag namin ang isang instance ng unyon na 'myUnion'. Una, itinakda namin ang halaga ng miyembro ng integer sa 42 at ginagamit ang 'cout' upang i-print ito. Kasunod nito, itinatalaga namin ang floating-point value na 3.14 sa miyembro ng 'floatValue' at i-print ito. Panghuli, itinatalaga namin ang character na 'A' sa miyembro ng 'charValue' at i-print ito. Mahalagang tandaan na dahil pare-pareho ang lokasyon ng memorya ng lahat ng miyembro ng unyon, ang pagpapalit ng isang miyembro ay maaaring magkaroon ng epekto sa mga halaga ng ibang miyembro. Ang code ay nagtatapos sa pamamagitan ng pagbabalik ng 0 na nagpapahiwatig ng isang matagumpay na pagpapatupad.
Halimbawa 2: Union with Struct
Ang struct ay isang uri ng data sa C++ na maaaring gawin ng mga user upang pagsamahin ang mga variable ng iba't ibang uri sa ilalim ng isang pinag-isang pangalan. Ang pagsasama-sama ng unyon sa isang struct ay maaaring maging kapaki-pakinabang kapag gusto naming lumikha ng istraktura ng data na maaaring maglaman ng iba't ibang uri ng data, at ang bawat uri ay nauugnay sa isang partikular na field. Ang pagpapares na ito ay nagbibigay-daan para sa pagbuo ng mga kumplikadong istruktura ng data na nagtatampok ng magkakaibang representasyon.
Narito ang isang halimbawa ng paggamit ng unyon sa loob ng isang struct sa C++:
#includegamit ang namespace std ;
struct Punto {
int s1 ;
int s2 ;
} ;
unyon Hugis {
int panig ;
lumutang radius ;
Point center ;
} ;
int pangunahing ( ) {
Hugis hugis ;
Hugis. panig = 5 ;
cout << 'Mga gilid:' << Hugis. panig << endl ;
Hugis. radius = 6.0f ;
cout << 'Radyus: ' << Hugis. radius << endl ;
Hugis. gitna = { 10 , dalawampu } ;
cout << 'Gitna: (' << Hugis. gitna . s1 << ',' << Hugis. gitna . s2 << ')' << endl ;
bumalik 0 ;
}
Sa code na ito, tinutukoy namin ang isang C++ program na gumagamit ng unyon at isang struct upang kumatawan sa iba't ibang aspeto ng isang geometric na hugis. Una, ipinapahayag namin ang isang istraktura ng 'Point' na binubuo ng dalawang miyembro ng integer, 's1' at 's2', na kumakatawan sa mga coordinate ng isang punto sa isang 2D na espasyo. Pagkatapos, tinukoy namin ang isang 'unyon' na pinangalanang 'Hugis' na binubuo ng tatlong miyembro: isang integer na 'mga gilid', isang 'radius' na floating-point, at isang istrukturang 'Point' na pinangalanang 'center'. Sa paglipat sa 'pangunahing' function, ginagawa namin ang isang bagay na 'Hugis' na pinangalanang 'hugis'. Pagkatapos ay ipinapakita namin ang versatility ng unyon sa pamamagitan ng pagtatalaga ng mga halaga sa iba't ibang miyembro nito. Sa una, itinakda namin ang bilang ng mga panig sa 5 at i-print ang resulta. Susunod, nagtatalaga kami ng radius na 6.0 sa hugis at output ang radius. Sa wakas, nagtatalaga kami ng center point na may mga coordinate (10, 20) sa hugis at i-print ang mga coordinate ng center.
Halimbawa 3: Union with Enum
Sa C++, ang mga enumerasyon, na karaniwang tinutukoy bilang mga enum, ay nagsisilbi sa layunin ng pagtukoy sa isang koleksyon ng mga pinangalanang integral constant. Ang pagsasama-sama ng mga enum sa mga unyon ay maaaring maging kapaki-pakinabang sa mga sitwasyon kung saan gusto naming kumatawan sa isang variable na maaaring tumagal sa iba't ibang uri, ang bawat isa ay nauugnay sa isang partikular na halaga ng enum.
Narito ang isang halimbawa:
#includegamit ang namespace std ;
enum Uri ng datos {
INTEGER ,
LUMUTANG ,
CHAR
} ;
unyon DataValue {
int intValue ;
lumutang floatValue ;
char charValue ;
} ;
struct Data {
Uri ng DataType ;
Halaga ng DataValue ;
} ;
int pangunahing ( )
{
datos ng datos1 , datos2 , datos3 ;
datos1. uri = INTEGER ;
datos1. halaga . intValue = 42 ;
datos2. uri = LUMUTANG ;
datos2. halaga . floatValue = 3.14f ;
datos3. uri = CHAR ;
datos3. halaga . charValue = 'A' ;
cout << 'Data 1: ' << datos1. halaga . intValue << endl ;
cout << 'Data 2: ' << datos2. halaga . floatValue << endl ;
cout << 'Data 3: ' << datos3. halaga . charValue << endl ;
bumalik 0 ;
}
Para sa halimbawang ito, mayroon kaming isang programa na gumagamit ng mga enum, unyon, at struct upang lumikha ng nababaluktot na istraktura ng data na may kakayahang humawak ng iba't ibang uri ng mga halaga. Ang 'DataType' na enum ay tinukoy na kumakatawan sa tatlong pangunahing uri ng data: INTEGER, FLOAT, at CHAR. Pinahuhusay ng enum ang pagiging madaling mabasa at mapanatili ng code sa pamamagitan ng pag-aalok ng isang set ng pinangalanang integral constants.
Pagkatapos, gumawa kami ng unyon na tinatawag na 'DataValue' na may tatlong miyembro: 'charValue' ng uri ng char, 'floatValue' ng uri ng float, at 'intValue' ng uri na int. Sa isang unyon, ang mga miyembrong ito ay nagbabahagi ng isang karaniwang lokasyon ng memorya na nagbibigay-daan sa unyon na mapagpalit na mapaunlakan ang mga halaga ng mga natatanging uri. Ang struct na 'Data' ay nilikha na binubuo ng dalawang miyembro: isang 'DataType' enumerator na pinangalanang 'type' at isang 'DataValue' na unyon na pinangalanang 'value'. Nagbibigay-daan sa amin ang struct na ito na iugnay ang isang uri ng data sa katumbas nitong halaga, na nagbibigay ng structured na representasyon.
Sa 'pangunahing' function, ginagawa namin ang tatlong instance ng 'Data' struct: 'data1', 'data2', at 'data3'. Nagtatalaga kami ng mga halaga sa mga pagkakataong ito sa pamamagitan ng pagtukoy sa uri ng data at pagtatakda ng naaangkop na halaga sa loob ng unyon. Halimbawa, ang 'data1' ay itinalaga na may uri ng INTEGER na may halaga na 42. Panghuli, ginagamit namin ang mga pahayag na 'cout' upang i-print ang mga halaga na nakaimbak sa bawat halimbawa ng 'Data'. Ang programa ay naglalabas ng integer value ng “data1”, ang floating-point value ng “data2”, at ang character value ng “data3”.
Ang halimbawang ito ay naglalarawan kung paano maaaring gamitin ang pagsasama-sama ng mga enum, unyon, at struct upang lumikha ng versatile at type-safe na representasyon ng data sa C++.
Konklusyon
Ang mga unyon ng C++ ay nagbibigay ng isang malakas at nababaluktot na mekanismo para sa pamamahala ng magkakaibang uri ng data sa loob ng iisang memory space. Ang mga pagkakataong inilalarawan sa artikulong ito ay nagpapakita ng kakayahang umangkop at pagiging epektibo ng mga unyon sa pagtugon sa isang hanay ng mga sitwasyon. Mula sa mga pangunahing gamit na nagpapakita ng pagpapalitan ng mga uri ng data hanggang sa mas kumplikadong mga application na kinasasangkutan ng mga istruktura at enum, binibigyang-diin ng mga halimbawang ito ang kahusayan at kakayahang umangkop na dinadala ng mga unyon sa C++ programming.