Aula 18 - Ponteiros , parametro por referencia

Prévia do material em texto

A18: Ponteiros e 
Parâmetros por referência
Algoritmos e Programação
Julio Toss
jtoss@inf.ufrgs.br
INF01202 – Algoritmos e Programação, 2018/01, Turmas G, H, K e L
*baseado no material da prof. Mariana e do prof. Marcelo Walter 
Atenção:
O material aqui contido não substitui a leitura do livro texto e é incompleto sem a 
apresentação do professor em aula.
2
Subprogramação
Escopo de variáves
Funções sem tipo
Parâmetros
Funções com tipo
Semana passada
void nome() {
 //código (…)
}
void nome(TIPO nome_param1, TIPO nome_param2, …) {
 //código (…)
}
TIPO nome() {
 //código (…)
 return retorno;
}
TIPO nome(TIPO nome_param1, TIPO nome_param2, …) {
 //código (…)
 return retorno;
}
3
Funções: semana passada
→ Funções sem retorno (void): não retornam valor associado à função
→ sem parâmetros
→ com parâmetros
→ passados por valor
passados por referência
→ Funções com retorno (tipadas): retornam um valor associado à função
→ sem parâmetros
→ com parâmetros
 → passados por valor
passados por referência
4
Aula passada: maior ou menor de números positivos
Escreva um programa que lê 3 números inteiros informados pelo usuário, garantindo que só 
serão aceitos valores positivos (>= 0, faça validação) e um indicador (m ou M, faça validação). Se o 
indicador for m, o programa calcula e retorna o menor dentre os números lidos. Se o indicador 
for M, ele calcula e retorna o maior dentre os números lidos. Seu programa deve estar baseado 
em subprogramação, contendo as seguintes funções (com os respectivos protótipos):
int le_valor() //le um valor inteiro, retornando apenas valores validos
char le_indicador() //le o indicador, retornando apenas valores validos
int busca_maior(int, int, int) //recebe os 3 numeros lidos, e retorna o maior
int busca_menor(int, int, int) //recebe os 3 numeros lidos, e retorna o menor
A função main() deverá chamar cada função quando apropriado, e deverá ser a responsável por 
imprimir o valor do maior ou menor elemento retornado pela respectiva função.
Obs.: você não deve usar vetores neste exercício (veremos na próxima semana!)
5
Exercicio aula passada
6
#include <stdio.h>
int le_valor() {
 int valor;
 do{
 printf("Informe um valor positivo: ");
 scanf("%d",&valor);
 if(valor <= 0)
 printf("Valor invalido!\n");
 }while(valor <= 0);
 
 return valor;
}
char le_indicador() {
 char indicador;
 do{
 printf("Informe o indicador (m ou M): ");
 scanf(" %c",&indicador);
 if(indicador != 'm' && indicador != 'M')
 printf("Indicador invalido!\n");
 }while(indicador != 'm' && indicador != 'M');
 
 return indicador;
}
int busca_maior(int a, int b, int c) {
 int maior;
 if (a > b)
 if (a > c)
 maior = a;
 else
 maior = c;
 else
 if (b > c)
 maior = b;
 else
 maior = c; 
 return maior;
}
int busca_menor(int a, int b, int c) {
 int menor;
 if (a < b)
 if (a < c)
 menor = a;
 else
 menor = c;
 else
 if (b < c)
 menor = b;
 else
 menor = c;
 return menor;
}
Exercicio aula passada
7
int main(){
 int v1, v2, v3;
 char ind;
 int res;
 v1=le_valor();
 v2=le_valor();
 v3=le_valor();
 printf("Valores lidos: %d, %d e %d\n",v1, v2, v3);
 ind = le_indicador();
 printf("Operação selecionada: %c\n",ind);
 if (ind == 'M'){
 res = busca_maior(v1, v2, v3);
 printf("Maior valor: %d\n",res);
 }
 else{
 res = busca_menor(v1, v2, v3);
 printf("Menor valor: %d\n",res);
 }
 return 0;
}
Passagem de parâmetros por valor
Como visto na semana passada:
● Cada parâmetro passa somente um valor à função
● para cada parâmetro, é alocada uma área de uso local da função e o valor 
do argumento é copiado para esta área (valor inicial).
● alterações deste valor, durante o processamento da função, não alteram o 
valor da variável enviada pelo programa que chamou a função (argumento 
ou parâmetro real), apenas a cópia local, pois se tratam de variáveis locais 
independendentes
8
Passagem de parâmetros por valor: exemplo
float calcula_media(float a, float b, float c)
{
float m;
a = a / 3;
b = b / 3;
c = c / 3;
m = (a+b+c);
return m;
}
int main ( )
{
float a=3.2, b=4.5, c=7.8, media;
printf(“a = %3.2f b= %3.2f c = %3.2f\n”, a,b,c);
media = calcula_media(a,b,c);
printf(“A media vale %3.2f\n”, media);
printf(“a = %3.2f b= %3.2f c = %3.2f\n”, a,b,c)
return 0;
}
9
a=3.20 b=4.50 c=7.80
A media vale 5.17
a=???? b=???? c=????
Passagem de parâmetros por valor: exemplo
int main ( )
{
float a=3.2, b=4.5, c=7.8, media;
printf(“a = %3.2f b= %3.2f c = %3.2f\n”, a,b,c);
media = calcula_media(a,b,c);
printf(“A media vale %3.2f\n”, media);
printf(“a = %3.2f b= %3.2f c = %3.2f\n”, a,b,c)
return 0;
}
10
a=3.20 b=4.50 c=7.80
A media vale 5.17
a=3.20 b=4.50 c=7.80
Os valores não mudam após a 
execução da função, pois foi 
passada à ela uma cópia dos 
valores de a, b e c.
float calcula_media(float a, float b, float c)
{
float m;
a = a / 3;
b = b / 3;
c = c / 3;
m = (a+b+c);
return m;
}
Funções: aula de hoje
Funções sem retorno (void): não retornam valor associado à função
sem parâmetros
com parâmetros
passados por valor
→ passados por referência
Funções com retorno (tipadas): retornam um valor associado à função
sem parâmetros
com parâmetros
passados por valor
→ passados por referência
11
Motivação
Como trocar os valores de duas variáveis?
int a = 1, b = 2, aux;
aux = a;
a = b;
b = aux;
Como fazer uma função auxiliar para isso?
1. // cabecalhos
2. #include <stdio.h>
3.
4. void troca(int a, int b)
5. {
6. int aux;
7. aux = a;
8. a = b;
9. b = aux;
10. }
11.
12. int main() {
13. int a=10, b=20;
14.
15. printf("a:%d b:%d\n", a, b);
16. troca(a, b);
17. printf("a:%d b:%d\n", a, b);
18. }
a:10 b:20
a:10 b:20
12
Motivação
Como trocar os valores de duas variáveis?
int a = 1, b = 2, aux;
aux = a;
a = b;
b = aux;
Como fazer uma função auxiliar para isso?
1. // cabecalhos
2. #include <stdio.h>
3.
4. void troca(int a, int b)
5. {
6. int aux;
7. aux = a;
8. a = b;
9. b = aux;
10. }
11.
12. int main() {
13. int a=10, b=20;
14.
15. printf("a:%d b:%d\n", a, b);
16. troca(a, b);
17. printf("a:%d b:%d\n", a, b);
18. }
a:10 b:20
a:10 b:20
visão do programador
Nome Dado
(...) (...)
a (main) 10
b (main) 20
a (troca) 10
b (troca) 20
aux (troca) ?
(...) (...)
13
Motivação
Como trocar os valores de duas variáveis?
int a = 1, b = 2, aux;
aux = a;
a = b;
b = aux;
Como fazer uma função auxiliar para isso?
1. // cabecalhos
2. #include <stdio.h>
3.
4. void troca(int a, int b)
5. {
6. int aux;
7. aux = a;
8. a = b;
9. b = aux;
10. }
11.
12. int main() {
13. int a=10, b=20;
14.
15. printf("a:%d b:%d\n", a, b);
16. troca(a, b);
17. printf("a:%d b:%d\n", a, b);
18. }
a:10 b:20
a:10 b:20
visão do programador
Nome Dado
(...) (...)
a (main) 10
b (main) 20
a (troca) 10
b (troca) 20
aux (troca) 10
(...) (...)
14
Motivação
Como trocar os valores de duas variáveis?
int a = 1, b = 2, aux;
aux = a;
a = b;
b = aux;
Como fazer uma função auxiliar para isso?
1. // cabecalhos
2. #include <stdio.h>
3.
4. void troca(int a, int b)
5. {
6. int aux;
7. aux = a;
8. a = b;
9. b = aux;
10. }
11.
12. int main() {
13. int a=10, b=20;
14.
15. printf("a:%d b:%d\n", a, b);
16. troca(a, b);
17. printf("a:%d b:%d\n", a, b);
18. }
a:10 b:20
a:10 b:20
visão do programador
Nome Dado(...) (...)
a (main) 10
b (main) 20
a (troca) 20
b (troca) 20
aux (troca) 10
(...) (...)
15
Motivação
Como trocar os valores de duas variáveis?
int a = 1, b = 2, aux;
aux = a;
a = b;
b = aux;
Como fazer uma função auxiliar para isso?
1. // cabecalhos
2. #include <stdio.h>
3.
4. void troca(int a, int b)
5. {
6. int aux;
7. aux = a;
8. a = b;
9. b = aux;
10. }
11.
12. int main() {
13. int a=10, b=20;
14.
15. printf("a:%d b:%d\n", a, b);
16. troca(a, b);
17. printf("a:%d b:%d\n", a, b);
18. }
a:10 b:20
a:10 b:20
visão do programador
Nome Dado
(...) (...)
a (main) 10
b (main) 20
a (troca) 20
b (troca) 10
aux (troca) 10
(...) (...)
16
Motivação
Como trocar os valores de duas variáveis?
int a = 1, b = 2, aux;
aux = a;
a = b;
b = aux;
Como fazer uma função auxiliar para isso?
1. // cabecalhos
2. #include <stdio.h>
3.
4. void troca(int a, int b)
5. {
6. int aux;
7. aux = a;
8. a = b;
9. b = aux;
10. }
11.
12. int main() {
13. int a=10, b=20;
14.
15. printf("a:%d b:%d\n", a, b);
16. troca(a, b);
17. printf("a:%d b:%d\n", a, b);
18. }
a:10 b:20
a:10 b:20
visão do programador
Nome Dado
(...) (...)
a (main) 10
b (main) 20
a (troca) 20
b (troca) 10
aux (troca) 10
(...) (...)
IMPORTANTE: as variáveis 
a e b da função main e a e b 
da função troca são 
independentes, sem 
nenhuma relação entre si!! 
17
Os valores de a e b não foram trocados, porque a passagem de parâmetros foi feita por 
valor:
- Variável local a da função troca é inicializada com conteúdo de a (argumento);
- Variável local b da função troca é inicializada com conteúdo de b (argumento);
- Dentro do subprograma, os valores de a e b da função troca são trocados, mas esta 
mudança é feita sobre as cópias locais dos valores e não é propagada para fora do 
subprograma, tal que a e b da função main permanecem com os valores originais.
Ponteiros e Parâmetros por referência
18
Ponteiros
Definição: variáveis que guardam e manipulam endereços de memória e o 
conteúdo dentro destes.
Servem para que o programador possa acessar diretamente o local que a 
variável utiliza para armazenar os dados.
19
Rua 
Nascimento 
Silva, 107
Rua 
Nascimento 
Silva, 107
Ponteiros
20
Diferenciar entre o endereço (a50f118) de um assento no show e a 
pessoa (Maria) que está sentada no assento específico
Memória
Toda variável utilizada por um programa reside em determinado endereço de 
memória.
Os nomes das variáveis são utilizados apenas pelo programador, como 
referência simbólica, para facilitar a escrita e a portabilidade do programa. O 
computador, ao executar o programa, utiliza apenas endereços para acessar o 
conteúdo das variáveis.
21
Memória
Toda variável utilizada por um programa reside em determinado endereço de 
memória.
Os nomes das variáveis são utilizados apenas pelo programador, como 
referência simbólica, para facilitar a escrita e a portabilidade do programa. O 
computador, ao executar o programa, utiliza apenas endereços para acessar o 
conteúdo das variáveis.
22
visão do programador
Nome Dado
(...) (...)
a (main) 10
b (main) 20
a (troca) 20
b (troca) 10
aux (troca) 10
(...) (...)
visão do computador
Endereço Dado
(...) (...)
9f5770010 10
9f5770014 20
9f5770018 20
9f5770022 10
9f5770026 10
(...) (...)
Memória
23
AFA1 = 1010 1111 1010 0001 = 44961
Memória
1. // cabecalhos
2. #include <stdio.h>
3.
4. int main() {
5. int a=3;
6. char c='A';
7. char string[3] = "oi";
8. short int b=7;
9.
10. (…)
11. }
visão do programador
Nome Dado
(...) (...)
a (main) 3
c (main) 'A'
string (main) "oi"
b (main) 7
(...) (...)
visão do computador
Endereço Dado
(...) (...)
9f5770010 3
9f5770011 0
9f5770012 0
9f5770013 0
9f5770014 65
9f5770015 111
9f5770016 105
9f5770017 0
9f5770018 7
9f5770019 0 24
Memória
1. // cabecalhos
2. #include <stdio.h>
3.
4. int main() {
5. int a=3;
6. char c='A';
7. char string[3] = "oi";
8. short int b=7;
9.
10. (…)
11. }
visão do programador
Nome Dado
(...) (...)
a (main) 3
c (main) 'A'
string (main) "oi"
b (main) 7
(...) (...)
visão do computador
Endereço Dado
(...) (...)
9f5770010 3
9f5770011 0
9f5770012 0
9f5770013 0
9f5770014 65
9f5770015 111
9f5770016 105
9f5770017 0
9f5770018 7
9f5770019 0 25
Memória
1. // cabecalhos
2. #include <stdio.h>
3.
4. int main() {
5. int a=3;
6. char c='A';
7. char string[3] = "oi";
8. short int b=7;
9.
10. (…)
11. }
visão do programador
Nome Dado
(...) (...)
a (main) 3
c (main) 'A'
string (main) "oi"
b (main) 7
(...) (...)
visão do computador
Endereço Dado
(...) (...)
9f5770010 00000011
9f5770011 00000000
9f5770012 00000000
9f5770013 00000000
9f5770014 01000001
9f5770015 01101111
9f5770016 01101001
9f5770017 00000000
9f5770018 00000111
9f5770019 00000000
em binário ;-)
26
Sintaxe: 
Declaração:
TIPO *nome;
Exemplos:
float *f; // f é um ponteiro para variáveis do tipo float
int *p; // p é um ponteiro para variáveis do tipo inteiro
char *a, b, *p, c, *q; // pode declarar junto com variáveis
 // de mesmo tipo
Ponteiro: sintaxe
27
Sintaxe: 
Declaração:
TIPO *nome;
Exemplos:
float *f; // f é um ponteiro para variáveis do tipo float
int *p; // p é um ponteiro para variáveis do tipo inteiro
char *a, b, *p, c, *q; // pode declarar junto com variáveis
 // de mesmo tipo
Ponteiro: sintaxe
28
Asterisco indica que a variável 
armazena um endereço de memória, 
cujo conteúdo é do tipo especificado.
Qualquer tipo de dado válido em C!
Ponteiro: sintaxe
Porque os ponteiros tem que possuir um tipo?
Lembrando: Tipos de Dados
● Diferentes tipos de dados necessitam de um número diferente de bytes de memória para 
armazenar seu conteúdo.
● A declaração do tipo de dado indica o número de bytes reservados para conteúdos:
char a = ‘Z’; //1 byte
int n = 1234; //4 bytes
float PI = 3.1415; //4 bytes
● O endereço de uma variável é sempre o MENOR dos endereços, isto é, o endereço inicial.
● Um ponteiro para um tipo qualquer indica também sempre o número de bytes que esse 
tipo ocupa.
29
Podem variar entre diferentes 
arquiteturas. Para verificar: sizeof(tipo)
Z 1234 3.1415
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
 
