Estruturas em C

Prévia do material em texto

Bruno Jurkovski
Fábio da Fontoura Beltrão
Felipe Augusto Chies
Kauê Soares da Silveira
Lucas Fialho Zawacki
Marcos Vinicius Cavinato
 Revisão da Aula 4
 Na última aula vimos... PONTEIROS...
 O que vocês lembram de ponteiros?
 Revisão da Aula 4
 Revisão da Aula 4
 Nas primeiras aulas vimos tipos de dado.
 Na linguagem C...
 int, float, char, ...
O usuário pode definir seus próprios tipos 
de dados, chamados de dados 
estruturados.
 struct, enum ...
 Veremos agora essa característica...
 Relembrando ...
 Estruturas
 Muitas vezes faz-se necessário o agrupamento 
de dados referentes a ‘algo’ em comum.
 Por exemplo, para armazenar informações 
referentes a um corpo precisaremos de sua 
massa, volume, posição, ...
 Para isso armazenamos todos esses dados 
numa estrutura (struct).
 Uma struct agrupa um conjunto de dados 
possivelmente diferentes, formando um novo 
tipo de dado.
 Estruturas - Criação
 Para criar uma estrutura usamos o comando 
struct:
struct nome_da_estrutura
{
 tipo1 nome1;
 tipo2 nome2;
 .
 .
 .
 tipon nomen;
} variáveis_da_estrutura;
 Exemplo para nossa estrutura ‘corpo’:
struct corpo
{
 float massa;
 float volume;
 struct ponto posicao;
} corpo1, corpo2;
 Estruturas - Criação
 Ponto?! O que é isso?! Existe um tipo de dado 
ponto?
 Não, ‘ponto’ não é um tipo primitivo, mas o que 
nos impede de criarmos o nosso ‘ponto’?
 Aí está, nota-se que nada nos impede
de não inicializar variáveis direto na cria-
ção da estrutura. Afinal, estamos declarando-as
automaticamente quando inicializamos um ‘corpo’.
struct 
ponto
{ 
float x;
 
float y;
};
 Estruturas - Criação
 Estruturas - Inicialização
 Para inicializar uma struct...
 
struct ponto p1 = { 2, 3 };
struct corpo c1 = { 10, 7, p1 };
 Estruturas - Acesso aos Campos
 Para acessar os campos de uma struct usamos 
o operador . , da seguinte forma:
 
p1.x acessa o campo ‘x’ da struct p1.
p1.y acessa o campo ‘y’ da struct p1.
struct ponto p1 = { 2, 3 };
struct 
ponto
{ 
float x;
 
float y;
};
 Estruturas - Atribuição
 O seguinte trecho de código é válido
struct ponto p1, p2 ;
p1.x = 2;
p1.y = 3;
p2 = p1;
printf(“%f”, p2.x);
struct ponto p1, p2 ;
p1.x = 2;
p1.y = 3;
p2 = p1;
printf(“%f”, p2.x);
 Estruturas - Atribuição
struct ponto p1, p2 ;
p1.x = 2;
p1.y = 3;
p2 = p1;
printf(“%.2f”, p2.x);
 Estruturas - Atribuição
 Estruturas - Comparação
 Não é possível comparar duas estruturas, 
somente seus campos separadamente!
 Erro de Compilação!
struct ponto p1 = {1 , 2};
struct ponto p2 = {3.14, 2.71};
if ( p1 == p2)
 printf(“Sao iguais”);
else
 printf(“Nao sao iguais”);
 Estruturas - Comparação
struct ponto p1 = {1 , 2};
struct ponto p2 = {3.14, 2.71};
if ( p1 == p2)
 printf(“Sao iguais”);
else
 printf(“Nao sao iguais”);
 Mas podemos comparar seus campos:
 Isso é possível!
struct ponto p1 = {1 , 2};
struct ponto p2 = {3.14, 2.71};
if ( p1.x == p2.x)
 printf(“Sao iguais no x”);
else
 printf(“Nao sao iguais no x”);
 Estruturas - Comparação
