06-variaveis-compostas-homogeneas

Prévia do material em texto

Variáveis Compostas Homogêneas 
• Da mesma forma que a teoria de conjuntos: 
– Uma variável pode ser considerada como um 
elemento. 
– Uma estrutura de dados como um conjunto. 
 
• Quando uma estrutura de dados for composta 
de variáveis do mesmo tipo primitivo, tem-se 
um conjunto homogêneo de dados. 
Variável Composta Homogênea 
Unidimensional (Vetores) 
 
• Analogia a um edifício. 
– Edifício representa o conjunto de dados. 
– Os andares representam uma partição do edifício. 
 
• Para chegar a um determinado andar, precisa 
apenas do número do andar. 
Vetores em C 
• [modificador] tipo identificador[tamanho]; 
 
• unsigned int V[8]; 
 
 
• char Str[15]; 
 
0 1 2 3 4 5 6 7 
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 
Vetores em C 
 
 
• Quando se declara um vetor, um espaço em 
bytes é reservado na memória e que se 
encontra linearmente disposto a partir de um 
endereço base. 
Executando Passo a Passo 
0 1 2 3 4 
int main() { 
 int V[5]; 
 V[0] = 2; 
 V[1] = 10; 
 V[V[0]] = V[0] + 5 * V[1]; 
 V[4] = V[2] – 8 / V[0]; 
 V[3] = V[1]; 
} 
Executando Passo a Passo 
0 1 2 3 4 
int main() { 
 int V[5]; 
 V[0] = 2; 
 V[1] = 10; 
 V[V[0]] = V[0] + 5 * V[1]; 
 V[4] = V[2] – 8 / V[0]; 
 V[3] = V[1]; 
} 
Executando Passo a Passo 
 
0 1 2 3 4 
int main() { 
 int V[5]; 
 V[0] = 2; 
 V[1] = 10; 
 V[V[0]] = V[0] + 5 * V[1]; 
 V[4] = V[2] – 8 / V[0]; 
 V[3] = V[1]; 
} 
Executando Passo a Passo 
 7 
0 1 2 3 4 
int main() { 
 int V[5]; 
 V[0] = 2; 
 V[1] = 10; 
 V[V[0]] = V[0] + 5 * V[1]; 
 V[4] = V[2] – 8 / V[0]; 
 V[3] = V[1]; 
} 
Executando Passo a Passo 
 7 
0 1 2 3 4 
int main() { 
 int V[5]; 
 V[0] = 2; 
 V[1] = 10; 
 V[V[0]] = V[0] + 5 * V[1]; 
 V[4] = V[2] – 8 / V[0]; 
 V[3] = V[1]; 
} 
Executando Passo a Passo 
 
0 1 2 3 4 
int main() { 
 int V[5]; 
 V[0] = 2; 
 V[1] = 10; 
 V[V[0]] = V[0] + 5 * V[1]; 
 V[4] = V[2] – 8 / V[0]; 
 V[3] = V[1]; 
} 
Executando Passo a Passo 
 
0 1 2 3 4 
int main() { 
 int V[5]; 
 V[0] = 2; 
 V[1] = 10; 
 V[V[0]] = V[0] + 5 * V[1]; 
 V[4] = V[2] – 8 / V[0]; 
 V[3] = V[1]; 
} 
Executando Passo a Passo 
 
0 1 2 3 4 
int main() { 
 int V[5]; 
 V[0] = 2; 
 V[1] = 10; 
 V[V[0]] = V[0] + 5 * V[1]; 
 V[4] = V[2] – 8 / V[0]; 
 V[3] = V[1]; 
} 
Executando Passo a Passo 
 
0 1 2 3 4 
int main() { 
 int V[5]; 
 V[0] = 2; 
 V[1] = 10; 
 V[V[0]] = V[0] + 5 * V[1]; 
 V[4] = V[2] – 8 / V[0]; 
 V[3] = V[1]; 
} 
Executando Passo a Passo 
 
0 1 2 3 4 
int main() { 
 int V[5]; 
 V[0] = 2; 
 V[1] = 10; 
 V[V[0]] = V[0] + 5 * V[1]; 
 V[4] = V[2] – 8 / V[0]; 
 V[3] = V[1]; 
} 
Executando Passo a Passo 
 7 
