Programação de

Computadores
Aula 7 e 8
13 e 20/09/2012
Profª Ms. Engª Elaine Cecília Gatto
Unidade 6: Estruturas, Uniões, Enumerações e Tipos
Definidos pelo Usuário
Curso de Bacharelado em Engenharia de Computação
Universidade do Sagrado Coração – USC
Bauru/SP
Estruturas: conceito/definição
• São coleções de variáveis relacionadas agrupadas sob um
único nome.
• Podem conter variáveis de muitos tipos de dados diferentes.
• São usadas para declarar registros a serem armazenados em
arquivo.
• Estruturas de dados mais complexas: listas, filas, pilhas e
árvores.
• Ponteiros e estruturas facilitam a formação dessas estruturas.
• Tipos de dados derivados (e não primitivos)
Declarações de Estruturas
• Declaração de uma estrutura:
struct card {
char * face;
char *suit;
};

• STRUCT é a palavra chave para estrutura;

• TAG DE ESTRUTURA: neste caso é a palavra CARD. A Tag de
Estrutura é usada para declarar variáveis desse tipo de
estrutura, é o identificador deste tipo de estrutura.
• As variáveis dentro da estrutura chamam-se MEMBROS.
• Não esquecer do ponto e vírgula ao final da declaração!
Declarações de Estruturas
• Obs.: dois tipos de estruturas diferentes podem ter membros
com o mesmo nome;
• Vetores e matrizes tem um único tipo. Exemplo um vetor de
reais ou uma matriz de inteiros.
• Estruturas podem ter vários tipos de dados diferentes.
Exemplo:

struct funcionario {
char nome[20];
char sobrenome[20];
int idade;
char sexo;
double salario;
};
Estrutura Autorreferenciada
• É uma estrutura que contém um membro que é um ponteiro
para o mesmo tipo de estrutura. São usadas para criar listas
interligadas. Exemplo:

struct funcionario2 {
char nome[20];
char sobrenome[20];
int idade;
char sexo;
double salario;
struct funcionario2 *ePtr; //estrutura autorreferenciada
}
Declarações de variáveis de
tipos de estrutura
• Declarações de estruturas não criam espaço na memória;
• Declarações de estruturas criam um novo tipo de dado;
• Esse novo tipo de dado é usado para declarar variáveis que então
ocupam espaço na memória;
• Exemplo:

struct card aCard, deck[52], *carPtr;

OU
struct card {
char *face;
char *suit;
} aCard, deck[52], *carPtr;
• aCard: é uma variável do tipo struct card;
• deck: é um vetor com 52 posições do tipo struct card;
• carPtr: é um ponteiro para struct card;
Nomes para tags de estruturas
• O nome para a tag de estrutura é opcional;
• Entretanto, sempre forneça um nome, é uma prática
recomendada;
• Escolha um nome significativo para a tag de estrutura. Isto
ajuda a tornar o programa mais legível e melhor
documentado.
• Se uma declaração de estrutura não tiver um nome para a tag
de estrutura, as variáveis do tipo da estrutura só poderão ser
declaradas na declaração da estrutura, e não em uma
declaração separada.
Operações que podem ser
realizadas nas estruturas
• Operações válidas:
• Atribuição de variáveis da estrutura a variáveis da estrutura de
mesmo tipo;
• Coleta de endereço de uma variável de estrutura (operador
&);
• Acesso aos membros de uma variável de estrutura;
• Uso do operador sizeof para determinar o tamanho de uma
variável de estrutura.

• NÃO PODEMOS:
• Comparar estruturas usando == e !=
Inicialização de estruturas
• Parecido com vetores e matrizes. Exemplo:

struct card aCard = {“Três”, “Copas”};

• Inicializa o membro da estrutura FACE com o valor TRÊS e o

membro SUIT com o valor COPAS.
• Atenção: se o número de inicializadores na lista for menor que
os membros na estrutura, os membros restantes serão
automaticamente inicializados em zero, ou NULL se o membro
for um ponteiro.
Acesso a membros da
estrutura
• Dois operadores são usados para acessar os membro de uma
estrutura:
• Operador de membro de estrutura ou operador de ponto ( . )
– é um ponto de fato!
• Operador de ponteiro de estrutura ou operador de seta (  )
– é uma seta de fato!

• Exemplo 1: printf(“%s”, aCard.suit);

• Exemplo 2: printf(“%s”, cardPtr->suit);

• Ambos imprimem na tela o conteúdo de SUIT;

Acesso a membros da
estrutura
/* Usando operadores de membro da estrutura e deponteiro da
estrutura */

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

/* Declaração da estrutura da carta */

struct card {
char *face; //ponteiro
char * suit; //ponteiro
}; //fim da estrutura
Acesso a membros da
estrutura
int main(void){
struct card aCard; //declaração de variável
struct card *cardPtr; //declaração de ponteiro
//coloca strings em aCard
aCard.face = “Ás”;
aCard.suit = “Espadas”;
//atribui o endereço de aCard a cardPtr
cardPtr = &aCard;
printf(“ %s%s%s \n %s%s%s \n %s%s%s \n ”,
aCard.face, “ de ”, aCard.suit,
cardPtr->face, “ de ”, cardPtr->suit,
(*cardPtr).face, “ de ”, (*cardPtr).suit);
return 0; //conclusão bem sucedida
}
Uso de estruturas com funções
• As estruturas podem ser passadas a funções ao:
• Passar membros da estrutura individuais;
• Passar uma estrutura inteira;
• Passar um ponteiro para uma estrutura;

