Aula11_Modularidade_2_AP

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