Estrutura de Dados Revisão Professor Luiz José Hoffmann Filho ljhfilho@gmail.com

Revisão : Struct/Registros

Struct/Registros Armazenar um conjunto heterogêneo de informação; Exemplo: 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). Como armazenar isto?

Struct/Registros Em uma Struct/Registro!!! É um conjunto composto de variáveis heterogênea sob um nome; É definido pelo usuário; 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: struct addr agenda[50]; Referênciando elementos da estrutura: strcpy(agenda[3].nome, “jose Silva”); gets(agenda[3].endereco); scanf(“%d”, &agenda[3].cep); 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], 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); } printf("Nome %s e fone %s\n", agenda[i].nome, agenda[i].fone); } return 0;

Revisão : Ponteiros

Ponteiros O que são ponteiros? 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 JOSE 1004 1005

Ponteiros Declaração: <tipo> *<nome da variável>; Exemplo: int *valor; char *nome;

Ponteiros Os operadores de Ponteiros: & - é um operador unário que devolve o endereço na memória do seu operando. Exemplo: m = &count; * - é o complemento de &. É um operador unário que devolve o valor da variável localizada no endereço que o segue. 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: Comparação de ponteiros: 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: If (p<q) printf(“p aponta para uma memória mais baixa que q”); If (p == q) printf(“p aponta para a memória mesma que q”);

Ponteiros Ponteiros e Matrizes: char str[80], *p1; p1 = str; p1 foi inicializado com o endereço de primeiro elemento da matriz str. Para acessar o quinto elemento de str: str[4]; *(p1+4); Vetor/Matriz de Ponteiros: int *x[10]; x[2] = &var; Atribuir o endereço a variável var a uma posição do vetor *x[2]; Valor de var.

Ponteiros Indireção mútipla: Inicialização de ponteiros: int main() { int x, *p, **q; x = 10; p = &x; q = &p; printf(“%d”, **q); return 0; } Inicialização de ponteiros: int *p = NULL; char *p = “alo mundo”;

Ponteiros Alocação dinâmica: stdlib.h Malloc = aloca memória int *p; If (!(p=malloc(50*sizeof(int)) { Printf(“sem memória.\n”); Return 0; } 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); }

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: 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. 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; 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() Comando return 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 Retornando de uma funçã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 *valor) { *valor = *valor * *valor;

Bibliografia Schildt, Herbet. C Completo e Total, 3ª ed. São Paulo. Markron Books, 1996.