0 1 2 3 4 
int main() { 
 int V[5]; 
 V[0] = 2; 
 V[1] = 10; 
 V[V[0]] = V[0] + 5 * V[1]; 
 V[4] = V[2] – 8 / V[0]; 
 V[3] = V[1]; 
} 
Inicialização de Vetores 
• A inicialização de um vetor é realizada quando 
da declaração do vetor. 
• unsigned int Vetor[4] = {100, 200, 300, 400}; 
 
 
• float B[4] = {2.4, 124, 2e1, 3E-5}; 
 
 
 
 
0 1 2 3 
0 1 2 3 
Inicialização de Vetores 
• double Tipos[4] = {1.1, 1.2, 1.3, 1.4}; 
 
 
• unsigned int Idades[10] = {10, 22, 21, 18, 50, 
23, 45, 60, 10, 34}; 
0 1 2 3 
0 1 2 3 4 5 6 7 8 9 
Inicialização de Vetores de Caracteres 
• char Nome*14+ = “Computação”; 
 
 
• char Nome*10+ = “Computação”; 
 
 
C o m p u t a ç ã o \0 
0 1 2 3 4 5 6 7 8 9 10 11 12 13 
C o m p u t a ç ã o 
0 1 2 3 4 5 6 7 8 9 
Inicialização de Vetores de Caracteres 
• unsigned char V*5+ = “UFMG”; 
 
 
• unsigned char Str*7+ = ,‘P’, ’U’, ’C’, ’-’, ’M’, ’G’, ‘\0’-; 
 
 
• char X*5+ = “P”; 
 
U F M G \0 
0 1 2 3 4 
P U C - M G \0 
0 1 2 3 4 5 6 
P \0 
0 1 2 3 4 
Vetores sem Dimensão 
• Dadas as declarações e inicializações: 
– int A[] = {12,13,14,15}; 
– char B*+ = “ENGENHARIA ELÉTRICA”; 
• Estas declarações e inicializações equivalem a: 
– int *A = {12,13,14,15}; 
– char *B = “ENGENHARIA ELÉTRICA”; 
• São duas notações diferentes para a mesma 
coisa. 
Vetores sem Dimensão 
 
• A[] ou B[] são ponteiros que possuem endereços 
das áreas de constantes. 
 
• MUITO CUIDADO AO MANIPULAR PORQUE 
PODERÁ ESTAR MANIPULANDO A ÁREA DE 
CÓDIGO E/OU A ÁREA DE DADOS DA MEMÓRIA. 
 
Observações sobre Vetores 
 
• O cálculo do tamanho em bytes de um vetor está 
diretamente em função do tamanho do vetor e 
do tipo do vetor. 
 
• Tamanho em bytes = tamanho do tipo * tamanho 
do vetor. 
Observações sobre Vetores 
• Na linguagem C não existe verificação dos limites 
de um vetor. 
• Pode-se ultrapassar os limites e escrever dados 
no lugar de uma outra variável ou mesmo no 
código do programa. 
• É responsabilidade do programador prover a 
verificação dos limites onde for necessário, de 
modo que nunca invada o espaço de memória, 
de uma outra variável. 
 
Variáveis Compostas Homogêneas 
Multidimensionais (Matrizes) 
• Analogia a um edifício. 
– Edifício representa o conjunto de dados. 
– Os andares representam uma partição do edifício. 
– Os apartamentos representam uma partição do 
andar. 
• Para chegar a um determinado apartamento, é 
preciso: 
– do número do andar . 
– do número do apartamento. 
• Portanto duas informações (dois índices). 
Variáveis Compostas Homogêneas 
Multidimensionais (Matrizes) 
• Suponha um conjunto residencial com três 
prédios de apartamentos. 
• Tem-se uma estrutura homogênea 
tridimensional. 
• Para chegar a um apartamento é necessário: 
– O número do prédio. 
– O número do andar. 
– O número do apartamento. 
Variáveis Compostas Homogêneas 
Multidimensionais (Matrizes) 
 
 
• Dependendo do problema a ser resolvido, 
pode-se ter a estrutura composta homogênea 
multidimensional que se desejar. 
Matrizes em C 
[modificador] tipo identificador[num_linhas][num_colunas] 
short int M[5][7]; 
0 1 2 3 4 5 6 
0 
1 
2 
3 
4 
Matrizes em C 
 
 
• Quando se declara uma matriz, um espaço em 
bytes é reservado na memória que se 
encontra linearmente disposto a partir de um 
endereço base. 
Inicialização de Matrizes 
unsigned long int V[2][2] = {{111,222},{333,444}}; 
0 1 
0 111 222 
1 333 444 
double V[2][10] = {{1,1,1,1,1,1,1,1,1,1,},{2,2,2,2,2,2,2,2,2,2}}; 
0 1 2 3 4 5 6 7 8 9 
0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 
1 2.0 2.0 2.0 2.0 2.0 2.0 2.0 2.0 2.0 2.0 
Executando Passo a Passo 
int main() { 
 int x, y; 
 double M[3][4] = {{0,0,0},{0,0,0},{0,0,0}}; 
 
 x = 2; 
 y = 3; 
 M[0][0] = 10; 
 M[2][1] = 4.34 + M[x – 2][y – 3]; 
 M[x][x] = 3.e-3; 
 M[x][y] = 100.01; 
} 
 
X 
Executando Passo a Passo 
int main() { 
 int x, y; 
 double M[3][4] = {{0,0,0},{0,0,0},{0,0,0}}; 
 
 x = 2; 
 y = 3; 
 M[0][0] = 10; 
 M[2][1] = 4.34 + M[x – 2][y – 3]; 
 M[x][x] = 3.e-3; 
 M[x][y] = 100.01; 
} 
 
X 
Y 
Executando Passo a Passo 
int main() { 
 int x, y; 
 double M[3][4] = {{0,0,0},{0,0,0},{0,0,0}}; 
 
 x = 2; 
 y = 3; 
 M[0][0] = 10; 
 M[2][1] = 4.34 + M[x – 2][y – 3]; 
 M[x][x] = 3.e-3; 
 M[x][y] = 100.01; 
} 
 
0 1 2 3 
0 
1 
2 
X 
Y 
Executando Passo a Passo 
int main() { 
 int x, y; 
 double M[3][4] = {{0,0,0,0},{0,0,0,0},{0,0,0,0}}; 
 
 x = 2; 
 y = 3; 
 M[0][0] = 10; 
 M[2][1] = 4.34 + M[x – 2][y – 3]; 
 M[x][x] = 3.e-3; 
 M[x][y] = 100.01; 
} 
 
0 1 2 3 
0 0.0 0.0 0.0 0.0 
1 0.0 0.0 0.0 0.0 
2 0.0 0.0 0.0 0.0 
X 
Y 
Executando Passo a Passo 
int main() { 
 int x, y; 
 double M[3][4] = {{0,0,0},{0,0,0},{0,0,0}}; 
 
 x = 2; 
 y = 3; 
 M[0][0] = 10; 
 M[2][1] = 4.34 + M[x – 2][y – 3]; 
 M[x][x] = 3.e-3; 
 M[x][y] = 100.01; 
} 
 
0 1 2 3 
0 0.0 0.0 0.0 0.0 
1 0.0 0.0 0.0 0.0 
2 0.0 0.0 0.0 0.0 
X 2 
Y 
Executando Passo a Passo 
int main() { 
 int x, y; 
 double M[3][4] = {{0,0,0},{0,0,0},{0,0,0}}; 
 
 x = 2;y = 3; 
 M[0][0] = 10; 
 M[2][1] = 4.34 + M[x – 2][y – 3]; 
 M[x][x] = 3.e-3; 
 M[x][y] = 100.01; 
} 
 
0 1 2 3 
0 0.0 0.0 0.0 0.0 
1 0.0 0.0 0.0 0.0 
2 0.0 0.0 0.0 0.0 
X 2 
Y 3 
Executando Passo a Passo 
int main() { 
 int x, y; 
 double M[3][4] = {{0,0,0},{0,0,0},{0,0,0}}; 
 
 x = 2; 
 y = 3; 
 M[0][0] = 10; 
 M[2][1] = 4.34 + M[x – 2][y – 3]; 
 M[x][x] = 3.e-3; 
 M[x][y] = 100.01; 
} 
 