struct ponto p1 = {1 , 2};
struct ponto p2 = {3.14, 2.71};
if ( p1.x == p2.x)
 printf(“Sao iguais no x”);
else
 printf(“Nao sao iguais no x”);
 Estruturas - Comparação
 Estruturas & Funções 
 Podemos passar estruturas como 
parâmetros para funções e também 
retorná-los.
struct ponto criaPonto (float x, float y)
{
 struct ponto p1;
 
 p1.x = x;
 p1.y = y;
 return p1;
} 
 Outro exemplo:
int comparaPontos (struct ponto p1, stuct ponto p2)
{
 if ( (p1.x == p2.x) && (p1.y == p2.y) )
 return 1;
 else
 return 0;
} 
 Estruturas & Funções 
 Podemos também passar ponteiros para 
estruturas como parâmetros para funções 
(passagem de parâmetros por referência).
 E para acessar os campos da estrutura, usamos 
o operador -> , dessa forma:
int comparaPontos (struct ponto *p1, stuct *ponto p2)
{
 if ( (p1->x == p2->x) && (p1->y == p2->y) )
 return 1;
 else
 return 0;
} 
 Estruturas & Funções 
Estruturas Auto-referenciáveis
 Estruturas não podem possuir um campo que 
seja uma estrutura do próprio tipo, senão ela 
estaria definida como um laço infinito, como no 
exemplo:
struct exemplo
{
 char info;
 struct exemplo ex1;
};
 Podemos, porém, definir uma estrutura em que 
um dos campos seja um ponteiro para uma 
estrutura de mesmo tipo, e é então que criamos 
listas encadeadas, árvores binárias, etc ...
struct lista
{
 float x;
 struct lista *prox;
};
Estruturas Auto-referenciáveis
 Arrays e Estruturas 
 Pode-se criar arrays de estruturas como com 
qualquer outro tipo de dado:
struct ponto
{
 float x;
 float y;
};
struct ponto[10];
 Comando Typedef
 O comando typedef cria aliases (“apelidos”) dos 
tipos de dados já existentes.
 Ele NÃO cria um novo tipo de dado
typedef int intero;
intero i; // declara um int
struct ponto
{
 float x;
 float y;
};
struct ponto p1, p2;
struct ponto criaPonto (int x, int y);
typedef struct ponto
{
 float x;
 float y;
}point;
point p1, p2;
point criaPonto (int x, int y);
 Comando Typedef
1. Crie uma estrutura do tipo registro, que contém 
uma string nome, um int idade e um float salário 
e faça uma função para preencher e uma para 
imprimir estes dados.
 Exercício
 Enumerações
 Uma enumeração é um conjunto de constantes 
do tipo inteiro que especifica todos os valores 
legais que uma variável desse tipo pode ser.
 Exemplo: uma enumeração com as estações do 
ano:
Verao, Inverno, Primavera, Outono
 Forma de definir uma enumeração:
 Identificador e lista_de_variáveis são opcionais.
enum identificador { lista de enumeração } 
lista_de_variáveis;
 Exemplo:
enum estacoes { Verao, Inverno, 
Primavera, Outono };
estacoes e1, e2;
e1 = Verao;
e2 = Inverno;
if (e1 == e2)
 printf(“As estacoes sao iguais”);
 Enumerações
 É importante notar que enumerações apenas 
informam ao compilador símbolos que 
determinados tipos de variáveis podem conter.
 Esses símbolos na verdade são representados 
como valores inteiros.
 Assim sendo, esses símbolos podem ser usados 
em qualquer lugar que um valor inteiro pode ser 
usado.
 Enumerações
enum lampada { Desligada, Ligada };
 A cada símbolo é dado um valor inteiro maior 
em uma unidade do valor precedente.
 O valor do primeiro símbolo, por default, é 0.
 Exemplo:
Desligada é o mesmo que o valor 0 e Ligada é o
mesmo que o valor 1.
 Enumerações
 Exemplo:
 Cada símbolo possuirá os seguintes valores 
correspondentes:
enum estacoes { Verao, Inverno = 2, Primavera, Outono };
Símbolo Valor
Verao 0
Inverno 2
Primavera 3
Outono 4
 Enumerações
 Lembre-se: os símbolos das enumerações 