Ponteiro: sintaxe
Operador Nome Ex Descrição 
* Derreferência de ponteiro *p
Derreferencia o ponteiro p. 
“Acessa o endereço de 
memória em p.” 
& Endereço de variável &v
Criar um ponteiro que 
referencia a variável v. 
“Obtém o endereço de 
memória de v.
30
Voltando ao show do U2...
31
Maria está sentada no assento 50 da fila 118
João está sentado no assento 43 da fila 77
O ingresso no assento 23 da fila 102 não foi vendido
Qual o “conteúdo” de a50f118?
*a50f118 = ? 
Onde está sentado Joao?
&Joao= ? 
Qual o “conteúdo” de a23f102?
*a23f102= ?
Maria
a43f77
Lixo! Não há como garantir 
o conteúdo
Sintaxe: 
Atribuição:
nome = expressão; // expressão: endereço de alguma variável
*nome = expressão; // expressão: valor a ser armazenado no
 // endereço apontado pelo ponteiro
Ponteiro: sintaxe
Exemplo:
char c = 'A', *ptr;
ptr = &c; //Variável ptr recebe endereço da variável c
Exemplo:
ptr = &c;
*ptr = 'B';
 printf("%c", c); // qual caractere vai mostrar?
32
Ponteiro: exemplo 1
#include <stdio.h>
#include <stdlib.h>
int main()
{
 int count, q, *m;
 m = &count;// recebe endereço de count
 count = 60; 
 q = *m; // recebe valor apontado por m
 
 printf("m = %p\n", m); // %p para imprimir em formato de endereço de memoria
 printf("q = %d\n", q);
 // conteúdo apontado por m
 printf("conteudo do endereco apontado por m: %d\n\n", *m);
 return 0;
}
33
Ponteiro: exemplo 1
#include <stdio.h>
#include <stdlib.h>
int main()
{
 int count, q, *m;
 m = &count; // recebe endereço de count
 count = 60; 
 q = *m; // recebe valor apontado por m
 
 printf("m = %p\n", m); // %p para imprimir em formato de endereço de memoria
 printf("q = %d\n", q);
 // conteúdo apontado por m
 printf("conteudo do endereco apontado por m: %d\n\n", *m);
 return 0;
}
34
Ponteiro: exemplo 1
#include <stdio.h>
#include <stdlib.h>
int main()
{
 int count, q, *m;
 m = &count; // recebe endereço de count
 count = 60; 
 q = *m; // recebe valor apontado por m
 
 printf("m = %p\n", m); // %p para imprimir em formato de endereço de memoria
 printf("q = %d\n", q);
 // conteúdo apontado por m
 printf("conteudo do endereco apontado por m: %d\n\n", *m);
 return 0;
}
visão do programador
Nome Dado
(...) (...)
count (main) 60
q (main) 60
*m (main) & count (main)
(...) (...)
visão do computador
Endereço Dado
(...) (...)
a43bf11190 60
a43bf11194 60
a43bf11198 a43bf11190
(...) (...)
35
Ponteiro: exemplo 2
#include <stdio.h>
#include <stdlib.h>
int main()
{
 int x = 200, *p1, *p2;
 p1 = &x; // p1 aponta para x
 p2 = p1; // p2 recebe p1 e também passa a apontar para x
 printf("x - %d, p1=%p e p2=%p\n", x, p1, p2); // endereço de x
 printf("x - %d, p1=%d e p2=%d\n",x,*p1, *p2); // conteúdo de x
 return 0;
}
36
x - 200, p1=0022FF60 e p2 = 0022FF60
x - 200, p1=200 e p2 = 200
Ponteiro: exemplo 3
#include <stdio.h>
#include <stdlib.h>
int main()
{
 int a, *x, *y;
 a = 10;
 x = &a;
 y = x;
 printf("a = %d, *x = %d, *y = %d \n",a,*x, *y);
 printf("a = %d, x = %p, y = %p\n\n", a, x, y);
 *x = 20;
 printf("a = %d, *x = %d, *y = %d \n",a, *x, *y);
 printf("a = %d, x = %p, y = %p\n\n", a, x, y); 
 return 0;
}
37
Ponteiro: erro comum 1
#include <stdio.h>
#include <stdlib.h>
int main()
{
 float x;
 int *p;
 
 x = 100;
 p = &x;
 printf("x=%f p=%p\n\n", x,p);
 return 0;
}
38
Ponteiro: erro comum 1
#include <stdio.h>
#include <stdlib.h>
int main()
{
 float x;
 int *p;
 
 x = 100;
 p = &x;
 printf("x=%f p=%p\n\n", x,p);
 return 0;
}
WARNING: atribuição de um tipo 
incompatível de ponteiro
P é um ponteiro para inteiros, logo não 
pode apontar para um float!
39
Ponteiro: erro comum 2
#include <stdio.h>
#include <stdlib.h>
int main()
{
 int x;
 int *p;
 
 x = 100;
 *p = x;
 printf("x=%d p=%p\n\n", x,p);
 return 0;
}
40
Ponteiro: erro comum 2
#include <stdio.h>
#include <stdlib.h>
int main()
{
 int x;
 int *p;
 
 x = 100;
 *p = x;
 printf("x=%d p=%p\n\n", x,p);
 return 0;
}
Undefined Behavior: 
Comportamento não definido 
(imprevisível)
Possível erro de execução: p 
não foi inicializado. quando p 
foi criado, ele aponta para um 
endereço de memória 
desconhecido.
Resultado imprevisível!!!
Compilador não avisará e o 
programa executará, porém 
provavelmente irá falhar.
41
Ponteiro: erro comum 2 (fixed)
#include <stdio.h>
#include <stdlib.h>
int main()
{
 int x;
 int *p;
 
 x = 100;
 p = &x;
 printf("x=%d p=%p\n\n", x,p);
 return 0;
}
42
Obs: inicialização de ponteiros
Ponteiros não devem ser utilizados sem 
prévia inicialização. Exemplo correto 
abaixo:
int x;
float pi = 3.14;
int *ptr_x = &x;
float *ptr_to_pi = &pi;
No entanto, podem existir situações* em 
que não se quer inicialmente que um 
ponteiro aponte uma variável. Nesse caso, 
deve-se inicializar o ponteiro com NULL. 
Exemplo:
int a = 5, b = 7;
int *ptr = NULL;
*estas situação virão em outras disciplinas
Funções: aula de hoje
Funções sem retorno (void): não retornam valor associado à função
sem parâmetros
com parâmetros
passados por valor
→ passados por referência
Funções com retorno (tipadas): retornam um valor associado à função
sem parâmetros
com parâmetros
passados por valor
→ passados por referência
43
Sintaxe 5: funções sem tipo e com parâmetros por referência
Protótipo:
void nome(TIPO*, …);
Implementação:
void nome(TIPO* nome_param1, …) {
 //código (…)
}
Chamada:
nome(&variável, …);
Funções definidas pelo usuário
44
Sintaxe 6: funções tipadas com parâmetros por referência
Protótipo:
TIPO nome(TIPO*, …);
Implementação:
TIPO nome(TIPO* nome_param1, …) {
 //código (…)
 return retorno;
}
Chamada:
TIPO variável0 = nome(&variável1, …);
Funções definidas pelo usuário
45
Funções tipadas: exemplos
1. // cabecalhos
2. #include <stdio.h>
3.
4. // funcoes
5. void troca(int a, int b) {
6.
7.
8.
9.
10. }
11.
12. int main() {
13. int a=10, b=20;
14.
15. printf("a:%d b:%d\n", a, b);
16. troca( a, b);
17. printf("a:%d b:%d\n", a, b);
18. }
46
Funções tipadas: exemplos
1. // cabecalhos
2. #include <stdio.h>
3.
4. // funcoes
5. void troca(int* a, int* b) {
6. int aux;
7. aux = a;
8. a = b;
9. b = aux;
10. }
11.
12. int main() {
13. int a=10, b=20;
14.
15. printf("a:%d b:%d\n", a, b);
16. troca( a, b);
17. printf("a:%d b:%d\n", a, b);
18. }
Nome Dado
(...) (...)
a (main) 10
b (main) 20
*a (troca) 10
*b (troca) 20
aux (troca) ?
(...) (...)
47
Funções tipadas: exemplos
1. // cabecalhos
2. #include <stdio.h>
3.
4. // funcoes
5. void troca(int* a, int* b) {
6. int aux;
7. aux = a;
8. a = b;
9. b = aux;
10. }
11.
12. int main() {
13. int a=10, b=20;
14.
15. printf("a:%d b:%d\n", a, b);
16. troca( a, b);
17. printf("a:%d b:%d\n", a, b);
18. }
Nome Dado
(...) (...)
a (main) 10
b (main) 20
*a (troca) 20
*b (troca) 10
aux (troca) 10
(...) (...)
X
48
Funções tipadas: exemplos
1. // cabecalhos
2. #include <stdio.h>
3.
4. // funcoes
5. void troca(int* a, int* b) {
6. int aux;
7. aux = a;
8. a = b;
9. b = aux;
10. }
11.
12. int main() {
13. int a=10, b=20;
14.
15. printf("a:%d b:%d\n", a, b);
16. troca( &a, &b);
17. printf("a:%d b:%d\n", a, b);
18. }
Nome Dado
(...) (...)
a (main) 10
b (main) 20
*a (troca) & a (main)
*b (troca) & b (main)
aux (troca) ?
(...) (...)
49
Funções tipadas: exemplos
1. // cabecalhos
2. #include <stdio.h>
3.
4. // funcoes
5. void troca(int* a, int* b) {
6. int aux;
7. aux = a;
8. a = b;
9. b = aux;
10. }
11.
12. int main() {
13. int a=10, b=20;
14.
15. printf("a:%d b:%d\n", a, b);
16. troca( &a, &b);
17. printf("a:%d b:%d\n", a, b);
18. }
Nome Dado
(...) (...)
a (main) 10
b (main) 20
*a (troca) & b (main)
*b (troca) & a (main)
aux (troca) & a (main)
(...) (...)
X
50
Funções tipadas: exemplos
1. // cabecalhos
2. #include <stdio.h>
3.
4. // funcoes
5. void troca(int* a, int* b) {
6. int aux;
7. aux =&a;
8. a =&b;
9. b =&aux;
10. }
11.
12. int main() {
13. int a=10, b=20;
14.
15. printf("a:%d b:%d\n", a, b);
16. troca( &a, &b);
17. printf("a:%d b:%d\n", a, b);
18. }
Nome Dado
(...) (...)
a (main) 10
b (main) 20
*a (troca) & a(main)
*b (troca) & b (main)
aux (troca) ?
(...) (...)
51
Funções tipadas: exemplos
1. // cabecalhos
2. #include <stdio.h>
3.
4. // funcoes
5. void troca(int* a, int* b) {
6. int aux;
7. aux =&a;
8. a =&b;
9. b =&aux;
10. }
11.
12. int main() {
13. int a=10, b=20;
14.
15. printf("a:%d b:%d\n", a, b);
16. troca( &a, &b);
17. printf("a:%d b:%d\n", a, b);
18. }
Nome Dado
(...) (...)
a (main) 10
b (main) 20
*a (troca) & b (troca)
*b (troca) & aux (troca)
aux (troca) & a (troca)
(...) (...)
X
52
Funções tipadas: exemplos
1. // cabecalhos
2. #include <stdio.h>
3.
4. // funcoes
5. void troca(int* a, int* b) {
6. int aux;
7. aux = *a;
8. *a = *b;
9. *b = aux;
10. }
11.
12. int main() {
13. int a=10, b=20;
14.
15. printf("a:%d b:%d\n", a, b);
16. troca( &a, &b);
17. printf("a:%d b:%d\n", a, b);
18. }
Nome Dado
(...) (...)
a (main) 10
b (main) 20
*a (troca) & a (main)
*b (troca) & b (main)
aux (troca) ?
(...) (...)
53
Funções tipadas: exemplos
1. // cabecalhos
2. #include <stdio.h>
3.
4. // funcoes
5. void troca(int* a, int* b) {
6. int aux;
7. aux = *a;
8. *a = *b;
9. *b = aux;
10. }
11.
12. int main() {
13. int a=10, b=20;
14.
15. printf("a:%d b:%d\n", a, b);
16. troca( &a, &b);
17. printf("a:%d b:%d\n", a, b);
18. }
Nome Dado
(...) (...)
a (main) 20
b (main) 10
*a (troca) & a (main)
*b (troca) & b (main)
aux (troca) 10
(...) (...)
v
54
Funções tipadas: exemplos
1. // cabecalhos
2. #include <stdio.h>
3.
4. // funcoes
5. void troca(int* a, int* b) {
6. int aux;
7. aux = *a;
8. *a = *b;
9. *b = aux;
10. }
11.
12. int main() {
13. int a=10, b=20;
14.
15. printf("a:%d b:%d\n", a, b);
16. troca( &a, &b);
17. printf("a:%d b:%d\n", a, b);
18. }
Nome Dado
(...) (...)
a (main) 20
b (main) 10
*a (troca) & a (main)
*b (troca) & b (main)
aux (troca) 10
(...) (...)
v
55
Assim como precisamos ter 
compatibilidade entre tipo de dados 
(int, char, float) declarado e enviado 
como parâmetro, também deve haver 
compatibilidade entre tipo de variável 
(simples/ponteiro) declarada e 
enviada como parâmetro
Exercício: baskara
Faça um programa que receba 
três valores reais a, b e c, e que 
retorne as duas raízes x1 e x2 da 
equação: ax2 + bx + c = 0.
Assuma que a equação de 
segundo grau possui raízes reais.
#include<stdio.h>
#include<math.h>
void baskara(float, float, float, float*, float*);
56
Exercício: baskara
Faça um programa que receba 
três valores reais a, b e c, e que 
retorne as duas raízes x1 e x2 da 
equação: ax2 + bx + c = 0.
Assuma que a equação de 
segundo grau possui raízes reais.
#include<stdio.h>
#include<math.h>
void baskara(float, float, float, float*, float*);
void baskara(float a, float b, float c, float* x1, float* x2) {
 float delta;
 delta = sqrt(b*b-4*a*c);
 *x1 = (-b + delta)/(2*a);
 *x2 = (-b - delta)/(2*a);
}
int main() {
 float a, b, c, x1, x2;
 scanf("%f %f %f", &a, &b, &c);
 baskara(a, b, c, &x1, &x2);
 printf("raizes: %f e %f", x1, x2);
 return 0;
}
57