0 1 2 3 
0 10.0 0.0 0.0 0.0 
1 0.0 0.0 0.0 0.0 
2 0.0 0.0 0.0 0.0 
X 2 
Y 3 
Executando Passo a Passo 
int main() { 
 int x, y; 
 double M[3][4] = {{0,0,0},{0,0,0},{0,0,0}}; 
 
 x = 2; 
 y = 3; 
 M[0][0] = 10; 
 M[2][1] = 4.34 + M[x – 2][y – 3]; 
 M[x][x] = 3.e-3; 
 M[x][y] = 100.01; 
} 
 
0 1 2 3 
0 10.0 0.0 0.0 0.0 
1 0.0 0.0 0.0 0.0 
2 0.0 0.0 0.0 0.0 
X 2 
Y 3 
Executando Passo a Passo 
int main() { 
 int x, y; 
 double M[3][4] = {{0,0,0},{0,0,0},{0,0,0}}; 
 
 x = 2; 
 y = 3; 
 M[0][0] = 10; 
 M[2][1] = 4.34 + M[x – 2][y – 3]; 
 M[x][x] = 3.e-3; 
 M[x][y] = 100.01; 
} 
 
0 1 2 3 
0 10.0 0.0 0.0 0.0 
1 0.0 0.0 0.0 0.0 
2 0.0 0.0 0.0 0.0 
X 2 
Y 3 
Executando Passo a Passo 
int main() { 
 int x, y; 
 double M[3][4] = {{0,0,0},{0,0,0},{0,0,0}}; 
 
 x = 2; 
 y = 3; 
 M[0][0] = 10; 
 M[2][1] = 4.34 + M[x – 2][y – 3]; 
 M[x][x] = 3.e-3; 
 M[x][y] = 100.01; 
} 
 
0 1 2 3 
0 10.0 0.0 0.0 0.0 
1 0.0 0.0 0.0 0.0 
2 0.0 0.0 0.0 0.0 
X 2 
Y 3 
Executando Passo a Passo 
int main() { 
 int x, y; 
 double M[3][4] = {{0,0,0},{0,0,0},{0,0,0}}; 
 
 x = 2; 
 y = 3; 
 M[0][0] = 10; 
 M[2][1] = 4.34 + M[x – 2][y – 3]; 
 M[x][x] = 3.e-3; 
 M[x][y] = 100.01; 
} 
 
0 1 2 3 
0 10.0 0.0 0.0 0.0 
1 0.0 0.0 0.0 0.0 
2 0.0 14.34 0.0 0.0 
X 2 
Y 3 
Executando Passo a Passo 
int main() { 
 int x, y; 
 double M[3][4] = {{0,0,0},{0,0,0},{0,0,0}}; 
 
 x = 2; 
 y = 3; 
 M[0][0] = 10; 
 M[2][1] = 4.34 + M[x – 2][y – 3]; 
 M[x][x] = 3.e-3; 
 M[x][y] = 100.01; 
} 
 
0 1 2 3 
0 10.0 0.0 0.0 0.0 
1 0.0 0.0 0.0 0.0 
2 0.0 14.34 3.e-3 0.0 
X 2 
Y 3 
Executando Passo a Passo 
int main() { 
 int x, y; 
 double M[3][4] = {{0,0,0},{0,0,0},{0,0,0}}; 
 
 x = 2; 
 y = 3; 
 M[0][0] = 10; 
 M[2][1] = 4.34 + M[x – 2][y – 3]; 
 M[x][x] = 3.e-3; 
 M[x][y] = 100.01; 
} 
 
0 1 2 3 
0 10.0 0.0 0.0 0.0 
1 0.0 0.0 0.0 0.0 
2 0.0 14.34 3.e-3 100.01 
X 2 
Y 3 
Declarando uma Matriz 
char V[2][5]; 
char *m; 
 
m = (char *) V; 
m*5*1+0+ = ‘X’; 
m*5*0+3+ = ‘Y’; 
m*5*1+1+ = ‘Z’; 
FF00 
FF01 
FF02 
FF03 
FF04 
FF05 
FF06 
FF07 
FF08 
FF09 
FF0A 
FF0B 
FF0C 
FF0D 
FF0E 
FF0F 
FF10 
FF11 
Total de colunas*linha+coluna 
0 1 2 3 4 
0 
1 
Declarando um Ponteiro para 
uma Matriz 
char V[2][5]; 
char *m; 
 
