Diferència entre estructura i unió
Content
C ++ permet totes les cinc maneres que proporcionava el llenguatge C per crear dades personalitzades. Aquestes cinc maneres són "estructura", "camp de bits", "unió", "enumeració", "mecanografia". A l'article següent estudiarem la diferència entre estructura i unió. L'estructura i la unió són els tipus de dades de contenidors que poden contenir dades de qualsevol tipus. La principal diferència que distingeix estructura i unió és que l'estructura té una ubicació de memòria separada per a cadascun dels seus membres, mentre que, els membres d'una unió comparteixen la mateixa ubicació de memòria.
Entenem la diferència entre estructura i unió, juntament amb un gràfic de comparació.
- Gràfic de comparació
- Definició
- Diferències claus
- Semblances
- Conclusió
Gràfic de comparació
| Bases de la comparació | Estructura | Unió |
|---|---|---|
| Bàsic | La ubicació de memòria separada s'assigna a cada membre de l'estructura. | Tots els membres del sindicat comparteixen la mateixa ubicació de memòria. |
| Declaració | struct struct_name { element element1; element element2; . . } variable1, variable2, ...; | union u_name { element de tipus1; element element2; . . } variable1, variable2, ...; |
| paraula clau | estructura | Unió |
| Mida | Dimensió de l'estructura = suma de la mida de tots els membres de les dades. | Mida de la unió = mida dels membres més grans. |
| Valor de la botiga | Emmagatzema valors diferents per a tots els membres. | Emmagatzema el mateix valor per a tots els membres. |
| En un moment | Una estructura emmagatzema diversos valors, dels diferents membres, de l'estructura. | Un sindicat emmagatzema un valor únic a la vegada per a tots els membres. |
| Manera de visualització | Proporcioneu una manera única de veure cada ubicació de la memòria. | Proporciona una manera múltiple de veure la mateixa ubicació de la memòria. |
| Funció anònima | No hi ha cap funció anònima. | Es pot declarar unió anònima. |
Definició d’estructura
L’estructura és una col·lecció de variables de diferents tipus de dades, a les quals es fa referència amb un nom comú. Les variables d'una estructura s'anomenen "membres". De manera predeterminada, tots els membres d’una estructura són “públics”. Quan declareu una estructura, creeu una plantilla, que es pot utilitzar per crear objectes d'estructura, compartint la mateixa organització de membres de dades i funcions de membres. La declaració de l'estructura sempre va precedida de la paraula clau "struct", que indica al compilador que s'ha declarat una estructura. Prenem un exemple.
Prenem un exemple.
struct empleat {string string; string company_name; ciutat de corda; } emp1, emp2;
Aquí, declarem una estructura per emmagatzemar la informació dels empleats. La declaració es tanca amb un punt i coma, ja que la declaració d'estructura és una sentència i, en C ++, la sentència es tanca amb un punt i coma.
El nom que es dóna a una estructura defineix un "tipus" (en l'exemple anterior, el nom de l'estructura és "empleat"). Les variables d’aquest tipus es podrien crear, com anteriorment, hem creat dues variables “emp1” i “emp2” del tipus “empleat”. A l'exemple anterior, hem creat una variable "estructura" just després de la declaració; alternativament, es podria crear per separat.
struct emple emp1, emp2; // la paraula clau no és obligatòria.
Els membres d'una variable d'estructura es poden inicialitzar o es pot accedir mitjançant l'operador punt (.).
emp1.name = "ashok";
La informació continguda en una variable d’estructura es pot assignar a una altra variable d’estructura del mateix tipus que segueix.
emp1.name = "ashok"; emp1.company_name = "Teckpix"; emp1.city = "Delhi"; emp2 = emp1; // assignant valors del membre de emp1 a emp2. cout <
Aquí, hem assignat la variable d'estructura "emp1" a "emp2", així, "emp1" copia tot el valor dels seus membres al membre corresponent de "epm2".
El membre de la variable d'estructura es pot passar a la funció.
funzione (emp1.city);
Tota la variable d'estructura es pot passar a la funció, tant pels mètodes anomenats per valor com per trucats per referència.
funt (emp1); // funció de trucada per mètode de trucada per valor. . . void function (struct emp emp) {// recepció de valors dels membres de emp1. cout <
Aquí, el canvi al valor d'un membre de la variable d'estructura no es reflectirà fora de la funció, ja que la variable es fa passar per mètode de trucada. Ara fem el mateix per trucada mitjançant mètode de referència.
funt (& emp1); // funció de trucada per trucada per mètode de referència. . . void function (struct empleat * emp) {// recepció de l'adreça de emp1. emp-> ciutat = "Nur"; // canviar el valor del membre (ciutat) de l'estructura variable emp1. . }
Aquí, la variable d’estructura es passa per referència així que, el canvi al valor dels membres de la variable d’estructura també es reflecteix fora de la funció també.
srtuct empleat * emp; // decalificació del punter d'estructura del tipus empleat. emp = & emp1; // assignant l'adreça de emp1 al punter. emp-> ciutat // punter que accedeix a la ciutat membre d'emp1.
També es pot crear el punter a l'estructura; manté l'adreça de l'estructura variable.
En estructura, la inicialització agregada és permesa quan la definició de l'estructura no conté, cap constructor o funcions virtuals definides per l'usuari o classe base o camp privat o protegit.
int main () {struct epm3 = {"Anil", "Teckpix", "Nur"}; } // Possible com a estructura de l'empleat no conté cap de les coses esmentades anteriorment.
Definició d’Unió
Una unió és una ubicació de memòria compartida per dos o més tipus de variables diferents declarats sota un únic tipus d'unió. La paraula clau utilitzada per declarar una unió és “unió”. A C ++, una unió pot contenir tant la funció de membre com les variables. Per defecte, tots els membres del sindicat són “públics”. La declaració de la "unió" és similar a la declaració de l'estructura.
union u_type {int x, char c; flotar f; } u1, u2;
Aquí, havíem declarat una unió anomenada u_type. Els membres del tipus u_type són "x" de tipus enter, "c" de tipus de caràcter i "f" de tipus float. També havíem creat les variables d'unió "u1" i "u2", de tipus "u_type", just després de la declaració d'una unió. També podem declarar la unió variable per separat de la declaració d’unió.
int main () {union u_type u1, u2; // La unió de paraules clau no és obligatòria a C ++. }
L’accés als membres de la unió es pot fer mitjançant l’operador de punt (.), Precedit de la unió variable i seguit del membre d’aquesta variable.
u1.x = 10;
Com les estructures, la inicialització agregada no és possible en una unió. Com sabem, la unió comparteix la mateixa ubicació de memòria per a tots els membres al mateix temps, només s’inicialitza una variable i tota la variable s’actualitza automàticament amb el valor inicialitzat.
u1.x = 10; cout <
Si intenteu canviar el valor de qualsevol membre de "u1". L’altre membre s’actualitzarà automàticament a aquest valor.
u1.c = 65; cout <
L’espai assignat a la unió és igual a la mida del membre més gran del sindicat. Com que el byte assignat a "char" és d'1 byte, "int" és de 4 bytes i "float" és de 4 bytes, la mida més gran és de 4 bytes. Així, la memòria assignada a "u1" i "u2" és de 4 bytes.
int main () {int size_1 = sizeof (u1); // 4 int size_2 = sizeof (u2); // 4
El punter a la unió es pot crear de la mateixa manera que en l'estructura. El punter té la direcció de la unió.
union u_type * un; un = & u1; cout < Com a estructura, la unió també es pot passar a les funcions pels dos mètodes, és a dir, trucar per valor i trucar per referència. funció (u1); // funció de trucada per mètode de trucada per valor. . . void function (union u_type un) {// rebent el valor del membre de u1. cout < Ara, anem a trucar la funció mitjançant el mètode de trucada per referència. funció (& u1); // funció de trucada per trucada per mètode de referència. . . void function (union u_type un) {// recepció de l'adreça de u1. un-> x = 20. } Hi ha un tipus especial d’unió a C ++ anomenat Unió Anònima ”. La unió anònima no pot tenir el nom del tipus i no es pot crear cap variable d'aquesta unió. Només cal dir-li al compilador que les seves variables de membre comparteixen la mateixa ubicació. Es pot fer referència a la variable d'una unió anònima sense l'operador dot (.) Normal. int main () {union {// definir unió anònima amb el nom del tipus. int x, char c; flotar f; }; x = 10; // va refer la variable d'unió amb l'operador de punts fora cout < A la unió anònima no es permet cap funció de membre, no pot contenir dades privades ni protegides, i la unió anònima global s’ha d’especificar com a “estàtica”. Els punts a recordar per a la declaració sindical normal. Ambdues, estructura i unió són el tipus de dades del contenidor que conté el membre de diferents tipus. Però es fan servir estructures quan necessitem emmagatzemar valor diferent per a tots els membres en una ubicació de memòria diferent. Les unions s’utilitzen quan es necessita la conversió de tipus.
Similituds:
Conclusió:
