Exemplos de união C++

Exemplos De Uniao C



Uma união é um tipo de classe especial em C++ que permite o armazenamento de diferentes tipos de dados em um local de memória compartilhada. Ao contrário das estruturas, onde cada parte geralmente obtém sua memória, as uniões permitem que diferentes partes de dados usem o mesmo local de memória. Esta característica torna as uniões particularmente úteis quando a eficiência da memória é uma prioridade e apenas um dos membros precisa ser acessado por vez. Neste artigo, nos aprofundaremos no conceito de uniões em C++ e exploraremos vários exemplos que demonstram sua utilidade em vários cenários.

Sintaxe:

Uma união é um tipo definido pelo usuário, permitindo o armazenamento de diversos tipos de dados em um local de memória compartilhada. O uso de uma união segue uma sintaxe idêntica a uma estrutura.







A sintaxe fundamental é a seguinte:



União NomeUnião {

// Declarações de membros

DataType1 membro1 ;

DataType2 membro2 ;

//...

} ;

Aqui, “UnionName” serve como identificador para a união que fornece um nome exclusivo para fazer referência a este tipo específico definido pelo usuário. Os tipos de dados dos membros do sindicato são indicados como “DataType1”, “DataType2” e assim por diante. Esses tipos de dados significam os diversos tipos de informações que podem ser armazenados no sindicato. Cada membro do sindicato, designado por nomes como “membro1”, “membro2”, etc., representa um dado distinto.



Agora entendemos a sintaxe básica. Vamos agora usar alguns exemplos para entender melhor isso.





Exemplo 1: Uso Básico da União

O primeiro exemplo ilustra a utilização básica de uniões em C++, mostrando como elas permitem o compartilhamento de espaço de memória entre diferentes tipos de dados dentro de uma única estrutura.

Aqui está um exemplo:



#include

usando namespace std ;

União ArrayUnion {

interno intArray [ 5 ] ;

flutuador floatArray [ 5 ] ;

} ;

interno principal ( ) {

ArrayUnion arrayUnion ;

para ( interno eu = 0 ; eu < 5 ; ++ eu ) {

arrayUnion. intArray [ eu ] = eu * 2 ;

}

corte << 'Matriz interna:' ;

para ( interno eu = 0 ; eu < 5 ; ++ eu ) {

corte << ' ' << arrayUnion. intArray [ eu ] ;

}

corte << fim ;

para ( interno eu = 0 ; eu < 5 ; ++ eu ) {

arrayUnion. floatArray [ eu ] = eu * 1,5f ;

}

corte << 'Matriz flutuante:' ;

para ( interno eu = 0 ; eu < 5 ; ++ eu ) {

corte << ' ' << arrayUnion. floatArray [ eu ] ;

}

corte << fim ;

retornar 0 ;

}

Neste trecho de código C++, utilizamos uma união chamada “MyUnion” que incorpora três membros de dados diferentes: um número inteiro (intValue), um número de ponto flutuante (floatValue) e um caractere (charValue). Apenas um destes membros pode estar activo num determinado momento devido à capacidade do sindicato de partilhar um espaço de memória.

Dentro da função “main”, declaramos uma instância da união que é “myUnion”. Primeiro, definimos o valor do membro inteiro como 42 e usamos “cout” para imprimi-lo. Posteriormente, atribuímos o valor de ponto flutuante 3,14 ao membro “floatValue” e o imprimimos. Por último, atribuímos o caractere “A” ao membro “charValue” e o imprimimos. É essencial lembrar que, uma vez que todos os membros do sindicato partilham a mesma localização de memória, a alteração de um membro pode ter impacto nos valores dos outros membros. O código termina retornando 0, o que significa uma execução bem-sucedida.

Exemplo 2: União com Estrutura

Uma estrutura é um tipo de dado em C++ que os usuários podem criar para combinar variáveis ​​de vários tipos sob um nome unificado. Combinar uma união com uma struct pode ser útil quando queremos criar uma estrutura de dados que possa conter diferentes tipos de dados, e cada tipo está associado a um campo específico. Este emparelhamento permite o desenvolvimento de estruturas de dados complexas com representações diversas.

Aqui está um exemplo de uso de uma união dentro de uma estrutura em C++:

#include

usando namespace std ;

estrutura Apontar {

interno s1 ;

interno s2 ;

} ;

União Forma {

interno lados ;

flutuador raio ;

Centro do ponto ;

} ;