• Quando as estruturas ou membros individuais da estrutura

são passados a uma função, eles são passados por valor;
• Os membros das estruturas passados por valor não podem
ser modificados pela função utilizada;

• Para passar uma estrutura por referência:

• Passe o endereço da variável da estrutura;
Uso de estruturas com funções
• Um array pode ser passado por valor usando uma estrutura;
• Para isto faça:
• Crie uma estrutura que tenha o array como membro;
• Estruturas são passadas por valor, de modo que o array
também é passado por valor;

• ERRO LÓGICO: supor que estruturas como arrays sejam

passadas automaticamente por referência e tentar modificar
os valores da estrutura passadas por valor na função utilizada;
• DICA: passar estruturas por referência é mais eficiente do que
passar estruturas por valor;
TYPEDEF
• TYPEDEF: oferece um mecanismo de criação de sinônimos
para tipos de dados previamente definidos;
• Usado para definir um tipo da estrutura, de modo que a tag da
estrutura não é necessária;
• Exemplo 1: typedef struct card Card;
• Exemplo 2:

typedef struct {
char *face;
char *suit;
} Card;
TYPEDEF
• A declaração anterior cria o tipo de estrutura Card sem a
necessidade de uma instrução typedef separada. Agora Card
pode ser usado para declarar variáveis do tipo struct card.

Card deck[52];

• Criar um novo nome com TYPEDEF não cria um novo tipo;

• Typedef simplesmente cria um novo nome de tipo, que pode
ser usado como um alias par aum nome de tipo existente;
• Use TYPEDEF para ajudar a tornar o seu programa mais
portável;
• Também pode ser usado para criar alias para os tipos de
dados básicos.
Exemplo 1
/* Cria uma estrutura para armazenar dados de um aluno */
#include <stdio.h>
#include <stdlib.h>

struct aluno {
int nmat; //número da matrícula
float nota[3]; //notas
float media; //média
};
Exemplo 1
int main () {
struct Aluno Jose; //declara uma variável do tipo struct
Jose.nmat = 456;
Jose.nota[0] = 7.5;
Jose.nota[1] = 5.2;
Jose.nota[2] = 8.4;
Jose.media = (Jose.nota[0] + Jose.nota[1] + Jose.nota[2])
/ 3.0;
printf(“Matrícula: %d \n ”, Jose.nmat);
printf(“Média: %2f \n ”, Jose.media);
system(“Pause”);
return 0;
}
Exemplo 2
/* estruturas aninhadas */
#include <stdio.h>
#include <stdlib.h>

typedef struct {
int dia;
char mes[10];
int ano;
} Data;

typedef struct {
int pecas;
float preço
Data diavenda;
} Venda;
Exemplo 2
int main () {
static Venda A = {20, 110.0, {7, “novembro”, 2001}};
printf(“Peças: %d \n”, A.pecas);
printf(“Preço: %d \n”, A.preco);
printf(“Data: %d de %s de %d
\n”, A.diavenda.dia, A.diavenda.mes, A.diavenda.ano);
system(“PAUSE”);
return 0;
}
Exemplo 3
/* Mostra a passagem de estruturas para funções por valor.
Mostra uma função que retorna uma estrutura */

#include <stdio.h>
#include <stdlib.h>

typedef struct Venda {

int pecas;
float preco;
} Venda;

Venda TotalVendas(Venda C, Venda D); //protótipo

Exemplo 3
int main () {
Venda A, B, Total;
printf(“ Venda A \n ========== \n”);
printf(“ Insira o número de peças”);
scanf(“%d”, &A.pecas);
printf(“ Insira o preço”);
scanf(“%d”, &A.preco);

printf(“ Venda B \n ========== \n”);

printf(“ Insira o número de peças”);
scanf(“%d”, &B.pecas);
printf(“ Insira o preço”);
scanf(“%d”, &B.preco);
Exemplo 3
//estruturas como argumento e retorno
Total = TotalVendas(A, B);
printf(“ \n \n Venda Total \n ===========”);
printf(“ \n Total de Peças %d.”, Total.pecas);
printf(“ \n Preço Total: %.2f \n”, Total.preco);
system(“PAUSE”);
return 0;
}
Venda TotalVendas(Venda C, Venda D) {
Venda T;
T.Pecas = C.pecas + D.pecas;
T.Preco = C.preco + D.preco;
Return T;
}
Exercícios
1. Forneça a definição para uma estrutura ESTOQUE que
contém um array de caracteres nomePeca[30], o inteiro
numPeca, o preço em ponto flutuante, o inteiro quantidade
e o inteiro pedido.
2. Forneça a definição para uma estrutura chamada
endereço, que contém os arrays de caracteres
rua[25], cidade[20], estado[2] e cep[8].
3. Forneça a definição para uma estrutura aluno que contém
os arrays nome[15] e sobrenome[15] e a variável endResid
do tipo struct endereço do exercício 2.