Estrutura de
Dados
Revisão
Professor Luiz José Hoffmann Filho
[email protected]
Revisão :
Struct/Registros
Struct/Registros
• Armazenar um conjunto heterogêneo de
informação;
• Exemplo:
o Informações de uma passagem de avião,
onde temos: número da passagem
(inteiro), nome do passagem (char),
destino e origem (char), data (char),
horário (char), poltrona (char), valor
(float).
o Como armazenar isto?
Struct/Registros
• Em uma Struct/Registro!!!
o É um conjunto composto de variáveis
heterogênea sob um nome;
o É definido pelo usuário;
o Pois estas informações são subdivisões de
um registro (elementos do conjunto),
chamados de campos;
Struct/Registros
struct <nome_estrutura> {
<tipo_1> <nome_1>;
<tipo_2> <nome_2>;
...
<tipo_n> <nome_n>;
} <nome da variável>;
Declaração:
struct <nome strutura> <nome da variável>
Struct/Registros
• Exemplos 1:
struct addr {
char nome[30];
char endereco[40];
char cidade[20];
char estado[3];
int cep;
};
struct addr endereco_info;
Struct/Registros
• Exemplos 1:
struct addr {
char nome[30];
char endereco[40];
char cidade[20];
char estado[3];
int cep;
} endereco_info;
Struct/Registros
• Usando um vetor de struct:
o struct addr agenda[50];
• Referênciando elementos da estrutura:
o strcpy(agenda[3].nome, “jose Silva”);
o gets(agenda[3].endereco);
o scanf(“%d”, &agenda[3].cep);
o Agenda[3].cep = 81010140
Struct/Registros
struct tipo_agenda {
char nome[50];
char fone[20]; };
int main(int argc, char** argv) {
struct tipo_agenda agenda;
printf("Digite o nome : \n");
scanf("%s",&agenda.nome);
printf("Digite o fone : \n");
scanf("%s", &agenda.fone);
printf("Nome %s e fone %s\n", agenda.nome, agenda.fone);
return 0;
}
Struct/Registros
struct tipo_agenda {
char nome[50];
char fone[20];
};
int main(int argc, char** argv) {
int i;
struct tipo_agenda agenda[5];
for(i=0;i<5;i++) {
printf("Digite o nome : \n");
scanf("%s",&agenda[i].nome);
printf("Digite o fone : \n");
scanf("%s", &agenda[i].fone);
}
for(i=0;i<5;i++) {
printf("Nome %s e fone %s\n", agenda[i].nome, agenda[i].fone);
}
return 0;
}
Revisão :
Ponteiros
Ponteiros
• O que são ponteiros?
o Um ponteiro é uma variável que contém um
endereço de memória. Esse endereço é
normalmente a posição de uma outra variável
na memória. Se uma variável contém o
endereço de uma outra, então a primeira
variável é dita para apontar para a segunda.
Ponteiros
Endereço
na memória
Variável na
memória
1000
1003
1001
1002
1003
1004
1005
JOSE
Ponteiros
• Declaração:
o <tipo> *<nome da variável>;
• Exemplo:
o int *valor;
o char *nome;
Ponteiros
• Os operadores de Ponteiros:
o & - é um operador unário que devolve o endereço na memória do seu
operando.
o Exemplo:
• m = &count;
o * - é o complemento de &. É um operador unário que devolve o valor da
variável localizada no endereço que o segue.
o Exemplo:
• q = *m;
•
Ponteiros
Atribuição de ponteiros:
#include <stdio.h>
int main() {
int x;
int *p1, *p2;
x = 1000;
p1 = &x;
p2 = p1;
printf("%p \n", p2); /*escreve o endereço de x, não seu
valor*/
printf("%d \n", *p2); /* escreve o valor de x */
return 0;
}
Ponteiros
• Aritmética de ponteiros:
o
o
o
o
o
int *p1;
p1 = &x; /* supondo que a posição de x é igual a 2000 */
p1++; /* incrementando em uma posição, agora vale 2001*/
p1--; /* decrementando em uma posição, agora vale 2000*/
P1 = p1 +10; /* Soma de posições, agora vale 2010*/
• Comparação de ponteiros:
o If (p<q)
o
printf(“p aponta para uma memória mais baixa que q”);
o If (p == q)
o
printf(“p aponta para a memória mesma que q”);
Ponteiros
•
Ponteiros e Matrizes:
char str[80], *p1;
p1 = str;
o p1 foi inicializado com o endereço de primeiro elemento da matriz str.
o Para acessar o quinto elemento de str:
str[4];
*(p1+4);
•
Vetor/Matriz de Ponteiros:
int *x[10];
x[2] = &var;
o Atribuir o endereço a variável var a uma posição do vetor
*x[2];
o Valor de var.
Ponteiros
• Indireção mútipla:
int main() {
int x, *p, **q;
x = 10;
p = &x;
q = &p;
printf(“%d”, **q);
return 0;
}
• Inicialização de ponteiros:
o int *p = NULL;
o char *p = “alo mundo”;
Ponteiros
• Alocação dinâmica: stdlib.h
o Malloc = aloca memória
int *p;
If (!(p=malloc(50*sizeof(int)) {
Printf(“sem memória.\n”);
Return 0;
}
o Free = desaloca memória
free(p);
Ponteiros
int main() {
char *s;
int t;
s = malloc(80);
if (!s)
return 0;
gets(s);
for ( t = strlen(s) - 1; t >= 0; t--)
putchar(s[t]);
free(s);
return 0;
}
Revisão :
Funções
Funções
• Funções são blocos de construção e o local onde
toda a atividade do programa ocorre.
<tipo> <nome da função> (<lista de parâmetros>)
{
< Corpo da função>
}
(<lista de parâmetros>) =
(<tipo1> <nome do parâmetro 1>, <tipo2> <nome do
parâmetro 2>, …, <tipo n> <nome do parâmetro n>)
Funções
• Argumentos de funções:
o Elas se comportam como quaisquer outras variáveis locais dentro da
função e são criadas na entrada e destruídas na saída.
o Chamada por valor : Esse método copia o valor de um argumento no
parâmetro formal da sub-rotina. Assim as alterações feitas nos
parâmetros da sub-rotina não têm nenhum efeito nas variáveis usadas
para chamá-la;
o Chamada por referência: Nesse métodos, o endereço de um argumento
é copiado no parâmetro. Dentro da sub-rotina, o endereço é usado para
acessar o argumento real utilizado na chamada. Isso significa que
alterações feitas no parâmetro afetam a variável usada para chamar a
rotina.
Funções
• Exemplo Chamada por valor:
#include <stdio.h>
int sqr(int x);
int main() {
int t = 10;
printf(“%d %d”, sqr(t), t);
}
int sqr(int x) {
x = x * x;
return x;
}
Funções
• Exemplo Chamada por referência:
#include <stdio.h>
void swap(int *x, int *y) {
int temp;
temp = *x;
*x = *y;
*y = temp; }
int main(){
int I, j;
I = 10; j = 20;
swap(&I, &j);
return 0;
}
Funções
• Argc e argc – Argumentos para main()
int main( int argc, char *argv){
if( argc != 2) {
printf(“Você esqueceu de digitar seu nome.\n”);
return 0;
}
printf(“Ola %s”, argv[1]);
return 1;
}
• Comando return
o Retornando de uma função
o Retornando Valores
Funções
• Protótipos de funções:
void sqrt_it(int *i);
int main() {
int x;
x = 10;
sqrt_it(x);
}
void sqrt_it(int *i) {
*i = *i * *I;
}
Bibliografia
• Schildt, Herbet. C Completo e Total, 3ª ed. São
Paulo. Markron Books, 1996.