Escola Secundária c/ 3º CEB da Batalha
Estruturas
Linguagem C
Estruturas
• Struct são colecções de dados heterogêneos
agrupados em uma mesma estrutura de
dados
• Ex:
armazenas as coordenadas (x,y) de um ponto:
(x, y)
Linguagem C
TTipos Complexos
•Tipos básicos: char, int, float, etc.
Variáveis guardam um só valor.
•Matrizes: v.g. char matriz[20]
Variáveis guardam colecções de objectos
do mesmo tipo.

Como guardar colecções de tipos diversos?
Linguagem C
Solução: Estruturas
• Declaração:
struct {
int x;
int y;
} p1, p2;
(x, y)
• a estrutura contém dois inteiros, x e y
• p1 e p2 são duas variáveis tipo struct
contendo duas coordenadas cada.
Linguagem C
Estruturas
Exemplo:
struct {
char nome[NOME_MAX + 1];
int numero;
double media;
} aluno1, aluno2;
• Informação diversa sobre uma única entidade (um
aluno).
• Podem conter matrizes (e vice-versa).
• Podem conter outras estruturas.
Linguagem C
Declaração
• Formato da declaração:
struct nome_da_estrutura {
tipo_1 dado_1;
tipo_2 dado_2;
...
tipo_n dado_n;
} lista_de_variaveis;
• A estrutura pode agrupar um número arbitrário de
dados de tipos diferentes
• Pode nomear-se a estrutura para referenciá-la
Linguagem C
Definição de Tipos
struct {
int x;
int y;
} p1;
• struct
Repetição
struct {
int x;
int y;
} p2;
ponto define um novo tipo de dado
struct ponto {
int x;
int y;
};
struct ponto p1, p2;
• Pode definir-se novas variáveis do tipo ponto
Linguagem C
Definição de Tipos (declaração de variáveis)
struct Aluno {
Novo tipo:
struct Aluno
char nome[NOME_MAX + 1];
int numero;
 Definição de variáveis:
struct Aluno aluno1,
double media;
aluno2,*p, lista[10];
};
Equivalente a:
struct {
char nome[NOME_MAX + 1];
int numero;
double media;
}aluno1,aluno2,*p,
lista[10];
Linguagem C
Inicialização
struct Aluno {
char nome[NOME_MAX + 1];
int numero;
double media;};
struct Aluno aluno = {"Zacarias", 666, 20.0};
aluno
nome:
numero:
media:
Linguagem C
Acesso aos dados
struct-var.campo
Exemplo:
aluno1.nome = “Pedro”;/*atribuição */
aluno2.nome = “João;
if ((aluno1.nome == aluno2.nome) &&
(aluno1.media >= aluno2.media))
...
Linguagem C
Inicialização de estruturas
struct Aluno {
char nome[NOME_MAX + 1];
int numero;
double media;};
struct Aluno
aluno = {"Zacarias", 666,
20.0};
Equivalente a:
struct Aluno aluno;
strcpy(aluno.nome,"Zacarias
);
aluno.numero = 666;
aluno.media = 20.0;
aluno
nome: Z a ca r i as
numero: 666
media:
20.0
Linguagem C
Atribuição de Estruturas
Revisão:
• Inicialização de uma estrutura:
struct ponto p1 = { 220, 110 };
• Atribuição entre estruturas do mesmo tipo:
struct ponto p1 = { 220, 110 };
struct ponto p2;
p2 = p1; /* p2.x = p1.x e p2.y = p1.y */
• Os campos correspondentes das estruturas são
automaticamente copiados do destino para a origem
p1
x:
y:
220
110
p2
x:
y:
p2 = p1
p2
x:
y:
220
110
Linguagem C
Atribuição de Estruturas
• Atenção para estruturas que contenham ponteiros:
struct aluno {
char *nome;
int idade;
} a1, a2;
a1.nome = “Afranio”;
a1.idade = 32;
a2 = a1;
• Agora a1 e a2 apontam para a mesma string nome:
a1.nome == a2.nome == “Afranio”
Linguagem C
Composição de Estruturas
struct rectangulo {
struct ponto inicio;
struct ponto fim;
};
struct rectangulo r = { { 10, 20
},
{ 30 , 40 }
};
• Acesso aos dados:
r.inicio.x += 10;
r.inicio.y -= 10;
r
inicio
x: 10
y: 20
fim
x:
y:
30
40
Linguagem C
Estruturas como parâmetros
struct ponto cria_ponto (int x, int y) {
struct ponto tmp;
tmp.x = x;
tmp.y = y;
return tmp;
p
x:
y:
10
20
}
main () {
p
struct ponto p = cria_ponto(10, 20); x:
y:
}
Linguagem C
Operações
Operações entre membros das estruturas devem
ser feitas membro a membro:
/* retorna uma cópia de p1 = p1 + p2 */
struct soma_pts (struct ponto p1, struct ponto p2)
{
p1.x += p2.x; (relembro que p1.x = p1.x +p2.x)
p1.y += p2.y;
return p1;
}
/* retorna uma copia de p1 */
Linguagem C
Arrays de Estruturas
struct ponto arp[10];
/* cria um array de 10 pontos */
arp[1].x = 5;
/*atribui 5 a coordenada x do 2º ponto */
struct jogador {
char *nome;
int idade;
};
struct jogador PT[4] = {“Figo”,32,
“Carlos”, 24,
“Rui Costa”,27
...};
PT
nome:
idade:
nome:
idade:
Figo
32
Carlos
24
nome: Rui Costa
idade: 27
nome:
idade:
...
...
Linguagem C
Ponteiros para Estruturas
Estruturas grandes são passadas como parâmetros
p1
de forma mais eficiente através de ponteiros
x:
y:
10
20
struct ponto *pp;
pp
1002
struct ponto p1 = { 10, 20 };
1002
pp = &p1;
printf(“Ponto P1: (%d %d)\n”, (*pp).x, (*pp).y};
• Aceder com o operador “->”:
printf(“Ponto P1: (%d %d)\n”, pp->x, pp->y};
(*pp).x == pp->x
Linguagem C
Espaço Alocado para uma Estrutura
struct aluno {
char *nome;
short idade;
char matricula[8];
};
/* ponteiro 4 bytes */
/* 2 bytes */
/* array 8 bytes */
struct aluno al
*
struct aluno al;
30
al.nome = “Xexeo”;
“00/0000”
al.idade = 30;
strcpy(al.matricula, “00/0001”);
“Xexeo”
Linguagem C
Função sizeof(tipo)
• A função sizeof(tipo) retorna o tamanho em
bytes ocupado na memória pelo tipo de dado
passado como parâmetro
Ex:
sizeof(int)
sizeof(char)
sizeof(struct ponto)
sizeof(struct ponto *)
=>
=>
=>
=>
4
1
8
4
bytes
byte
bytes
bytes
Linguagem C
Espaço Efectivo
/* teste com Symantec C, PowerPC 603 - Macintosh */
struct aluno {
char *nome;
/* 4
short idade;
/* 2
char matricula[3];
/* 3
};
/* sizeof(aluno)
bytes */
bytes */
bytes */
= 12 bytes */
Linguagem C
Espaço Efectivo
/* teste com Symantec C, PowerPC 603 - Macintosh */
struct aluno1 {
char *nome;
short idade;
char matricula[5];
};
/* 4 bytes */
/* 2 bytes */
/* 5 bytes */
/* sizeof(aluno1) = 12 bytes */
Linguagem C
Espaço Efectivo
/* teste com Symantec C, PowerPC 603 - Macintosh */
struct aluno2 {
char *nome;
/* 4 bytes
short idade;
/* 2 bytes
char matricula[7];
/* 7 bytes
};
/* sizeof(aluno2) = 16
*/
*/
*/
bytes */
• no PowerMac uma estrutura é um múltiplo do tamanho
da palavra, 32 bits
Linguagem C