Baixe o app para aproveitar ainda mais
Prévia do material em texto
Universidade Federal da Grande Dourados Faculdade de Ciências Exatas e de Tecnologias Curso de Bacharelado em Sistemas de Informação Algoritmos e programação Modularidade (parte 2) Profª Janne Oeiras Lachi 1 Plano de aula ` Programação estruturada de computador ou Programação modular ` Subprogramas: procedimentos e funções ` Variáveis globais e locais ` Passagem de parâmetro: por valor e por referência ` Argumentos x Parâmetros Escopo de variáveis ` O escopo de uma variável, ou sua abrangência operacional, está vinculado à forma de sua visibilidade no algoritmo em relação aos subprogramas que o compõem. ` Variáveis Locais: quando são declaradas dentro de um subprograma e, portanto, são válidas somente dentro dele. O algoritmo principal e outros subprogramas não conseguem “enxergá-la” ou saber da sua existência. ` Variáveis Globais: quando são declaradas no início de um algoritmo antes de um conjunto de subprogramas. Têm o escopo visível por todos os subprogramas subordinados à rotina chamadora. Exemplo programa TROCA_2 var A, B : inteiro procedimento TROCA_VARS var X: inteiro início X Å A A Å B B Å X fim início leia A, B TROCA_VARS escreva A, B fim Variáveis globais Variável local O espaço de memória alocado para A e B ficam ocupados enquanto o algoritmo é executado. Já o espaço de memória para a variável X é alocado quando a sub- rotina é chamada e desalocado quando a sub-rotina acaba. #include <stdio.h> #include <stdlib.h> int A, B; void troca_vars (void); /*protótipo*/ int main() { scanf("%d%d", &A, &B); scanf("%d", &B); troca_vars(); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(void) { int X; X = A; A = B; B = X; } Exemplo programa TROCA_2 var A, B : inteiro procedimento TROCA_VARS var X: inteiro início X Å A A Å B B Å X fim início leia A, B TROCA_VARS escreva A, B fim #include <stdio.h> #include <stdlib.h> int A, B; void troca_vars (void); /*protótipo*/ int main() { scanf("%d%d", &A, &B); scanf("%d", &B); troca_vars(void); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(void) { int X; X = A; A = B; B = X; } Errado, não precisa usar o void como parâmetro na chamada da função CORRETO ERRADO #include <stdio.h> #include <stdlib.h> int A, B; void troca_vars (void); /*protótipo*/ int main() { scanf("%d%d", &A, &B); scanf("%d", &B); troca_vars(); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(void) { int X; X = A; A = B; B = X; } #include <stdio.h> #include <stdlib.h> int A, B; void troca_vars (void); /*protótipo*/ int main() { scanf("%d%d", &A, &B); scanf("%d", &B); void troca_vars(); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(void) { int X; X = A; A = B; B = X; } Errado, não precisa do tipo void na chamada #include <stdio.h> #include <stdlib.h> int A, B; void troca_vars (void); /*protótipo*/ int main() { scanf("%d%d", &A, &B); scanf("%d", &B); troca_vars(); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(void) { int X; X = A; A = B; B = X; } CORRETO ERRADO Escopo de variáveis ` O escopo de uma variável, ou sua abrangência operacional, está vinculado à forma de sua visibilidade no algoritmo em relação aos subprogramas que o compõem. ` Variáveis Locais: quando são declaradas dentro de um subprograma e, portanto, são válidas somente dentro dele. O algoritmo principal e outros subprogramas não conseguem “enxergá-la” ou saber da sua existência. ` Variáveis Globais: quando são declaradas no início de um algoritmo antes de um conjunto de subprogramas. Têm o escopo visível por todos os subprogramas subordinados à rotina chamadora. Exemplo variáveis locais programa TROCA_3 procedimento TROCA_VARS var X: inteiro início X Å A A Å B B Å X fim var A, B : inteiro início leia A, B TROCA_VARS escreva A, B fim Observe a posição da declaração das variáveis A, B. Como foram declaradas abaixo do procedimento, são locais e NÃO acessíveis por TROCA_VARS. #include <stdio.h> #include <stdlib.h> void troca_vars(void) { int X; X = A; A = B; B = X; } int A, B; int main() { scanf("%d%d", &A, &B); troca_vars(); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } O primeiro problema está na tradução literal, sem usar PROTÓTIPO da função. Não dá erro, mas não se faz assim. Exemplo: erro programa TROCA_3 procedimento TROCA_VARS var X: inteiro início X Å A A Å B B Å X fim var A, B : inteiro início leia A, B TROCA_VARS escreva A, B fim #include <stdio.h> #include <stdlib.h> void troca_vars(void); int A, B; int main() { scanf("%d%d", &A,&B); troca_vars(); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(void) { int X; X = A; A = B; B = X; } Exemplo: erro programa TROCA_3 procedimento TROCA_VARS var X: inteiro início X Å A A Å B B Å X fim var A, B : inteiro início leia A, B TROCA_VARS escreva A, B fim Lembre de usar protótipo! #include <stdio.h> #include <stdlib.h> void troca_vars(void); int A, B; int main() { scanf("%d%d", &A,&B); troca_vars(); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(void) { int X; X = A; A = B; B = X; } Exemplo: erro programa TROCA_3 procedimento TROCA_VARS var X: inteiro início X Å A A Å B B Å X fim var A, B : inteiro início leia A, B TROCA_VARS escreva A, B fim Continua errado porque se A e B são locais ao algoritmo principal, na Linguagem C deveriam ser colocados dentro da função main() A, B são locais e NÃO acessíveis por TROCA_VARS #include <stdio.h> #include <stdlib.h> void troca_vars(void); int main() { int A, B; scanf("%d%d", &A,&B); troca_vars(); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(void) { int X; X = A; A = B; B = X; } ERRADO CERTO, mas ainda não resolve o problema porque as variáveis A e B não são vistas por troca_vars Aqui sim estão dentro da função main() e são locais #include <stdio.h> #include <stdlib.h> void troca_vars(void); int A, B; int main() { scanf("%d%d", &A,&B); troca_vars(); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(void) { int X; X = A; A = B; B = X; } Passagens de parâmetros ` É um processo que permite estabelecer uma linha de comunicação entre os conteúdos dos trechos de sub- rotinas e dos trechos de programa que chamam essas sub- rotinas, principalmente se usam variáveis com escopo local. ` Dois tipos: ` Passagem de parâmetro por valor ` Passagem de parâmetro por referência Exemplo de parâmetros ` Escreva um programa na Linguagem C que receba do usuário a temperatura em ºF e converta para ºC. Crie e use uma função que faça essa conversão. ` Vamos pensar na solução primeiramente sem usar função. Solução SEM função ` Escreva um programa na Linguagem C que receba do usuário a temperatura em ºF e converta para ºC. Crie e use uma função que faça essa conversão. /* Programa que converte graus Fahrenheit para Celsius */ #include <stdio.h> #include <stdlib.h> int main() { float c, f; printf(“Digite a temperatura em Fahrenheit: ”); scanf(“%f”, &f); c = (f – 32.0) * 5.0/9.0; printf(“Celsius = %.2f\n”, c); system(“PAUSE”); return 0; } Solução incluindo função ` Escreva um programa na Linguagem C que receba do usuário a temperaturaem ºF e converta para ºC. Crie e use uma função que faça essa conversão. /* Programa que converte graus Fahrenheit para Celsius */ #include <stdio.h> #include <stdlib.h> int main() { float c, f; printf(“Digite a temperatura em Fahrenheit: ”); scanf(“%f”, &f); c = (f – 32.0) * 5.0/9.0; printf(“Celsius = %.2f\n”, c); system(“PAUSE”); return 0; } Pense no que a função precisa realizar (conversão) e coloque esse trecho de código nela Criando um corpo para a função ` Escreva um programa na Linguagem C que receba do usuário a temperatura em ºF e converta para ºC. Crie e use uma função que faça essa conversão. /* Programa que converte graus Fahrenheit para Celsius */ #include <stdio.h> #include <stdlib.h> int main() { float c, f; printf(“Digite a temperatura em Fahrenheit: ”); scanf(“%f”, &f); c = ???; printf(“Celsius = %.2f\n”, c); system(“PAUSE”); return 0; } tipo??? celsius (parâmetros???) { (f – 32.0) * 5.0/9.0; return valor???; } A conta ficou no “limbo”... Crie uma variável para receber esse resultado Criando um corpo para a função ` Escreva um programa na Linguagem C que receba do usuário a temperatura em ºF e converta para ºC. Crie e use uma função que faça essa conversão. /* Programa que converte graus Fahrenheit para Celsius */ #include <stdio.h> #include <stdlib.h> int main() { float c, f; printf(“Digite a temperatura em Fahrenheit: ”); scanf(“%f”, &f); c = ???; printf(“Celsius = %.2f\n”, c); system(“PAUSE”); return 0; } tipo??? celsius (parâmetros???) { float temp; temp =(f – 32.0) * 5.0/9.0; return valor???; } Agora sim! Porém, note que precisamos do valor de f, que é local a main(). Vamos receber uma cópia de f via parâmetros Criando um corpo para a função ` Escreva um programa na Linguagem C que receba do usuário a temperatura em ºF e converta para ºC. Crie e use uma função que faça essa conversão. /* Programa que converte graus Fahrenheit para Celsius */ #include <stdio.h> #include <stdlib.h> int main() { float c, f; printf(“Digite a temperatura em Fahrenheit: ”); scanf(“%f”, &f); c = ???; printf(“Celsius = %.2f\n”, c); system(“PAUSE”); return 0; } tipo??? celsius (float fahr) { float temp; temp =(fahr – 32.0) * 5.0/9.0; return valor???; } Trocamos o nome de f para fahr para deixar mais claro que é uma cópia de f Criando um corpo para a função ` Escreva um programa na Linguagem C que receba do usuário a temperatura em ºF e converta para ºC. Crie e use uma função que faça essa conversão. /* Programa que converte graus Fahrenheit para Celsius */ #include <stdio.h> #include <stdlib.h> int main() { float c, f; printf(“Digite a temperatura em Fahrenheit: ”); scanf(“%f”, &f); c = ???; printf(“Celsius = %.2f\n”, c); system(“PAUSE”); return 0; } tipo??? celsius (float fahr) { float temp; temp =(fahr – 32.0) * 5.0/9.0; return temp; } Agora que temos a conta pronta, devemos mandar esse resultado de volta para a main() via comando return. Criando um corpo para a função ` Escreva um programa na Linguagem C que receba do usuário a temperatura em ºF e converta para ºC. Crie e use uma função que faça essa conversão. /* Programa que converte graus Fahrenheit para Celsius */ #include <stdio.h> #include <stdlib.h> int main() { float c, f; printf(“Digite a temperatura em Fahrenheit: ”); scanf(“%f”, &f); c = ???; printf(“Celsius = %.2f\n”, c); system(“PAUSE”); return 0; } tipo??? celsius (float fahr) { return ((fahr – 32.0) * 5.0/9.0); } Poderia ser assim também. Criando um corpo para a função ` Escreva um programa na Linguagem C que receba do usuário a temperatura em ºF e converta para ºC. Crie e use uma função que faça essa conversão. /* Programa que converte graus Fahrenheit para Celsius */ #include <stdio.h> #include <stdlib.h> int main() { float c, f; printf(“Digite a temperatura em Fahrenheit: ”); scanf(“%f”, &f); c = ???; printf(“Celsius = %.2f\n”, c); system(“PAUSE”); return 0; } float celsius (float fahr) { float temp; temp =(fahr – 32.0) * 5.0/9.0; return temp; } temp é do tipo float e é o nosso valor de retorno, então a nossa função celsius deve ser do tipo float também. Criando um corpo para a função ` Escreva um programa na Linguagem C que receba do usuário a temperatura em ºF e converta para ºC. Crie e use uma função que faça essa conversão. /* Programa que converte graus Fahrenheit para Celsius */ #include <stdio.h> #include <stdlib.h> float celsius (float); int main() { float c, f; printf(“Digite a temperatura em Fahrenheit: ”); scanf(“%f”, &f); c = celsius (f); printf(“Celsius = %.2f\n”, c); system(“PAUSE”); return 0; } float celsius (float fahr) { float temp; temp =(fahr – 32.0) * 5.0/9.0; return temp; } Acertando a chamada: note que chamamos a função usando o nome dado e passamos como parâmetro o conteúdo da variável f Criando um corpo para a função ` Escreva um programa na Linguagem C que receba do usuário a temperatura em ºF e converta para ºC. Crie e use uma função que faça essa conversão. /* Programa que converte graus Fahrenheit para Celsius */ #include <stdio.h> #include <stdlib.h> float celsius (float); int main() { float f; printf(“Digite a temperatura em Fahrenheit: ”); scanf(“%f”, &f); printf(“Celsius = %.2f\n”, celsius (f)); system(“PAUSE”); return 0; } float celsius (float fahr) { float temp; temp =(fahr – 32.0) * 5.0/9.0; return temp; } Poderia ser assim também, chamar a função celsius dentro do printf(). Parâmetros de uma função ` As variáveis que recebem as informações enviadas para uma função são chamadas parâmetros. ` A função deve declarar essas variáveis entre parênteses, no cabeçalho de sua definição ou antes das chaves que marcam o início do corpo da função. /* definição da função */ float celsius (float fahr) { float temp; temp = (fahr – 32.0) * 5.0/9.0; return temp; } /* definição da função */ float celsius (fahr) float fahr; { float temp; temp = (fahr – 32.0) * 5.0/9.0; return temp; } Passagem de parâmetro por valor ` Ocorre a cópia do conteúdo enviado para uma variável do mesmo tipo daquela que foi enviada, que existirá apenas no procedimento/função. ` Com isso, podem ser feitos processamentos, avaliações e atribuições sem que haja qualquer tipo de alteração na variável que se encontra no algoritmo chamador. Argumento x Parâmetro ` Argumentos: valores ou variáveis definidos na chamada da função. É por meio desses argumentos que passamos valores para os parâmetros definidos na declaração da função ` Parâmetros: constituem a lista das variáveis declaradas na função chamada que irão receber os valores passados pelos argumentos Passagem de parâmetro por valor: exemplo /* Programa que converte graus Fahrenheit para Celsius */ #include <stdio.h> #include <stdlib.h> float celsius (float); /* protótipo da função */ int main() { float c, f; printf(“Digite a temperatura em Fahrenheit: ”); scanf(“%f”, &f); c = celsius(f); /* chamada à função */ printf(“Celsius = %.2f\n”, c); system(“PAUSE”); return 0; } /* definição da função */ float celsius (float fahr) { float temp; temp = (fahr – 32.0) * 5.0/9.0; return temp; } parâmetro argumento Passagem de parâmetro por valor: exemplo /* Programa que converte graus Fahrenheit para Celsius */ #include <stdio.h> #include <stdlib.h> float celsius (float); /* protótipo da função */ int main() { float c, f; printf(“Digite a temperatura em Fahrenheit: ”); scanf(“%f”, &f); c = celsius(f); /* chamada à função */ printf(“Celsius = %.2f\n”, c); system(“PAUSE”); return 0; } /* definição da função */ float celsius (float fahr) { floattemp; temp = (fahr – 32.0) * 5.0/9.0; return temp; } Uma cópia do valor de f é passada para a variável fahr da função celsius Passagem de parâmetro por valor: exemplo /* Programa que converte graus Fahrenheit para Celsius */ #include <stdio.h> #include <stdlib.h> float celsius (float); /* protótipo da função */ int main() { float c, f; printf(“Digite a temperatura em Fahrenheit: ”); scanf(“%f”, &f); c = celsius(f); /* chamada à função */ printf(“Celsius = %.2f\n”, c); system(“PAUSE”); return 0; } /* definição da função */ float celsius (float fahr) { float temp; temp = (fahr – 32.0) * 5.0/9.0; return temp; } Memória c f Memória c f 95.0 Memória c f 95.0 fahr 95.0 temp 35.0temp Memória c f 95.0 fahr 95.0 35.0temp Memória c 35.0 f 95.0 fahr 95.0 35.0temp Memória c 35.0 f 95.0 fahr 95.0 Passagem de parâmetro por valor: exemplo 2 /* Programa que recebe um valor e retorna o seu valor absoluto */ #include <stdio.h> #include <stdlib.h> int abs(int); /* protótipo da função */ int main() { int x=10; printf(“%d %d %d\n”, abs(0), abs(-3), abs(x)); system(“PAUSE”); return 0; } /* definição da função */ int abs (int n) { return (n>0) ? n : -n; } Passagem de parâmetro por valor: exemplo 2 /* Programa que recebe uma valor e retorna o seu valor absoluto */ #include <stdio.h> #include <stdlib.h> int abs(int); /* protótipo da função */ int main() { int x=10; printf(“%d %d %d\n”, abs(0), abs(-3), abs(x)); system(“PAUSE”); return 0; } /* definição da função */ int abs (int n) { return (n>0) ? n : -n; } Memória x 10 Passagem de parâmetro por valor: exemplo 2 /* Programa que recebe uma valor e retorna o seu valor absoluto */ #include <stdio.h> #include <stdlib.h> int abs(int); /* protótipo da função */ int main() { int x=10; printf(“%d %d %d\n”, abs(0), abs(-3), abs(x)); system(“PAUSE”); return 0; } /* definição da função */ int abs (int n) { return (n>0) ? n : -n; } Memória x 10 n 0 Passagem de parâmetro por valor: exemplo 2 /* Programa que recebe uma valor e retorna o seu valor absoluto */ #include <stdio.h> #include <stdlib.h> int abs(int); /* protótipo da função */ int main() { int x=10; printf(“%d %d %d\n”, abs(0), abs(-3), abs(x)); system(“PAUSE”); return 0; } /* definição da função */ int abs (int n) { return (n>0) ? n : -n; } Memória x 10 n 0 Aqui vai imprimir o valor 0 Passagem de parâmetro por valor: exemplo 2 /* Programa que recebe uma valor e retorna o seu valor absoluto */ #include <stdio.h> #include <stdlib.h> int abs(int); /* protótipo da função */ int main() { int x=10; printf(“%d %d %d\n”, abs(0), abs(-3), abs(x)); system(“PAUSE”); return 0; } /* definição da função */ int abs (int n) { return (n>0) ? n : -n; } Memória x 10 n 0 n -3 Passagem de parâmetro por valor: exemplo 2 /* Programa que recebe uma valor e retorna o seu valor absoluto */ #include <stdio.h> #include <stdlib.h> int abs(int); /* protótipo da função */ int main() { int x=10; printf(“%d %d %d\n”, abs(0), abs(-3), abs(x)); system(“PAUSE”); return 0; } /* definição da função */ int abs (int n) { return (n>0) ? n : -n; } Aqui vai imprimir o valor 3 Memória x 10 n 0 n -3 Passagem de parâmetro por valor: exemplo 2 /* Programa que recebe uma valor e retorna o seu valor absoluto */ #include <stdio.h> #include <stdlib.h> int abs(int); /* protótipo da função */ int main() { int x=10; printf(“%d %d %d\n”, abs(0), abs(-3), abs(x)); system(“PAUSE”); return 0; } /* definição da função */ int abs (int n) { return (n>0) ? n : -n; } Memória x 10 n 0 n -3 Memória x 10 n 10 n -3 Passagem de parâmetro por valor: exemplo 2 /* Programa que recebe uma valor e retorna o seu valor absoluto */ #include <stdio.h> #include <stdlib.h> int abs(int); /* protótipo da função */ int main() { int x=10; printf(“%d %d %d\n”, abs(0), abs(-3), abs(x)); system(“PAUSE”); return 0; } /* definição da função */ int abs (int n) { return (n>0) ? n : -n; } Aqui vai imprimir o valor 10 Memória x 10 n 10 n -3 Passando vários argumentos ` Caso seja necessário passar vários argumentos, isto pode ser feito dentro do parênteses, separando-os por vírgula; ` Podem ser passados tantos argumentos quanto forem necessários para a execução da função; Exemplo 4 programa TROCA_4 procedimento TROCA_VARS (A, B: inteiro) var X: inteiro início X Å A A Å B B Å X escreva A, B fim var A, B : inteiro início leia A, B TROCA_VARS(A,B) fim #include <stdio.h> #include <stdlib.h> void troca_vars(int, int); int main() { int A, B; scanf("%d%d", &A,&B); troca_vars(A, B); system("PAUSE"); return 0; } void troca_vars(int a, int b) { int X; X = a; a = b; b = X; printf(“%d%d”, a, b); } Passagem de parâmetro por referência ` Não existe cópia do conteúdo. É enviada a referência de onde a variável da rotina chamadora se encontra. ` Com isso, qualquer alteração na variável na sub-rotina refletirá em alterações na variável da rotina chamadora. ` Na linguagem C precisaremos estudar o conceito de ponteiro Armazenamento de informações ` Quando uma variável é declarada em um programa, um espaço na memória do computador será alocado para ela de acordo com o seu tipo. ` Esse espaço tem um endereço que serve para armazenar e localizar o dado que queremos guardar. 1 byte Memória Tipos de dados definidos pelo padrão ANSI Tipo Bit* Bytes Faixa de Valores char 8 1 -128 a 127 unsigned char 8 1 0 a 255 int 32 4 -2.147.483.648 a 2.147.483.647 unsigned int 32 4 0 a 4.294.967.295 short int 16 2 -32.768 a 32.767 long 32 4 -2.147.483.648 a 2.147.483.647 unsigned long 32 4 0 a 4.294.967.295 float 32 4 3.4x10-38 a 3.4x1038 double 64 8 1.7x10-308 a 1.7x10308 long double 80 10 3.4x10-4932 a 1.1x104932 *O tamanho e a faixa de valores podem variar de acordo com o processador ou compilador. Armazenamento de informações: exemplo Instruções Dados na Memória t 1 t e s t e \0 char x = ‘t’; int y = 1; char z[6] = {“teste”}; Armazenamento de informações: exemplo char x; Espaço de memória para o conteúdo de x x é associado a um endereço x 2000 2001 2002 2003 2004 2005 Endereços de memória Armazenamento de informações: exemplo x=‘t’; Armazenamento de ‘t’ no espaço alocado para x tx 2000 2001 2002 2003 2004 2005 Ponteiro ` É um tipo de variável especial que armazena um endereço de uma outra variável que foi alocada na memória do computador ` Esse tipo de variável “aponta” para um endereço de memória determinado ` Como queremos usar parâmetros por referência, é necessário indicarmos qual o endereço da variável que estaremos usando para realizar alterações no seu conteúdo. Declarando uma variável ponteiro tipo *nome_ponteiro; ` Onde: ` tipo: é o tipo de dado que caracteriza a variável ` *nome_ponteiro: é o nome da variável que caracterizará o ponteiro ` Atenção: o asterisco na frente do nome é que caracteriza a variável como ponteiro ` * : é o operador de conteúdo ou de derreferenciação Variável ponteiro: exemplo int *idade; char *ponteiro; ` A variável idade é capaz de armazenar um endereço do tipo inteiro ` A variável ponteiro é capaz de armazenar um endereço do tipo caractere Operadores de manipulação de ponteiros ` A manipulação de ponteiros ocorre de duas maneiras: ` Por meio do endereço de uma variável ` Por meio do conteúdo de um endereço apontado pelo ponteiro ` São usados dois operadores: ` Endereço: & ` Conteúdo: * Operador de endereço(&) #include <stdio.h> int main() { char w = ‘t’; printf(“O conteúdo de w é %c”, w); printf(“O endereço de w é %x”, &w); } Busca o conteúdo de w Busca o endereço de w t 2000 2001 2002 Observação: note que conteúdo teria nesse caso o valor t e o endereço teria o valor 2000 Endereços em strings ` Quando for necessário obter o endereço de uma variável do tipo string, não é necessário usar o operador & ` As strings são matrizes para a linguagem C e nesse caso, o compilador passa o endereço do primeiro elemento da matriz (índice 0) #include <stdio.h> int main() { char nome[10] = {“alberto”}; printf(“O conteúdo de nome é %s”, nome); printf(“O endereço de nome é %x”, nome); } Inicializando um ponteiro ` Como atribuir um endereço de uma variável para um ponteiro? ` Basta usar o operador de endereço. ` Se for uma string, não precisa do operador & char x = ‘t’; char *ponteiro; ponteiro = &x; char nome[30]; char *ponteiro; ponteiro = nome; Obs.: sempre inicialize um ponteiro logo depois de sua declaração para não correr risco de esquecê-lo Verificando o conteúdo armazenado em um ponteiro ` Podemos usar as funções de impressão e leitura (printf, scanf) e o operador de conversão %p. ` Exemplo: char x = ‘t’; char *p; p = &x; printf(“O conteúdo de ponteiro é %p”, p); printf(“O endereço do ponteiro é %x”, &p); Verificando o conteúdo armazenado em um ponteiro char x = ‘t’; char *pointer; pointer = &x; printf(“O conteúdo do ponteiro é %p”, pointer); printf(“O endereço do ponteiro é %x”, &pointer); t 2000 2001 2002 x char x = ‘t’; char *pointer; pointer = &x; printf(“O conteúdo do ponteiro é %p”, pointer); printf(“O endereço do ponteiro é %x”, &pointer); t 2000 2001 2002 Espaço de memória para ponteiro pointer x Verificando o conteúdo armazenado em um ponteiro char x = ‘t’; char *pointer; pointer = &x; printf(“O conteúdo do ponteiro é %p”, pointer); printf(“O endereço do ponteiro é %x”, &pointer); t 2000 2000 2001 2002 Usando o operador de conteúdo (*) ` O operador * pode ser usado na declaração de ponteiros, ou para acessar o valor contido no endereço armazenado pelo ponteiro ` Exemplo: char x = ‘t’; char *pointer; pointer = &x; printf(“O conteúdo do ponteiro é %p”, pointer); /*2000*/ printf(“O conteúdo de x é %c”, x); /* t */ printf(“O endereço do ponteiro é %x”, &pointer); /*2002 */ printf(“O conteúdo apontado pelo ponteiro é %c”, *pointer); /* t */ t 2000x 2000 2001 2002 pointer Passagem de parâmetros por referência ` Os argumentos passam os endereços de memória para os parâmetros declarados na função (que devem ser ponteiros) ` Sintaxe: ` Cada parâmetro é um ponteiro tipo nome_função (tipo *parâmetro 1, ...,tipo *parâmetro n) { corpo da função; return (valor de retorno); } Exemplo programa TROCA_4 procedimento TROCA_VARS (A, B: inteiro) var X: inteiro início X Å A A Å B B Å X escreva A, B fim var A, B : inteiro início leia A, B TROCA_VARS(A,B) fim #include <stdio.h> #include <stdlib.h> void troca_vars(int, int); int main() { int A, B; scanf("%d%d", &A,&B); troca_vars(A, B); system("PAUSE"); return 0; } void troca_vars(int a, int b) { int X; X = a; a = b; b = X; printf(“%d%d”, a, b); } Aqui usamos passagem de parâmetro por VALOR, mas poderíamos ter usado POR REFERÊNCIA. Exemplo programa TROCA_4 procedimento TROCA_VARS (var A, var B: inteiro) var T: inteiro início T Å A A Å B B Å T fim var A, B : inteiro início leia A, B TROCA_VARS(A,B) escreva A, B fim Em Português estruturado um parâmetro passado por referência será identificado pelo uso da palavra var antes de seu nome Exemplo #include <stdio.h> #include <stdlib.h> void troca_vars(int *, int *); int main() { int A, B; scanf("%d%d", &A,&B); troca_vars(&A, &B); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(int *a, int *b) { int X; X = *a; *a = *b; *b = X; } Para usar passagem de parâmetros por referência, colocamos o * na frente do nome do parâmetro Exemplo #include <stdio.h> #include <stdlib.h> void troca_vars(int *, int *); int main() { int A, B; scanf("%d%d", &A,&B); troca_vars(&A, &B); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(int *a, int *b) { int X; X = *a; *a = *b; *b = X; } No protótipo da função, não escrevemos o nome do parâmetro, apenas colocamos o tipo, e neste caso, o * para indicar que usaremos um ponteiro. Exemplo Memória Endere ço Nome da variável Valor 100 110 120 130 140 A B #include <stdio.h> #include <stdlib.h> void troca_vars(int *, int *); int main() { int A, B; scanf("%d%d", &A,&B); troca_vars(&A, &B); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(int *a, int *b) { int X; X = *a; *a = *b; *b = X; } Cada variável possui um endereço de memória. Exemplo Memória Endere ço Nome da variável Valor 100 110 120 130 1 2 140 A B #include <stdio.h> #include <stdlib.h> void troca_vars(int *, int *); int main() { int A, B; scanf("%d%d", &A,&B); troca_vars(&A, &B); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(int *a, int *b) { int X; X = *a; *a = *b; *b = X; } Lemos o valor de A e B Exemplo #include <stdio.h> #include <stdlib.h> void troca_vars(int *, int *); int main() { int A, B; scanf("%d%d", &A,&B); troca_vars(&A, &B); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(int *a, int *b) { int X; X = *a; *a = *b; *b = X; } Memória Endere ço Nome da variável Valor 100 110 120 130 1 2 100 110 140 a b A B Chamamos a função e passamos como parâmetros o endereço de A e de B porque na definição da função são esperados endereços. Exemplo #include <stdio.h> #include <stdlib.h> void troca_vars(int *, int *); int main() { int A, B; scanf("%d%d", &A,&B); troca_vars(&A, &B); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(int *a, int *b) { int X; X = *a; *a = *b; *b = X; } Memória Endere ço Nome da variável Valor 100 110 120 130 1 2 100 110 140 X a b A B É alocado espaço para a variável local X. Exemplo Memória Endere ço Nome da variável Valor 100 110 120 130 1 2 100 110 140 X 1 a b A B #include <stdio.h> #include <stdlib.h> void troca_vars(int *, int *); int main() { int A, B; scanf("%d%d", &A,&B); troca_vars(&A, &B); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(int *a, int *b) { int X; X = *a; *a = *b; *b = X; } X deve receber o CONTEÚDO apontado pelo endereço que consta na variável a. Por essa razão precisamos usar o operador * (operador de conteúdo) na frente do nome da variável a. Memória Endere ço Nome da variável Valor 100 110 120 130 2 2 100 110 140 X 1 a b A B Exemplo #include <stdio.h> #include <stdlib.h> void troca_vars(int *, int *); int main() { int A, B; scanf("%d%d", &A,&B); troca_vars(&A, &B); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(int *a, int *b) { int X; X = *a; *a = *b; *b = X; } *a nesta linha significa o conteúdo (1) apontado pelo endereço que consta em a (100). *b nesta linha significa o conteúdo (2) apontado pelo endereço que consta em b (110) *a = *b significa que o valor 1 (que consta noendereço 100) será substituído pelo valor 2 (que consta no endereço 110) . Memória Endere ço Nome da variável Valor 100 110 120 130 2 1 100 110 140 X 1 a b A B Exemplo #include <stdio.h> #include <stdlib.h> void troca_vars(int *, int *); int main() { int A, B; scanf("%d%d", &A,&B); troca_vars(&A, &B); printf("\nA:%d\nB:%d", A, B); system("PAUSE"); return 0; } void troca_vars(int *a, int *b) { int X; X = *a; *a = *b; *b = X; } *b nesta linha significa o conteúdo (2) apontado pelo endereço que consta em b (110) *b = X significa que o valor 2 (que consta no endereço 110) será substituído pelo conteúdo da variável X. Exemplo 2: passagem por referência #include <stdio.h> #include <stdlib.h> int valor(int *, int *); int main() { int n1=2, n2=3, total; printf(“\n”); printf(“Valor de n1=%d\n”,n1); printf(“Valor de n2=%d\n”,n2); printf(“Chamando a função\n”); valor(&n1,&n2); printf(“Valor de n1=%d após função \n”,n1); printf(“Valor de n2=%d após função \n”,n2); system(“pause”); return 0; } Protótipo da função. Note que como os parâmetros serão ponteiros, depois de cada tipo acrescentamos o * Continua no próximo slide... Exemplo 1: passagem por referência #include <stdio.h> #include <stdlib.h> int valor(int *, int *); int main() { int n1=2, n2=3, total; printf(“\n”); printf(“Valor de n1=%d\n”,n1); printf(“Valor de n2=%d\n”,n2); printf(“Chamando a função\n”); valor(&n1,&n2); printf(“Valor de n1=%d após função \n”,n1); printf(“Valor de n2=%d após função \n”,n2); system(“pause”); return 0; } Criação de variáveis locais dentro da função main() Chamada à função. Note que aqui são passados os endereços das variáveis n1 e n2 Continua no próximo slide... Exemplo 1: passagem por referência #include <stdio.h> #include <stdlib.h> int valor(int *, int *); int main() { ... valor(&n1,&n2); ... } int valor(int *a, int *b) { *a = *a +3; *b = *b +2; printf(“Valores de n1 e n2 modificados dentro da função \n”); printf(“Valor de n1=%d \n”,*a); printf(“Valor de n2=%d \n”,*b); } Criação dos parâmetros a e b (que são variáveis locais da função valor). Os parâmetros a e b são ponteiros e recebem os endereços das variáveis que são informados durante a chamada da função Exemplo 1: passagem por referência #include <stdio.h> #include <stdlib.h> int valor(int *, int *); int main() { ... valor(&n1,&n2); ... } int valor(int *a, int *b) { *a = *a +3; *b = *b +2; printf(“Valores de n1 e n2 modificados dentro da função \n”); printf(“Valor de n1=%d \n”,*a); printf(“Valor de n2=%d \n”,*b); } Atribui (indiretamente) o resultado da expressão ao endereço apontado por a. Ou seja, a contém o endereço de n1, então n1 recebe o seu conteúdo + 3. Idem para a linha *b =*b + 2, sendo que b contém o endereço de n2 Exemplo 1: passagem por referência #include <stdio.h> #include <stdlib.h> int valor(int *, int *); int main() { int n1=2, n2=3, total; ... valor(&n1,&n2); ... } int valor(int *a, int *b) { *a = *a +3; *b = *b +2; printf(“Valores de n1 e n2 modificados dentro da função \n”); printf(“Valor de n1=%d \n”,*a); printf(“Valor de n2=%d \n”,*b); } Aqui precisamos usar a passagem por referência porque queremos mudar os valores das variáveis n1 e n2. Note que n1 e n2 são locais à função main() e por isso não podem ser acessadas diretamente pela função valor(). Embora n1 e n2 não estejam acessíveis à função valor(), seus endereços podem ser passados via parâmetros e assim valor() pode finalmente acessar as variáveis n1 e n2. Passando strings por referência ` No exemplo anterior, você passou como parâmetros os endereços de duas variáveis do tipo inteiro e por isso precisou usar o operador de endereço & ` No próximo exemplo, veremos que no caso de strings não precisamos usar o & Exemplo 3: passando string ` Escreva um procedimento chamado repete para receber como parâmetros uma cadeia de caracteres e um número n. Ao recebê-los, o procedimento deve exibir essa mesma cadeia de caracteres n vezes. Escreva um algoritmo em Português estruturado para receber uma palavra e usando esse procedimento repete, exiba a palavra 10 vezes. Exemplo 2: passando string #include <stdio.h> void repete (char [], int); int main() { char palavra[100]; int n=10; printf("\nQual a palavra (até 100 letras)? "); scanf("%s", palavra); fflush(stdin); repete(palavra, n); return 0; } void repete(char w[], int n) { int i; for (i=1; i<=n; i++) { printf("\n%s", w); } } Exemplo 3: outro jeito #include <stdio.h> void repete (char *, int); int main() { char palavra[100]; int n=10; printf("\nQual a palavra (até 100 letras)? "); scanf("%s", palavra); fflush(stdin); repete(palavra, n); return 0; } void repete(char *p, int n) { int i; for (i=1; i<=n; i++) { printf("\n%s", p); } } Exemplo 4: sem parâmetros ` Primeiro vamos ver um caso mais simples: ` Escreva uma função para imprimir o cabeçalho: Universidade Federal da Grande Dourados Curso de Bacharelado em Sistemas de Informação Ano 2012 ` Escreva um Programa em C estruturado que utilize o procedimento para escrever o cabeçalho. Exemplo 4: sem parâmetros #include <stdio.h> void cabecalho (void); int main() { cabecalho(); } void cabecalho(void) { printf("\nUniversidade Federal da Grande Dourados"); printf("\nCurso de Bacharelado em Sistemas de Informação"); printf("\nAno 2012"); } Exemplo 5: passando strings por referência ` Reescreva a função anterior de modo que ela possa receber qualquer nome de universidade, curso e ano. Escreva também um Programa em C que utilize o seu novo procedimento para escrever o cabeçalho com os dados fornecidos pelo usuário. Exemplo 2: passagem por referência #include <stdio.h> void cabecalho (char *, char *, char *); int main() { char univ[100], curso[100], ano[5]; printf("\nQual a universidade? "); scanf("%s", univ); fflush(stdin); printf("\nQual o curso? "); scanf("%s", curso); fflush(stdin); printf("\nQual o ano? "); scanf("%s", ano); cabecalho(univ, curso, ano); return 0; } Exemplo 2: passagem por referência #include <stdio.h> void cabecalho (char *, char *, char *); int main() { ... cabecalho(univ, curso, ano); return 0; } void cabecalho(char *u, char *c, char *a) { printf("\n%s", u); printf("\n%s", c); printf("\n%s", a); } Referências ` Algoritmos – Fundamento e Prática. Everton Coimbra de Araújo. Florianópolis: Visual Book, 2007. ` Algoritmos - Lógica para desenvolvimento de programação de computadores. José Augusto N. G. Manzano, Jayr Figueiredo de Oliveira. São Paulo: Érica, 2006. ` Victorine Viviane Mizrahi. Treinamento em linguagem C. São Paulo: Pearson Prentice Hall, 2008. ` Ricardo Sonaglio Albano e Silvie Guedes Albano. Programação em Linguagem C. Rio de Janeiro; Editora Ciência Moderna, 2010. 85 Algoritmos e programação Plano de aula Escopo de variáveis Exemplo Exemplo Escopo de variáveis Exemplo variáveis locais Exemplo: erro Exemplo: erro Exemplo: erro Passagens de parâmetros Exemplo de parâmetros Solução SEM função Solução incluindo função Criando um corpo para a função Criando um corpo para a função Criando um corpo para a função Criando um corpo para a função Criando um corpo para a função Criando um corpo para a função Criando um corpo para a função Criando um corpo para a função Parâmetros de uma função Passagem de parâmetro por valor Argumento x Parâmetro Passagem de parâmetro por valor: exemplo Passagem de parâmetro por valor: exemplo Passagem de parâmetro por valor: exemplo Passagem de parâmetropor valor: exemplo 2 Passagem de parâmetro por valor: exemplo 2 Passagem de parâmetro por valor: exemplo 2 Passagem de parâmetro por valor: exemplo 2 Passagem de parâmetro por valor: exemplo 2 Passagem de parâmetro por valor: exemplo 2 Passagem de parâmetro por valor: exemplo 2 Passagem de parâmetro por valor: exemplo 2 Passando vários argumentos Exemplo 4 Passagem de parâmetro por referência Armazenamento de informações Tipos de dados definidos pelo padrão ANSI Armazenamento de informações: exemplo Armazenamento de informações: exemplo Armazenamento de informações: exemplo Ponteiro Declarando uma variável ponteiro Variável ponteiro: exemplo Operadores de manipulação de ponteiros Operador de endereço (&) Endereços em strings Inicializando um ponteiro Verificando o conteúdo armazenado em um ponteiro Verificando o conteúdo armazenado em um ponteiro Verificando o conteúdo armazenado em um ponteiro Usando o operador de conteúdo (*) Passagem de parâmetros por referência Exemplo Exemplo Exemplo Exemplo Exemplo Exemplo Exemplo Exemplo Exemplo Exemplo Exemplo Exemplo 2: passagem por referência Exemplo 1: passagem por referência Exemplo 1: passagem por referência Exemplo 1: passagem por referência Exemplo 1: passagem por referência Passando strings por referência Exemplo 3: passando string Exemplo 2: passando string Exemplo 3: outro jeito Exemplo 4: sem parâmetros Exemplo 4: sem parâmetros Exemplo 5: passando strings por referência Exemplo 2: passagem por referência Exemplo 2: passagem por referência Referências
Compartilhar