m = (char *) V; 
m*5*1+0+ = ‘X’; 
m*5*0+3+ = ‘Y’; 
m*5*1+1+ = ‘Z’; 
FF00 
FF01 
FF02 
FF03 
FF04 
FF05 
FF06 
FF07 
FF08 
FF09 
FF0A 
FF0B 
FF0C 
FF0D 
FF0E 
FF0F 
FF10 
FF11 
Total de colunas*linha+coluna 
0 1 2 3 4 
0 
1 
V 
Recebe o Endereço de uma 
Matriz 
char V[2][5]; 
char *m; 
 
m = (char *) V; 
m*5*1+0+ = ‘X’; 
m*5*0+3+ = ‘Y’; 
m*5*1+1+ = ‘Z’; 
FF00 
FF01 
FF02 
FF03 
FF04 
FF05 
FF06 
FF07 
FF08 
FF09 
FF0A 
FF0B 
FF0C 1111 1111 
FF0D 0000 0001 
FF0E 0000 0000 
FF0F 0000 0000 
FF10 
FF11 
Total de colunas*linha+coluna 
0 1 2 3 4 
0 
1 
V 
Atribuindo 
char V[2][5]; 
char *m; 
 
m = (char *) V; 
m*5*1+0+ = ‘X’; 
m*5*0+3+ = ‘Y’; 
m*5*1+1+ = ‘Z’; 
FF00 
FF01 
FF02 
FF03 
FF04 
FF05 1001 1000 
FF06 
FF07 
FF08 
FF09 
FF0A 
FF0B 
FF0C 1111 1111 
FF0D 0000 0001 
FF0E 0000 0000 
FF0F 0000 0000 
FF10 
FF11 
Total de colunas*linha+coluna 
0 1 2 3 4 
0 
1 X 
V 
Atribuindo 
char V[2][5]; 
char *m; 
 
m = (char *) V; 
m*5*1+0+ = ‘X’; 
m*5*0+3+ = ‘Y’; 
m*5*1+1+ = ‘Z’; 
FF00 
FF01 
FF02 
FF03 1001 1001 
FF04 
FF05 1001 1000 
FF06 
FF07 
FF08 
FF09 
FF0A 
FF0B 
FF0C 1111 1111 
FF0D 0000 0001 
FF0E 0000 0000 
FF0F 0000 0000 
FF10 
FF11 
Total de colunas*linha+coluna 
0 1 2 3 4 
0 Y 
1 X 
V 
Atribuindo 
char V[2][5]; 
char *m; 
 
m = (char *) V; 
m*5*1+0+ = ‘X’; 
m*5*0+3+ = ‘Y’; 
m*5*1+1+ = ‘Z’; 
FF00 
FF01 
FF02 
FF03 1001 1010 
FF04 
FF05 1001 1000 
FF06 1001 1000 
FF07 
FF08 
FF09 
FF0A 
FF0B 
FF0C 1111 1111 
FF0D 0000 0001 
FF0E 0000 0000 
FF0F 0000 0000 
FF10 
FF11 
Total de colunas*linha+coluna 
0 1 2 3 4 
0 Y 
1 X Z 
V 
Variáveis Compostas Heterogêneas 
• Estrutura – é uma coleção de variáveis 
referenciadas por um nome. 
• Trata-se de uma maneira eficiente de se agrupar 
informações relacionadas. 
• A definição de uma estrutura forma um modelo 
que pode ser usado para criar variáveis 
estruturas. 
• As variáveis estruturas que compreendem a 
estrutura são chamadas elementos (CAMPOS) 
da estrutura 
Definição de uma Estrutura 
struct IDENTIFICADOR { 
 [modificador] tipo identificador; 
 [modificador] tipo identificador[tamanho]; 
 [modificador] tipo identificador[linhas][colunas]; 
 [modificador] tipo *identificador; 
 [modificador] tipo *identificador[tamanho]; 
 struct XXXX identificador; 
}; 
 
• Definir uma estrutura é criar um modelo. 
• Não ocupa espaço na memória 
Exemplo de Definição de uma 
Estrutura 
struct REGISTRO { 
 char nome[65]; 
 char rua[45]; 
 char cidade[25]; 
 char cep[8]; 
 char fone[11]; 
 int idade; 
 double salario; 
}; 
 
Declarações de Estruturas 
• struct REGISTRO funcionario; 
• struct REGISTRO funcionarios[10]; 
• struct REGISTRO *funcionario; 
• struct REGISTRO funcionarios[5][10]; 
• struct REGISTRO *funcionarios[7]; 
 
• Declarar uma estrutura é reservar um espaço na 
memória para a estrutura. 
Definição de Estruturas 
struct DATA { 
 int dia, mes, ano; 
}; 
struct PERIODO { 
 struct DATA inicio; 
 struct DATA fim; 
}; 
Declaração e Manipulação de 
Estruturas 
 /* declaração e inicialização */ 
 struct PERIODO p_1 = {{20,9,2011},{22,9,2011}}; 
 /* declarações sem inicializações */ 
 struct PERIODO p_2, p_3; 
 
 p_2 = p_1; /* atualização completa */ 
 p_3.inicio.dia = 13; /* atualização seletiva */ 
 p_3.inicio.mes = 10; /* atualização seletiva */ 
 p_3.inicio.ano = 2010; /* atualização seletiva */ 
 p_3.fim = p_2.fim; 
 
printf("\nData inicio: {%i,%i,%i}",p_3.inicio.dia,p_3.inicio.mes,p_3.inicio.ano); 
printf("\nData inicio: {%i,%i,%i}",p_3.fim.dia,p_3.fim.mes,p_3.fim.ano); 
Ponteiros para Estruturas 
 /* declaração e inicialização */ 
 struct PERIODO *m, a = {{20,9,2011},{22,9,2011}}; 
 /* atribuindo o endereço de uma estrutura */ 
 m = &a; 
 
 m->inicio.dia = 10; 
 m->fim.dia = 13; 
 m->fim.ano = 2012; 
 
 printf("\nData inicio: {%i,%i,%i}",m->inicio.dia,m->inicio.mes,m->inicio.ano); 
 printf("\nData inicio: {%i,%i,%i}", m->fim.dia, m->fim.mes, m->fim.ano); 
Espaço de Memória Ocupado 
• Corresponde ao número de bytes dos 
elementos (CAMPOS) da estrutura. 
• A declaração: 
– struct DATA d; 
– A variável d ocupa 12 bytes. 
• A declaração: 
– struct PERIODO p; 
– A variável p ocupa 24 bytes. 
Supondo Existir Limitações de 
Memória 
 /* definição da estrutura data */ 
struct DATA { 
 char dia, mes; 
 unsigned short ano; 
}; 
/* definição da estrutura PERIODO */ 
struct PERIODO { 
 struct DATA inicio, fim; 
}; 
Qual o ganho de memória? 
Qual seria o ganho de memória após a declaração 
de uma variável do tipo PERIODO? 
 
Versão antiga de PERIODO ao declarar: 
struct p; /* 12+12=24 bytes na memória */ 
 
Verão nova de PERIODO ao declarar: 
struct p; /* 4+4=8 bytes na memória */ 
 
Ganho de memoria: 
Ganho = 1 – novo (bytes)/antigo (bytes) 
 = 1 – 8/24 
 = 1 – 0,3333 = 0,6667 ≈ 66,67% de ganho. 
Uma Estrutura 
na Memória 
struct P = {{20,9,2011},{22,9,2011}}; 
 
P.fim.mes = 11; 
P.inicio.ano = 2010. 
 
printf(“\nDia: %i”,P.inicio.dia);Printf(“\nMes: %i”,P.fim.mes); 
FF00 
FF01 
FF02 
FF03 
FF04 
FF05 
FF06 
FF07 
FF08 
FF09 
FF0A 
FF0B 
FF0C 
FF0D 
FF0E 
FF0F 
FF10 
FF11 
dia 
mes 
ano 
inicio 
dia 
mes 
ano 
fim 
P 
Uma Estrutura 
na Memória 
struct P = {{20,9,2011},{22,9,2011}}; 
 
P.fim.mes = 11; 
P.inicio.ano = 2010. 
 
