Différence entre structure et union
Contenu
C ++ permet aux cinq méthodes fournies par le langage C de créer des données personnalisées. Ces cinq manières sont "structure", "champ binaire", "union", "énumération", "typedef". Dans l'article ci-dessous, nous allons étudier la différence entre structure et union. La structure et l'union sont les types de données de conteneur pouvant contenir des données de n'importe quel «type». La principale différence qui distingue la structure et l'union est que la structure dispose d'un emplacement de mémoire distinct pour chacun de ses membres, tandis que les membres d'une union partagent le même emplacement de mémoire.
Comprenons la différence entre structure et union, ainsi qu’un tableau comparatif.
- Tableau de comparaison
- Définition
- Différences Clés
- Similitudes
- Conclusion
Tableau de comparaison
| Base de comparaison | Structure | syndicat |
|---|---|---|
| De base | L'emplacement de mémoire séparé est attribué à chaque membre de la structure. | Tous les membres du syndicat partagent le même emplacement de mémoire. |
| Déclaration | struct nom_str { type element1; type element2; . . } variable1, variable2, ...; | union u_name { type element1; type element2; . . } variable1, variable2, ...; |
| mot-clé | struct | syndicat |
| Taille | Taille de la structure = somme de la taille de tous les membres de données. | Taille de l'Union = taille des membres les plus importants. |
| Valeur de magasin | Stocke des valeurs distinctes pour tous les membres. | Stocke la même valeur pour tous les membres. |
| À la fois | Une structure stocke plusieurs valeurs, des différents membres, de la structure. | Un syndicat stocke une valeur unique à la fois pour tous les membres. |
| Manière de regarder | Fournir un moyen unique pour afficher chaque emplacement de mémoire. | Fournir plusieurs moyens pour afficher le même emplacement mémoire. |
| Fonction anonyme | Aucune fonctionnalité anonyme. | L'union anonyme peut être déclarée. |
Définition de la structure
La structure est un ensemble de variables de différents types de données, appelées par un nom commun. Les variables d'une structure sont appelées «membres». Par défaut, tous les membres d'une structure sont «publics». Lorsque vous déclarez une structure, vous créez un modèle qui peut être utilisé pour créer des objets de structure partageant la même organisation de membres de données et de fonctions membres. La déclaration de la structure est toujours précédée du mot-clé «struct», qui indique au compilateur qu'une structure a été déclarée. Prenons un exemple.
Prenons un exemple.
struct employee {nom de chaîne; string company_name; ville de ficelle; } emp1, emp2;
Ici, nous déclarons une structure pour stocker les informations des employés. La déclaration se termine par un point-virgule, car la déclaration de structure est une instruction et, en C ++, elle se termine par un point-virgule.
Le nom donné à une structure définit un «type» (dans l'exemple ci-dessus, le nom de la structure est «employé»). Les variables de ces types pourraient être créées, comme ci-dessus, nous avons créé deux variables "emp1" et "emp2" de type "employé". Dans l’exemple ci-dessus, nous avons créé une variable ‘structure’ juste après la déclaration; alternativement, il pourrait être créé séparément.
struct employee emp1, emp2; // le mot clé struct n'est pas obligatoire.
Les membres d'une variable de structure peuvent être initialisés ou accessibles à l'aide de l'opérateur point (.).
emp1.name = "ashok";
Les informations contenues dans une variable de structure peuvent être affectées à une autre variable de structure du même type, comme suit.
emp1.name = "ashok"; emp1.company_name = "Teckpix"; emp1.city = "Delhi"; emp2 = emp1; // attribution des valeurs du membre de emp1 à emp2. cout <
Ici, nous avons affecté la variable de structure 'emp1 ′ à' emp2 ′ so ', ‘emp1 ′ copie toute la valeur de ses membres dans le membre correspondant de« epm2 ».
Le membre de la variable de structure peut être passé à la fonction.
funct (emp1.city);
La variable de structure entière peut être transmise à la fonction, à la fois par les méthodes call by value et call by reference.
funt (emp1); // appel de fonction par appel par méthode de valeur. . . void funct (struct employee emp) {// recevant les valeurs des membres de emp1. cout <
Ici, la modification de la valeur d'un membre de la variable de structure ne sera pas répercutée à l'extérieur de la fonction car une variable est transmise par la méthode call by value. Faisons maintenant la même chose appel par méthode de référence.
funt (& emp1); // appelant fonction par appel par méthode de référence. . . void funct (struct employee * emp) {// adresse de réception de emp1. emp-> city = "Nur"; // change la valeur du membre (ville) de la variable de structure emp1. . }
Ici, la variable de structure est passée par référence, de sorte que la modification de la valeur des membres de la variable de structure reflète également en dehors de la fonction.
employé salarié * emp; // décalque le pointeur de structure de type employee. emp = & emp1; // attribuer l'adresse de emp1 au pointeur. emp-> city // pointeur accédant à la ville membre de emp1.
Le pointeur sur la structure peut également être créé. il contient l'adresse de la variable de structure.
Dans la structure, l'initialisation de l'agrégat est autorisée lorsque la définition de la structure ne contient pas de constructeur défini par l'utilisateur, de fonctions virtuelles, de classe de base ou de champ privé ou protégé.
int main () {struct epm3 = {"Anil", "Teckpix", "Nur"}; } // Possible car la structure de l'employé ne contient aucune des choses mentionnées ci-dessus.
Définition de l'union
Une union est un emplacement de mémoire partagé par au moins deux types différents de variable déclarée sous un seul type d'union. Le mot clé utilisé pour déclarer un syndicat est "syndicat". En C ++, une union peut contenir à la fois une fonction membre et des variables. Par défaut, tous les membres du syndicat sont «publics». La déclaration de “l'union” est similaire à la déclaration de la structure.
union u_type {int x, char c; float f; } u1, u2;
Ici, nous avions déclaré une union nommée u_type. Les membres de u_type sont "x" de type entier, "c" de type caractère et "f" de type float. Nous avions également créé les variables d’union «u1» et «u2», de type «u_type», juste après la déclaration d’une union. Nous pouvons également déclarer la variable d'union séparément de la déclaration d'union.
int main () {union u_type u1, u2; // Le mot clé union n'est pas obligatoire en C ++. }
L'accès des membres de l'union peut être effectué à l'aide de l'opérateur point (.), Précédé de la variable d'union et suivi du membre de cette variable.
u1.x = 10;
Comme pour les structures, l'initialisation des agrégats n'est pas possible dans une union. Comme nous le savons, l'union partage le même emplacement mémoire pour tous ses membres à la fois, une seule variable est initialisée et toute la variable est automatiquement mise à jour avec la valeur initialisée.
u1.x = 10; cout <
Si vous essayez de changer la valeur d’un membre de ‘u1’. L'autre membre sera automatiquement mis à jour avec cette valeur.
u1.c = 65; cout <
L'espace alloué au syndicat est égal à la taille du plus grand membre du syndicat. Comme l’octet attribué à "char" est de 1 octet, "int" de 4 octets et "float" de 4 octets, la plus grande taille est de 4 octets. Ainsi, la mémoire allouée à "u1" et "u2" est de 4 octets.
int main () {int size_1 = sizeof (u1); // 4 int size_2 = sizeof (u2); // 4
Le pointeur sur l'union peut être créé comme dans la structure. Le pointeur contient l'adresse de l'union.
union u_type * un; un = & u1; cout < Comme pour la structure, l’union peut également être transmise aux fonctions à la fois par les méthodes, c’est-à-dire appel par valeur et appel par référence. funct (u1); // appel de fonction par appel par méthode de valeur. . . void funct (union u_type un) {// recevant la valeur du membre de u1. cout < Appelons maintenant la fonction en utilisant la méthode d’appel par référence. funct (& u1); // appel de fonction par appel par méthode. . . void funct (union u_type un) {// recevant l'adresse de u1. un-> x = 20. } Il existe un type spécial d'union en C ++ appelé Union anonyme ”. L'union anonyme ne peut pas avoir le nom du type et aucune variable d'une telle union ne peut être créée. C'est seulement pour dire au compilateur que ses variables membres doivent partager le même emplacement. La variable d'une union anonyme peut être référée sans l'opérateur point (.) Normal. int main () {union {// définit une union anonyme sans le nom du type. int x, char c; float f; }; x = 10; // fait référence à la variable d'union avec out opérateur de point cout < Dans l’union anonyme, aucune fonction membre n’est autorisée, elle ne peut pas contenir de données privées ou protégées, et l’union anonyme globale doit être spécifiée comme ‘statique’. Les points à retenir pour la déclaration syndicale normale. La structure et l'union sont le type de données du conteneur qui contient le membre de types différents. Mais les structures sont utilisées lorsque nous devons stocker une valeur distincte pour tous les membres dans un emplacement de mémoire distinct. Les unions sont utilisées lorsque la conversion de type est nécessaire.
Similitudes:
Conclusion:
