Linguagem C - Uniões

1. UNIÕES
Profª Ms. Engª Elaine Cecília Gatto
Curso de Bacharelado em Engenharia de Computação
Universidade do Sagrado CoraçãO – USC
Bauru/SP

2. Uniões
• Uma união é um tipo de dado derivado com membros que
compartilham o mesmo espaço de armazenamento.
• Para diferentes situações em um programa, algumas variáveis
podem não ser relevantes, mas outras variáveis o são, de
modo que uma união compartilha o espaço em vez de
desperdiçar armazenamento em variáveis que não são mais
usadas.
• Os membros de uma união podem ser de qualquer tipo de
dado.

3. Uniões
• O número de bytes usados para armazenar uma união precisa
ser, pelo menos, o suficiente para manter o maior membro.
• Na maior parte dos casos, as uniões contêm dois ou mais tipos
de dados.
• Apenas um membro e, portanto, um tipo de dado, pode ser
referenciado a cada vez.
• É de responsabilidade do programador garantir que os dados
em uma união sejam referenciados com o tipo apropriado.

4. UNIÕES
• Estruturas são
relacionadas.
usadas
para
armazenar
informações
• Quando você cria uma estrutura o programa armaneza espaço
em memória suficiente para conter todos os dados daquela
estrutura.
• No entanto, algumas vezes você pode querer usar apenas um
dado de cada estrutura.

5. UNIÕES
• Por exemplo: numa estrutura que indica horas trabalhadas
(para funcionários de escritório) e produção (para empregados
que ganham por comissão) você vai utilizar apenas um dado
da estrutura, ou ele é funcionário de escritório ou de produção.
• Utilizando o operador union você faz com que o programa
armazene espaço suficiente para o maior dado, pois somente
será armazenado um. Com isso você economiza bastante
recurso de memória.

6. UNIÕES
union inteiro Flutuante {
int i; double d;
};
• Sabemos que um número inteiro (int) possui o tamanho 4
• Sabemos que o um número de precisão dupla (double) ocupa
8 bits
• Para poder acomodar qualquer um dos dois valores
declarados, a união vai reservar 8 bits.
• Num dado momento, apenas um dos números poderá ser
armazenado, nunca os dois juntos.
• Uma união funciona mais ou menos como um rascunho
ocupando um número fixo de bits na memória

7. UNIÕES
• Uniões empacotam estruturas. Como?
• Em um determinado programa criamos várias estruturas
ligeiramente diferentes que nunca serão usadas
simultaneamente.
• No momento em que são definidas e recebem valores, cada
uma delas ocupará determinado espaço na memória.
• Quando estivermos usado cada uma delas, uma grande área
da memória estará alocada, mas apenas uma pequena
porção, referente à estrutura em uso no momento, estará
sendo utilizada.

8. UNIÕES
• A união reserva um espaço correspondente à maior estrutura
da lista
• O resultado é que se troca a soma dos espaços necessários
para cada estrutura, pelo espaço necessário para a maior
delas.
• Cada vez que quisermos trabalhar com uma das estruturas,
podemos copiar a mesma para a união, porque temos a
certeza de que haverá espaço suficiente para contê-la.
• Uniões são uma forma prática e elegante de economizar
memória!

9. UNIÕES
• Estruturas são excelentes para manter a ordem e tornarem o
código fonte legível.
• Estruturas são práticas, rápidas e eficientes
• São utilizadas com frequência em aplicativos e sistemas
operacionais que dependam de desempenho e de
confiabilidade.
• As uniões, por sua vez, garantem um melhor aproveitamento
da memória.

10. Declarações de Uniões
• Uma união é declarada com a palavra-chave union no mesmo
formato de uma estrutura.
union numero {
int x;
double y;
}
• A declaração acima indica que número é um tipo union com
os membros int x e double y.
• A declaração da união normalmente é colocada no cabeçalho
e incluída em todos os arquivos-fonte que usam o tipo união.

11. Declarações de Uniões
• Assim como a declaração de struct, uma declaração de union
simplesmente cria um novo tipo.
• Colocar uma declaração de union ou struct fora de uma
função não cria uma variável global.
• Uma union é o meio pelo qual um pedaço de memória é
tratado ora como uma variável de um certo tipo, ora como
outra variável de outro tipo.
• Uniões podem ser usadas para poupar memória.
• Uma struct aloca um espaço diferente de memória para cada
membro.

12. Operações que podem ser
realizadas em uniões
• As operações que podem ser realizadas em uma união são as
seguintes:
• Atribuição de uma união a outra união do mesmo tipo;
• Coleta do endereço (&) de uma variável de união;
• Acesso dos membros da união usando o operador de membro
da estrutura e o operador de ponteiro da estrutura;
• As uniões não podem ser comparadas com os operadores == e !=
pelos mesmos motivos pelos quais as estruturas não podem ser
comparadas.

13. Inicialização de uniões em
declarações
• Em uma declaração, uma união pode ser inicializada com um valor
do mesmo tipo que o primeiro membro da união.
• Por exemplo, com a união anterior, a declaração
union número valor = { 10 };
• é uma inicialização válida de uma variável de união valor, pois a
união é inicializada com um int

14. Demonstração de Uniões
• O programa a seguir usa a variável VALUE do tipo UNION
NUMBER para exibir o valor armazenado na união como um
INT e um DOUBLE.
• A saída do programa depende da implementação.
• A saída do programa mostra que a representação interna de
um valor DOUBLE pode ser muito diferente da representação
de INT.
• Uniões são tipos de dados que armazenam um único membro
por vez.
• Os membros de uma union representam os diversos tipos de
dados que ela pode conter.

15. Demonstração de Uniões
#include <stdio.h>
union number{
int x;
double y;
};
int main(void) {
union number value; //declara a variável de union
//coloca um inteiro na union
value.x = 100;
printf( “ %s n %s n %s n %d n n %s n %f n”,
“Coloca um valor no membro inteiro”,
“e mostra os dois membros.”,
“int:”, value.x,
“double:”, value.y);

16. Demonstração de Uniões
// coloca um double na mesma union
value.x = 100.0;
printf( “ %s n %s n %s n %d n n %s n %f n”,
“Coloca um valor no membro de ponto flutuante”,
“e mostra os dois membros.”,
“int:”, value.x,
“double:”, value.y);
return 0;
}

17. Constantes de Enumeração
• Essa enumeração cria um novo tipo, em que os identificadores
são definidos como os inteiros de 0 a 11, respectivamente.
• Para numerar os meses de 1 a 12, use a seguinte enumeração:
enum months {
jan = 1, fev, mar, abr, mai, jun, jul, ago, set, out, nov,
dez; }
• Como o primeiro valor nessa enumeração é explicitamente
definido como 1, os valores restantes serão incrementados a
partir de 1 resultando nos valores de 0 a 11.

18. Constantes de Enumeração
• Uma enumeração, introduzida pela palavra-chave enum, é um
conjunto de constantes de enumeração inteiras,
representadas por identificadores.
• Os valores em um enum começam com zero, a menos que
haja outras especificações, e são incrementados por 1.
• Exemplo:
enum months {
jan, fev, mar, abr, mai, jun, jul, ago, set, out, nov, dez
};

19. Constantes de Enumeração
• Os identificadores em uma enumeração precisam ser
exlusivos.
• O valor de cada constante em uma enumeração pode ser
definido explicitamente pela declaração que atribui um valor
ao identificador.
• Vários membros de uma enumeração podem ter o mesmo
valor constante.
• Tipos enumerados são usados quando conhecemos o
conjunto de valores que uma variável pode assumir.
• A variável desse tipo é sempre INT.

20. Constantes de Enumeração
#include <stdio.h>
enum months {
JAN = 1, FEV, MAR, ABR, MAI, JUN, JUL, AGO, SET, OUT, NOV, DEZ
};
int main(void) {
//pode conter qualquer um dos 12 meses
enum months month;
"Julho",
//inicializa array de ponteiros
const char *monthName[] = {"", "Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho",
"Agosto", "Setembro", "Outubro", "Novembro", "Dezembro"};
//loop pelos meses
for( month=JAN; month <= DEZ; month++){
printf(" %2d %11s n", month, monthName[month]);
fflush(stdout);
}
return 0;
}

21. Constantes de Enumeração

22. Função ATOI() e ATOF()
• Função atoi():
• Recebe o endereço de uma string como argumento e o
converte para um valor inteiro.
• Caso a string não contenha um número válido, ela retornará
zero.
• Espaços em branco iniciais são ignorados.
• Função atof():
• Recebe o endereço de uma string como um argumento e o
converte em um valor double.
• Caso a string não contenha um número válido, ela retornará
zero.
• Espaços em branco iniciais são ignorados.

23. Função EXIT()
• Permite o término imediato do programa e passa o controle
ao sistema operacional.
• A função exit() finaliza o programa.
• O seu argumento é um número inteiro que é retornado ao
sistema operacional e pode ser acessado por meio do
subcomando ERRORLEVEL de um programa .BAT.
• O arquivo .BAT pode conter uma linha como IF ERRORLEVER 1
GOTO ERR1, o que provoca uma mudança de operação,
dependendo do valor de retorno indicado pelo término do
programa.
• O zero costuma ser usado para indicar o término normal do
programa.

24. Exercícios