printf(“\nDia: %i”,P.inicio.dia); 
Printf(“\nMes: %i”,P.fim.mes); 
FF00 
FF01 0001 0100 
FF02 0000 1001 
FF03 0000 0111 
FF04 1101 1011 
FF05 0001 0110 
FF06 0000 1001 
FF07 0000 0111 
FF08 1101 1011 
FF09 
FF0A 
FF0B 
FF0C 
FF0D 
FF0E 
FF0F 
FF10 
FF11 
dia 
mes 
ano 
inicio 
dia 
mes 
ano 
fim 
P 
Uma Estrutura 
na Memória 
struct P = {{20,9,2011},{22,9,2011}}; 
 
P.fim.mes = 11; 
P.inicio.ano = 2010. 
 
printf(“\nDia: %i”,P.inicio.dia); 
Printf(“\nMes: %i”,P.fim.mes); 
FF00 
FF01 0001 0100 
FF02 0000 1001 
FF03 0000 0111 
FF04 1101 1011 
FF05 0001 0110 
FF06 0000 1011 
FF07 0000 0111 
FF08 1101 1011 
FF09 
FF0A 
FF0B 
FF0C 
FF0D 
FF0E 
FF0F 
FF10 
FF11 
dia 
mes 
ano 
inicio 
dia 
mes 
ano 
fim 
P 
Uma Estrutura 
na Memória 
struct P = {{20,9,2011},{22,9,2011}}; 
 
P.fim.mes = 11; 
P.inicio.ano = 2010. 
 
printf(“\nDia: %i”,P.inicio.dia); 
Printf(“\nMes: %i”,P.fim.mes); 
FF00 
FF01 0001 0100 
FF02 0000 1001 
FF03 0000 0111 
FF04 1101 1010 
FF05 0001 0110 
FF06 0000 1011 
FF07 0000 0111 
FF08 1101 1011 
FF09 
FF0A 
FF0B 
FF0C 
FF0D 
FF0E 
FF0F 
FF10 
FF11 
dia 
mes 
ano 
inicio 
dia 
mes 
ano 
fim 
P 
Uma Estrutura 
na Memória 
struct P = {{20,9,2011},{22,9,2011}}; 
 
P.fim.mes = 11; 
P.inicio.ano = 2010. 
 
printf(“\nDia: %i”,P.inicio.dia); 
Printf(“\nMes: %i”,P.fim.mes); 
FF00 
FF01 0001 0100 
FF02 0000 1001 
FF03 0000 0111 
FF04 1101 1010 
FF05 0001 0110 
FF06 0000 1011 
FF07 0000 0111 
FF08 1101 1011 
FF09 
FF0A 
FF0B 
FF0C 
FF0D 
FF0E 
FF0F 
FF10 
FF11 
dia 
mes 
ano 
inicio 
dia 
mes 
ano 
fim 
P 
Uma Estrutura 
na Memória 
struct P = {{20,9,2011},{22,9,2011}}; 
 
P.fim.mes = 11; 
P.inicio.ano = 2010. 
 
printf(“\nDia: %i”,P.inicio.dia); 
Printf(“\nMes: %i”,P.fim.mes); 
FF00 
FF01 0001 0100 
FF02 0000 1001 
FF03 0000 0111 
FF04 1101 1010 
FF05 0001 0110 
FF06 0000 1011 
FF07 0000 0111 
FF08 1101 1011 
FF09 
FF0A 
FF0B 
FF0C 
FF0D 
FF0E 
FF0F 
FF10 
FF11 
dia 
mes 
ano 
inicio 
dia 
mes 
ano 
fim 
P 
Uniões 
 
• A definição é semelhante a definição de 
estruturas. Ao invés de struct tem-se union. 
 
• Compartilham a mesma posição de memória 
por duas ou mais diferentes variáveis 
(elementos ou campos da união) 
Definição/Declaração/Atualização 
/* definição */ 
union INT_32 { 
 char c[4]; 
 int i; 
}; 
/* declaração */ 
union INT_32 a; 
/* atualização */ 
a.i = 0xA0B0C0D0; 
a.c[0] = 0; 
 
Uma Estrutura 
na Memória 
union INT_32 U; 
 
U.i = 0xA0B0C0D0; 
 