são só nomes para inteiros.
O seguinte código está errado!
e1 não é um string, e sim um inteiro!
e1 = Verao;
printf(“%s”, e1);
e1 = Verao;
printf(“%d”, e1);
 Enumerações
2. Crie uma enumeração contendo os dia da 
semana e faça um função que receba um inteiro 
e diga que dia da semana foi recebido. 
Ex: Dia da semana: 3
 Terça-feira
 Exercício
 C não possui nenhum comando básico de E/S;
 Essas operações são realizadas através de 
bibliotecas especializadas:
 <stdio.h>, <stdlib.h>, <conio.h>;
 stdio.h é a biblioteca padrão de E/S em C;
 Há dois tipos de E/S: por console e por arquivo;
Entrada e Saída em C ( E/S )
 E/S por ConsoleE/S por Console
 Manipulação de Caracteres
getchar();
getch();
getche();
putchar();
 Manipulação de Strings
gets();
puts();
 E/S Formatada
printf();scanf();
 Outras Funções de Manipulação
 putchar(char c);
 Imprime um caracter na tela.
 Exemplo:
 
char ch = ‘f’;
putchar(ch);
 Manipulação de Caracteres
 Manipulação de Caracteres
 ch = getchar();
getchar() retorna o valor do caractere digitado;
É necessário o ENTER;
O caractere retornado é o primeiro a ser digitado;
Biblioteca: <stdio.h>
 Exemplo:
char ch = getchar();
putchar(ch);
 ch = getche():
 retorna o caractere digitado;
NÃO é necessário o ENTER;
Biblioteca: <conio.h>
 ch = getch():
 retorna o carcartere digitado;
NÃO é necessário o ENTER;
NÃO produz eco = não mostra na tela a tecla 
digitada;
Biblioteca: <conio.h>
 Manipulação de Caracteres
 Manipulação de Strings
 gets(<string>):
Lê e armazena em <string> uma string digitada;
NÃO encorajamos o uso dessa função !
 puts(<string>):
 Imprime <string> na tela.
 Ambas funções pertencem à <stdio.h>
 gets(<string>):
Lê uma string digitada;
 Manipulação de Strings
 Manipulação de Strings
 E/S Formatada – printf();
 printf(): Imprime na tela informações de 
qualquer tipo.
 printf(“INFO”, parâmetros);
 As variáveis e constantes impressas 
necessitam de uma especificação:
Tipo Código
Inteiro %i, %d
Float, Double %f, %lf
Char %c
String %s
Imprimir % %%
 Entrada e Saída
 Caracteres de barra invertida
Código Significado
\a Beep
\t Tabulação Horizontal
\n Quebra de Linha
\b Backspace
\v Tabulação Vertical
\\ Barra Invertida
\? Ponto de Interrogação
\’ Aspas Simples
\” Aspas Duplas
\N Constante em Octal
\xN Constante em Hexadecimal
 E/S Formatada – scanf()
 scanf () – função que lê dados entrados pelo 
usuário:
 scanf(“tipos de dados”, &variaveis);
Onde os tipos são os mesmos da função 
printf(int, float..) e as ‘variaveis’ são aonde 
serão armazenados os valores lidos.
 E/S – scanf()
 Nota sobre scanf():
Scanf recebe um ponteiro para as variáveis, 
logo o nome da variável deve ser precedido 
por um ‘&’.
Strings não necessitam, nem podem, receber 
esse caractere, uma vez que o nome de uma 
string é um ponteiro para o primeiro elemento 
da string.
3. Faça um programa que receba caracteres ate 
que um “0” seja pressionado, armazene-os em 
uma string e imprima-a na tela. Faça uma 
versão com getch(); e uma com getche();
 + Exercícios
4. Faça um programa que leia caracteres até ser 
digitado “0” e imprima somente as letras 
minúsculas (dica: use a função islower da 
ctype.h).
 Cabeçalho da função:
 int islower(char c);
 retorna 0 se não for minúsculo e diferente 
de 0 se for.
 + Exercícios