interno principal ( ) {

Forma ;

forma. lados = 5 ;
corte << 'Lados:' << forma. lados << fim ;

forma. raio = 6,0f ;
corte << 'Raio: ' << forma. raio << fim ;

forma. Centro = { 10 , vinte } ;
corte << 'Centro: (' << forma. Centro . s1 << ',' << forma. Centro . s2 << ')' << fim ;

retornar 0 ;

}

Neste código, definimos um programa C++ que usa uma união e uma estrutura para representar diferentes aspectos de uma forma geométrica. Primeiro, declaramos uma estrutura “Ponto” que consiste em dois membros inteiros, “s1” e “s2”, que representam as coordenadas de um ponto em um espaço 2D. Em seguida, definimos uma “união” chamada “Forma” que consiste em três membros: um inteiro “lados”, um ponto flutuante “raio” e uma estrutura “Ponto” chamada “centro”. Passando para a função “principal”, instanciamos um objeto “Shape” denominado “shape”. Demonstramos então a versatilidade do sindicato ao atribuir valores aos seus diferentes membros. Inicialmente, definimos o número de lados como 5 e imprimimos o resultado. A seguir, atribuímos um raio de 6,0 à forma e produzimos o raio. Finalmente, atribuímos um ponto central com coordenadas (10, 20) à forma e imprimimos as coordenadas do centro.

Exemplo 3: União com Enum

Em C++, as enumerações, comumente chamadas de enums, servem ao propósito de definir uma coleção de constantes integrais nomeadas. Combinar enums com uniões pode ser útil em cenários onde queremos representar uma variável que pode assumir diferentes tipos, cada um associado a um valor enum específico.

Aqui está um exemplo:

#include

usando namespace std ;

enumeração Tipo de dados {

INTEIRO ,

FLUTUADOR ,

CARACTERES

} ;

União Valor de dados {

interno valorintt ;

flutuador floatValor ;

Caracteres charValor ;

} ;

estrutura Dados {

Tipo de dados ;

Valor DataValue ;

} ;

interno principal ( )

{

Dados dados1 , dados2 , dados3 ;

dados1. tipo = INTEIRO ;
dados1. valor . valorintt = 42 ;

dados2. tipo = FLUTUADOR ;
dados2. valor . floatValor = 3.14f ;

dados3. tipo = CARACTERES ;
dados3. valor . charValor = 'A' ;

corte << 'Dados 1:' << dados1. valor . valorintt << fim ;
corte << 'Dados 2:' << dados2. valor . floatValor << fim ;
corte << 'Dados 3:' << dados3. valor . charValor << fim ;

retornar 0 ;

}

Para este exemplo, temos um programa que utiliza enums, uniões e estruturas para criar uma estrutura de dados flexível capaz de conter diferentes tipos de valores. O enum “DataType” é definido para representar três tipos de dados fundamentais: INTEGER, FLOAT e CHAR. O enum melhora a legibilidade e a manutenção do código, oferecendo um conjunto de constantes integrais nomeadas.

Em seguida, fazemos uma união chamada “DataValue” com três membros: “charValue” do tipo char, “floatValue” do tipo float e “intValue” do tipo int. Com uma união, esses membros compartilham um local de memória comum que permite que a união acomode de forma intercambiável os valores de tipos distintos. A estrutura “Data” é então criada e consiste em dois membros: um enumerador “DataType” denominado “type” e uma união “DataValue” denominada “value”. Esta estrutura nos permite associar um tipo de dados ao seu valor correspondente, fornecendo uma representação estruturada.

Na função “main”, instanciamos três instâncias da estrutura “Data”: “data1”, “data2” e “data3”. Atribuímos os valores a essas instâncias especificando o tipo de dados e definindo o valor apropriado na união. Por exemplo, “data1” é atribuído a um tipo INTEGER com valor 42. Finalmente, usamos as instruções “cout” para imprimir os valores que estão armazenados em cada instância “Data”. O programa gera o valor inteiro de “data1”, o valor de ponto flutuante de “data2” e o valor do caractere de “data3”.

Este exemplo ilustra como a combinação de enums, uniões e estruturas pode ser empregada para criar uma representação de dados versátil e de tipo seguro em C++.

Conclusão

As uniões C++ fornecem um mecanismo poderoso e flexível para gerenciar diversos tipos de dados em um único espaço de memória. Os casos ilustrados neste artigo destacam a adaptabilidade e a eficácia dos sindicatos na abordagem de uma série de cenários. Desde os usos fundamentais que demonstram a intercambialidade dos tipos de dados até aplicações mais complexas envolvendo estruturas e enumerações, esses exemplos ressaltam a eficiência e a adaptabilidade que as uniões trazem à programação C++.