printf(“\n%0X”,U.c*1+); 
printf(“\n%0X”,U.c*2+); 
printf(“\n%i”,U.c*1+); 
printf(“\n%i”,U.c*2+); 
FF00 
FF01 
FF02 
FF03 
FF04 
FF05 
FF06 
FF07 
FF08 
FF09 
FF0A 
FF0B 
FF0C 
FF0D 
FF0E 
FF0F 
FF10 
FF11 
c[0] 
c[1] 
c[2] 
c[3] 
i U 
Uma Estrutura 
na Memória 
union INT_32 U; 
 
U.i = 0xA0B0C0D0; 
 
printf(“\n%0X”,U.c*1+); 
printf(“\n%0X”,U.c*2+); 
printf(“\n%i”,U.c*1+); 
printf(“\n%i”,U.c*2+); 
FF00 
FF01 1101 0000 
FF02 1100 0000 
FF03 1011 0000 
FF04 1010 0000 
FF05 
FF06 
FF07 
FF08 
FF09 
FF0A 
FF0B 
FF0C 
FF0D 
FF0E 
FF0F 
FF10 
FF11 
c[0] 
c[1] 
i 
c[2] 
c[3] 
U 
Uma Estrutura 
na Memória 
union INT_32 U; 
 
U.i = 0xA0B0C0D0; 
 
printf(“\n%0X”,U.c*1+); 
printf(“\n%0X”,U.c*2+); 
printf(“\n%i”,U.c*1+); 
printf(“\n%i”,U.c*2+); 
FF00 
FF01 1101 0000 
FF02 1100 0000 
FF03 1011 0000 
FF04 1010 0000 
FF05 
FF06 
FF07 
FF08 
FF09 
FF0A 
FF0B 
FF0C 
FF0D 
FF0E 
FF0F 
FF10 
FF11 
c[0] 
c[1] 
i 
c[2] 
c[3] 
U 
Uma Estrutura 
na Memória 
union INT_32 U; 
 
U.i = 0xA0B0C0D0; 
 
printf(“\n%0X”,U.c*1+); 
printf(“\n%0X”,U.c*2+); 
printf(“\n%i”,U.c*1+); 
printf(“\n%i”,U.c*2+); 
FF00 
FF01 1101 0000 
FF02 1100 0000 
FF03 1011 0000 
FF04 1010 0000 
FF05 
FF06 
FF07 
FF08 
FF09 
FF0A 
FF0B 
FF0C 
FF0D 
FF0E 
FF0F 
FF10 
FF11 
c[0] 
c[1] 
i 
c[2] 
c[3] 
U 
Uma Estrutura 
na Memória 
union INT_32 U; 
 
U.i = 0xA0B0C0D0; 
 
printf(“\n%0X”,U.c*1+); 
printf(“\n%0X”,U.c*2+); 
printf(“\n%i”,U.c*1+); 
printf(“\n%i”,U.c*2+); 
FF00 
FF01 1101 0000 
FF02 1100 0000 
FF03 1011 0000 
FF04 1010 0000 
FF05 
FF06 
FF07 
FF08 
FF09 
FF0A 
FF0B 
FF0C 
FF0D 
FF0E 
FF0F 
FF10 
FF11 
c[0] 
c[1] 
i 
c[2] 
c[3] 
U 
Uma Estrutura 
na Memória 
union INT_32 U; 
 
U.i = 0xA0B0C0D0; 
 
printf(“\n%0X”,U.c*1+); 
printf(“\n%0X”,U.c*2+); 
printf(“\n%i”,U.c*1+); 
printf(“\n%i”,U.c*2+); 
FF00 
FF01 1101 0000 
FF02 1100 0000 
FF03 1011 0000 
FF04 1010 0000 
FF05 
FF06 
FF07 
FF08 
FF09 
FF0A 
FF0B 
FF0C 
FF0D 
FF0E 
FF0F 
FF10 
FF11 
c[0] 
c[1] 
i 
c[2] 
c[3] 
U 
Ponteiros para Uniões 
union INT_32 U, *a; 
 
a = &U; 
 
A->i = 0xA0B0C0D0; 
 
printf(“\n%0X”,a->c[1]); 
printf(“\n%0X”,a->c[2]); 
printf(“\n%i”,a->c[1]); 
printf(“\n%i”,a->c[2]);