Aula 05 - Subrotinas - Funções e procedimentos

Prévia do material em texto

DCC 119 Algoritmos
Um conceito simples seria: 
Subrotina é um parcela de código 
computacional que executa uma tarefa bem 
definida, sendo que essa tarefa pode ser 
executada (chamada) diversas vezes num 
mesmo programa.
Necessidade de dividir um problema computacional em 
pequenas partes.
Os programadores verificaram que muitas destas 
pequenas partes se repetiam.
Ex.: Impressão de mensagens, zerar um vetor, fazer uma 
operação matricial, etc.
Deve-se usar subrotinas sempre que:
Utilizar uma parte do código em várias partes do 
programa; 
Vários programas irão utilizar os mesmos códigos 
(bibliotecas); 
Abstrair a complexidade e facilitar o entendimento do 
programa.
Facilita a programação estruturada:
dada as fases previstas nos refinamentos 
sucessivos decompõe-se o programa em módulos 
funcionais
tais módulos podem ser organizados/programados 
como subrotinas
Ou seja: viabiliza a modularização
Executam uma tarefa bem definida
Não funcionam sozinhas: devem ser chamadas por um 
programa principal ou por outra subrotina
Permite a criação de variáveis próprias e a manipulação de 
variáveis externas (devidamente parametrizadas)
Facilita a legibilidade do código através da:
estruturação (subrotinas são agrupadas fora do programa 
principal)
enxugamento (através de diversas chamadas da mesma 
subrotina) 
Existem dois tipos de subrotinas:
Procedimentos: não retornam nenhum valor. São usadas 
para realizar alguma operação que não gera dados. 
Funções: retornam valor. São utilizadas para realizar 
uma operação e retornam alguma resposta relativa à 
operação realizada.
A sintaxe de declaração de um procedimento é:
<nome do procedimento> (<lista de parâmetros>)
{
<declaração de variáveis locais>
<comandos>
}
Nome que identifique a ação a ser 
executada no procedimento (sem 
espaços em branco!)
Ex.: imprimeMedia
A sintaxe de declaração de um procedimento é:
<nome do procedimento> (<lista de parâmetros>)
{
<declaração de variáveis locais>
<comandos>
}
Valores recebidos como parâmetro. 
Ex.: (A,B,20,30)
A sintaxe de declaração de um procedimento é:
<nome do procedimento> (<lista de parâmetros>)
{
<declaração de variáveis locais>
<comandos>
} Variáveis necessárias para a 
codificação do procedimento, 
além das passados na lista de 
parâmetros.
A sintaxe de declaração de um procedimento é:
<nome do procedimento> (<lista de parâmetros>)
{
<declaração de variáveis locais>
<comandos>
}
Comandos que implementam o 
procedimento desejado.
imprimeMaior(inteiro X, inteiro Y)
{
se (X > Y)
{ 
imprima(X);
}
senão
{ 
imprima(Y); 
}
}
imprimeMaior(inteiro X, inteiro Y)
{
se (X > Y)
{ 
imprima(X);
}
senão
{ 
imprima(Y); 
}
}
principal
{
inteiro A, B;
leia(A,B);
imprimeMaior(A,B);
}
Toda variável pertencente ao procedimento é 
chamada de variável local, pois ela só pode ser 
utilizada dentro do escopo do procedimento.
Fazem parte das variáveis locais de um procedimento:
- as variáveis declaradas no procedimento; 
- todos os parâmetros recebidos pelo procedimento.
Chamada por valor: é passado uma cópia da variável para a 
subrotina, ou seja, é feito uma cópia do argumento para o parâmetro. 
Qualquer alteração feita no parâmetro não reflete em alteração no 
argumento.
Chamada por referência: todas as alterações realizadas no 
parâmetro, refletem em alterações no argumento, ou seja, ambas as 
variáveis apontam para o mesmo endereço de memória. Para isso, é
necessário utilizar o modificar ref, indicando que será uma referência 
a uma variável. 
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y)
{ 
imprima(X);
Z X; 
}
senão
{ 
imprima(Y); 
Z Y; 
}
}
principal
{
inteiro A, B, C;
A 22; 
B 11; 
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8
P9
P1
P2
P3
P4
P5
P10
P9
P8
P8
P9
P10
P7
P6
P5
P4
P3
P2
P1
ZYXCBA
imprimeMaiorprincipalLinha
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y)
{ 
imprima(X);
Z X; 
}
senão
{ 
imprima(Y); 
Z Y; 
}
}
principal
{
inteiro A, B, C;
A 22; 
B 11; 
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8
P9
P1
P2
P3
P4
P5
P10
P9
P8
P8
P9
P10
P7
P6
P5
P4
P3
P2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y)
{ 
imprima(X);
Z X; 
}
senão
{ 
imprima(Y); 
Z Y; 
}
}
principal
{
inteiro A, B, C;
A 22; 
B 11; 
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8
P9
P1
P2
P3
P4
P5
P10
P9
P8
P8
P9
P10
P7
P6
P5
P4
P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y)
{ 
imprima(X);
Z X; 
}
senão
{ 
imprima(Y); 
Z Y; 
}
}
principal
{
inteiro A, B, C;
A 22; 
B 11; 
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8
P9
P1
P2
P3
P4
P5
P10
P9
P8
P8
P9
P10
P7
P6
P5
P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y)
{ 
imprima(X);
Z X; 
}
senão
{ 
imprima(Y); 
Z Y; 
}
}
principal
{
inteiro A, B, C;
A 22; 
B 11;
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8
P9
P1
P2
P3
P4
P5
P10
P9
P8
P8
P9
P10
P7
P6
P5
---lixo1122P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y)
{ 
imprima(X);
Z X; 
}
senão
{ 
imprima(Y); 
Z Y; 
}
}
principal
{
inteiro A, B, C;
A 22; 
B 11;
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8
P9
P1
P2
P3
P4
P5
P10
P9
P8
P8
P9
P10
P7
P6
---lixo1122P5
---lixo1122P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y)
{ 
imprima(X);
Z X; 
}
senão
{ 
imprima(Y); 
Z Y; 
}
}
principal
{
inteiro A, B, C;
A 22; 
B 11;
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8
P9
P1
P2
P3
P4
P5
P10
P9
P8
P8
P9
P10
P7
lixo1122lixo1122P6
---lixo1122P5
---lixo1122P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y) // (22 > 11)
{ 
imprima(X);
Z X; 
}
senão
{ 
imprima(Y); 
Z Y; 
}
}
principal
{
inteiro A, B, C;
A 22; 
B 11;
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8
P9
P1
P2
P3
P4
P5
P10
P9
P8
P8
P9
P10
lixo1122lixo1122P7
lixo1122lixo1122P6
---lixo1122P5
---lixo1122P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y) 
{ 
imprima(X); // imprima (22)
Z X; 
}
senão
{ 
imprima(Y); 
Z Y; 
}
}
principal
{
inteiro A, B, C;
A 22; 
B 11;
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8
P9
P1
P2
P3
P4
P5
P10
P9
P8
lixo1122lixo1122P8
P9
P10
lixo1122lixo1122P7
lixo1122lixo1122P6
---lixo1122P5
---lixo1122P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y) 
{ 
imprima(X); 
Z X; // Z 22
}
senão
{ 
imprima(Y); 
Z Y; 
}
}
principal
{
inteiro A, B, C;
A 22; 
B 11;
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8
P9
P1
P2
P3
P4
P5
P10
P9
P8
lixo1122lixo1122P8
2211221122P9
P10
lixo1122lixo1122P7
lixo1122lixo1122P6
---lixo1122P5
---lixo1122P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y) 
{ 
imprima(X); 
Z X; // Z 22
}
senão
{ 
imprima(Y); 
Z Y; 
}
}
principal
{
inteiro A, B, C;
A 22; 
B 11;
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8
P9
P1
P2
P3
P4
P5
P10
P9
P8
lixo1122lixo1122P8
221122221122P9
P10
lixo1122lixo1122P7
lixo1122lixo1122P6
---lixo1122P5
---lixo1122P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y) 
{ 
imprima(X); 
Z X; 
}
senão
{ 
imprima(Y); 
Z Y; 
}
}
principal
{
inteiro A, B, C;
A 22; 
B 11;
imprimeMaior(A,B,C);
imprima(C);
}
P6
P7
P8
P9
P8
P9
P1P2
P3
P4
P5
P10
P9
P8
lixo1122lixo1122P8
221122221122P9
P10
lixo1122lixo1122P7
lixo1122lixo1122P6
---lixo1122P5
---lixo1122P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
imprimeMaior(inteiro X, inteiro Y,ref inteiro Z)
{
se (X > Y) 
{ 
imprima(X); 
Z X; 
}
senão
{ 
imprima(Y); 
Z Y; 
}
}
principal
{
inteiro A, B, C;
A 22; 
B 11;
imprimeMaior(A,B,C);
imprima(C); //imprima(22)
}
P6
P7
P8
P9
P8
P9
P1
P2
P3
P4
P5
P10
P9
P8
lixo1122lixo1122P8
221122221122P9
---221122P9
lixo1122lixo1122P7
lixo1122lixo1122P6
---lixo1122P5
---lixo1122P4
---lixolixo22P3
---lixolixolixoP2
------P1
ZYXCBA
imprimeMaiorprincipalLinha
Em C, para que uma subrotina atue como um 
procedimento devemos declarar algo do tipo:
void imprime (int val)
{ 
printf( %d ,val);
}
Parâmetros de uma subrotina em C
Passados através da lista de parâmetros
Estes parâmetros podem ser cópia dos 
dados do programa (quando eles não serão 
alterados) ou pode-se permitir que a subrotina
altere os dados do programa diretamente.
Parâmetros de uma subrotina em C 
Exemplo
#include <stdio.h>
void ParImpar(int a)
{
int resto;
resto=a%2; 
if (resto==0) printf( par );
else printf( ímpar );
}
int main()
{
int x;
scanf( %d ,&x);
ParImpar(x);
return 0;
}
Parâmetros de uma subrotina em C 
Exemplo
#include <stdio.h>
void ParImpar(int a)
{
int resto;
resto=a%2; 
if (resto==0) printf( par );
else printf( ímpar );
}
int main()
{
int x;
scanf( %d ,&x);
ParImpar(x);
return 0;
}
Variáveis do main:
x
Parâmetros de uma subrotina em C 
Exemplo
#include <stdio.h>
void ParImpar(int a)
{
int resto;
resto=a%2; 
if (resto==0) printf( par );
else printf( ímpar );
}
int main()
{
int x;
scanf( %d ,&x);
ParImpar(x);
return 0;
}
Variáveis locais:
a (cópia da variável x)
resto
Parâmetros de uma subrotina em C 
Exemplo
Chamada por valor: Qualquer alteração feita no parâmetro não 
reflete em alteração no argumento.
Chamada por referência: Todas as alterações realizadas no 
parâmetro, refletem em alterações no argumento, ou seja, ambas as 
variáveis apontam para o mesmo endereço de memória. Para isso, é
necessário que seja passado o endereço do argumento e o 
parâmetro receba-o na forma de ponteiro. 
imprimeMaior(inteiro X,
inteiro Y,
ref inteiro Z)
{
se (X > Y) 
{ 
imprima(X); 
Z X; 
}
senão
{ 
imprima(Y); 
Z Y; 
}
}
void imprimeMaior(int X, int Y, int *Z)
{
if (X > Y) 
{ 
printf( %d ,X); 
*Z = X; 
}
else
{ 
printf( %d ,Y);
*Z = Y; 
}
}
principal
{
inteiro A, B, C;
A 22; 
B 11; 
imprimeMaior(A,B,C);
imprima(C); 
}
main()
{
int A, B, C;
A = 22; 
B = 11; 
imprimeMaior(A,B,&C);
printf( %d ,C);
}
É um tipo especial de procedimento
Retorna como resultado o valor calculado pela 
função, que deve ser do tipo básico definido.
A sintaxe de declaração de uma função é:
<tipo básico> <nome da função> (<lista de parâmetros formais>)
{
<declaração de variáveis locais>
<comandos>
retorne <valor de retorno>;
}
Tipo do dado a ser retornado 
como resultado da execução 
da função.
A sintaxe de declaração de uma função é:
<tipo básico> <nome da função> (<lista de parâmetros formais>)
{
<declaração de variáveis locais>
<comandos>
retorne <valor de retorno>;
}
Nome que identifique a ação a ser executada 
na função (sem espaços em branco!)
Ex.: calculaMedia
A sintaxe de declaração de uma função é:
<tipo básico> <nome da função> (<lista de parâmetros formais>)
{
<declaração de variáveis locais>
<comandos>
retorne <valor de retorno>;
}
Valores recebidos como parâmetro. 
Ex.: (A,B,20,30)
A sintaxe de declaração de uma função é:
<tipo básico> <nome da função> (<lista de parâmetros formais>)
{
<declaração de variáveis locais>
<comandos>
retorne <valor de retorno>;
}
Declaração das variáveis 
locais e sequencia de 
comandos para a realização 
da função.
A sintaxe de declaração de uma função é:
<tipo básico> <nome da função> (<lista de parâmetros formais>)
{
<declaração de variáveis locais>
<comandos>
retorne <valor de retorno>;
}
A função permite retornar um valor, resultado das ações 
nela programadas. Este valor deve ser do <tipo 
básico> declarado antes do nome da função.
Funções exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X 0)
{
Y X;
}
senão
{
Y - X; 
}
retorne Y;
}
principal
{
real A,D;
A -40;
D valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8
P9
P1
P2
P3
P4
P10 P10
P9
P8
P8
P7
P6
P5
P4
P3
P2
P1
YXDA
valorAbsolutoprincipal
Linha
Funções exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X 0)
{
Y X;
}
senão
{
Y - X; 
}
retorne Y;
}
principal
{
real A,D;
A -40;
D valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8
P9
P1
P2
P3
P4
P10 P10
P9
P8
P8
P7
P6
P5
P4
P3
P2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X 0)
{
Y X;
}
senão
{
Y - X; 
}
retorne Y;
}
principal
{
real A,D;
A -40;
D valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8
P9
P1
P2
P3
P4
P10 P10
P9
P8
P8
P7
P6
P5
P4
P3
--lixolixoP2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X 0)
{
Y X;
}
senão
{
Y - X; 
}
retorne Y;
}
principal
{
real A,D;
A -40;
D valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8
P9
P1
P2
P3
P4
P10 P10
P9
P8
P8
P7
P6
P5
P4
--lixo-40P3
--lixolixoP2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X 0)
{
Y X;
}
senão
{
Y - X; 
}
retorne Y;
}
principal
{
real A,D;
A -40;
D valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8
P9
P1
P2
P3
P4
P10 P10
P9
P8
P8
P7
P6
P5
--???-40P4
--lixo-40P3
--lixolixoP2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X 0)
{
Y X;
}
senão
{
Y - X; 
}
retorne Y;
}
principal
{
real A,D;
A -40;
D valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8
P9
P1
P2
P3
P4
P10 P10
P9
P8
P8
P7
P6
--40???-40P5
--???-40P4
--lixo-40P3
--lixolixoP2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X 0)
{
Y X;
}
senão
{
Y - X; 
}
retorne Y;
}
principal
{
real A,D;
A -40;
D valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8
P9
P1
P2
P3
P4
P10 P10
P9
P8
P8
P7
lixo-40???-40P6
--40???-40P5
--???-40P4
--lixo-40P3
--lixolixoP2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X 0) // (-40 0) 
{
Y X;
}
senão
{
Y - X; 
}
retorne Y;
}
principal
{
real A,D;
A -40;
D valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8
P9
P1
P2
P3
P4
P10
--40???-40P5
lixo-40???-40P6
P10
P9
P8
P8
lixo-40???-40P7
--???-40P4
--lixo-40P3
--lixolixoP2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X 0) // (-40 0)
{
Y X;
}
senão
{
Y - X; 
}
retorne Y;
}
principal
{
real A,D;
A -40;
D valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8
P9
P1
P2
P3
P4
P10
--40???-40P5
lixo-40???-40P6
P10
P9
P8
P8
lixo-40???-40P7
--???-40P4
--lixo-40P3
--lixolixoP2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X 0) // (-40 0)
{
Y X;
}
senão
{
Y - X; 
}
retorne Y;
}
principal
{
real A,D;
A -40;
D valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8
P9
P1
P2
P3
P4
P10
--40???-40P5
lixo-40???-40P6
P10
P9
40-40???-40P8
P8
lixo-40???-40P7
--???-40P4
--lixo-40P3
--lixolixoP2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X 0) // (-40 0)
{
Y X;
}
senão
{
Y - X; 
}
retorne Y;
}
principal
{
real A,D;
A -40;
D valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8
P9
P1
P2
P3
P4
P10
--40???-40P5
lixo-40???-40P6
P10
40-4040-40P9
40-40???-40P8
P8
lixo-40???-40P7
--???-40P4
--lixo-40P3
--lixolixoP2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X 0) // (-40 0)
{
Y X;
}
senão
{
Y - X; 
}
retorne Y;
}
principal{
real A,D;
A -40;
D valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8
P9
P1
P2
P3
P4
P10
--40???-40P5
lixo-40???-40P6
P10
40-4040-40P9
40-40???-40P8
P8
lixo-40???-40P7
--40-40P4
--lixo-40P3
--lixolixoP2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções exemplo
real valorAbsoluto ( real X )
{
real Y;
se (X 0) // (-40 0)
{
Y X;
}
senão
{
Y - X; 
}
retorne Y;
}
principal
{
real A,D;
A -40;
D valorAbsoluto(A);
imprima (D);
}
P5
P6
P7
P8
P8
P9
P1
P2
P3
P4
P10
--40???-40P5
lixo-40???-40P6
40-40P10
40-4040-40P9
40-40???-40P8
P8
lixo-40???-40P7
--40-40P4
--lixo-40P3
--lixolixoP2
----P1
YXDA
valorAbsolutoprincipal
Linha
Funções: retornam valor. São utilizadas para realizar 
uma operação e retornam alguma resposta relativa à 
operação realizada.
Exemplo:
int soma (int a, int b)
{
return (a+b);
}
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf( %d,%d,%d ,a,b,c);
return 0;
}
MemMemóóriaria
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf( %d,%d,%d ,a,b,c);
return 0;
}
MemMemóóriaria
25
50
75
a
b
c
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf( %d,%d,%d ,a,b,c);
return 0;
}
MemMemóóriaria
25
50
75
a
b
c
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf( %d,%d,%d ,a,b,c);
return 0;
}
MemMemóóriaria
25
50
75
a
b
c
a1
b1
&a
&b
MemMemóóriaria
25
50
75
a
b
c
a1
b1
aux25
&a
&b
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf( %d,%d,%d ,a,b,c);
return 0;
}
MemMemóóriaria
50
50
75
a
b
c
a1
b1
aux25
&a
&b
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf( %d,%d,%d ,a,b,c);
return 0;
}
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf( %d,%d,%d ,a,b,c);
return 0;
}
MemMemóóriaria
50
25
75
a
b
c
a1
b1
aux25
&a
&b
MemMemóóriaria
50
25
75
a
b
c
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf( %d,%d,%d ,a,b,c);
return 0;
}
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf( %d,%d,%d ,a,b,c);
return 0;
}
MemMemóóriaria
50
25
75
a
b
c
a1
b1
&b
&c
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf( %d,%d,%d ,a,b,c);
return 0;
}
MemMemóóriaria
a
b
c
a1
b1
aux25
&b
&c
50
25
75
MemMemóóriaria
75
a
b
c
a1
b1
aux25
&b
&c
50
75
75
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf( %d,%d,%d ,a,b,c);
return 0;
}
MemMemóóriaria
a
b
c
a1
b1
aux25
&b
&c
50
75
25
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf( %d,%d,%d ,a,b,c);
return 0;
}
#include <stdio.h>
void Troca(int *a1, int *b1)
{ 
int aux=*a1;
*a1=*b1;
*b1=aux;
}
int main()
{
int a=25, b=50, c=75;
Troca(&a,&b);
Troca(&b,&c);
printf( %d,%d,%d ,a,b,c);
return 0;
}
MemMemóóriaria
a
b
c
50
75
25
Variações na implementação de 
subrotinas em C
#includes.....
int Func1(int a)
{
........
}
main()
{
......
x=Func1(10);
.....
}
#includes.....
int Func1(int a); //protótipo
main()
{
......
x=Func1(10);
.....
}
int Func1(int a)
{
........
}
Exercícios
1) O que será impresso no programa abaixo?
#include <stdio.h>
void calculo (int *p, int *q)
{
*p = *p * 10;
*q = *q + 10;
}
int main()
{
int x = 2, y = 5;
calculo(&x,&y);
printf("%d - %d",x,y);
return 0;
}
Exercícios
2) Qual a saída do programa abaixo:
#include <stdio.h>
int calculo (int p, int q)
{
p = p * 10;
q = q + 10;
return(p + q);
}
int main()
{
int x = 2, y = 5;
printf( %d %d %d ,x,y,calculo(x,y));
return 0;
}
Exercícios
3) Qual a saída do programa abaixo:
#include <stdio.h>
int calculo (int p, int *q)
{
p = p * 10;
*q = *q + 10;
return(p);
}
int main()
{
int x = 2, y = 5, z;
z = calculo(x,&y);
printf( %d %d %d ,x,y,z);
return 0;
}
Exercícios
4) Qual a saída do programa abaixo:
#include <stdio.h>
int cal(int p, int *q, int *r)
{
p = p * 10;
*q = *q + 10;
*r = *r - 10;
return(p);
}
int main()
{
int x = 2, y = 5, z = 3, r;
r = cal(x,&y,&z);
printf( %d %d %d %d ,x,y,z,r);
return 0;
}
Subrotinas
DCC 120
REVISÃO: Forma Geral
A forma geral de uma subrotina é:
especificador_tipo nome ( lista parâmetros )
{
corpo da subrotina;
return xxx;
}
REVISÃO: Tipos de Subrotinas
procedimentos
void ImprimeSoma (int a, int b)
{ 
printf( %d , a+b); 
}
funções
int Soma (int a, int b)
{ 
return (a+b); 
}
REVISÃO: Como implementar Subrotinas
#includes.....
int Func1(int a)
{
........
}
main()
{
......
x=Func1(10);
.....
}
#includes.....
int Func1(int a); //protótipo
main()
{
......
x=Func1(10);
.....
}
int Func1(int a)
{
........
}
Escreva um programa que leia a matrícula de um aluno e suas três notas. Calcule a média 
desse aluno e mostre, ao final, a média calculada e uma mensagem "APROVADO" se a média 
for maior ou igual a 6 e "REPROVADO" caso contrário. O cálculo da média e as impressões 
devem ser feitos por um procedimento. Repita a operação até que uma matrícula negativa 
seja lida.
void media(float nota1, float nota2, float nota3)
{
float media;
media = (nota1 + nota2 + nota3) / 3;
printf("Media = %.2f\n", media);
if(media >= 6)
printf("APROVADO\n");
else
printf("REPROVADO\n");
}
int main()
{
int matricula;
float n1, n2, n3;
printf("Digite a matricula do aluno: ");
scanf("%d", &matricula);
while(matricula >= 0)
{
printf("Digite as 3 notas: ");
scanf("%f %f %f", &n1, &n2, &n3);
media(n1, n2, n3);
printf("Digite a matricula do aluno: ");
scanf("%d", &matricula);
}
return 0;
} 
Exemplo completo usando PROCEDIMENTO
int quadrado (int x)
{
return (x * x);
}
int main ()
{
int numero, res;
printf("Digite um numero inteiro: ");
scanf("%d", &numero);
while(numero != 0)
{
res = quadrado(numero);
printf ("O quadrado de %d eh %d.\n", numero, res);
printf("Digite um numero inteiro: ");
scanf("%d", &numero);
}
return 0;
}
Exemplo completo usando Função
Escreva uma programa que calcule e imprima o quadrado de um número. O cálculo 
deve ser feito por uma função. Repita a operação até que seja lido um número igual 
a zero.
Exercícios
1) Escreva um procedimento que receba como 
parâmetro dois valores inteiros n1 e n2 e imprima 
o intervalo fechado entre eles, do menor para o 
maior.
Por exemplo: se n1 = 2 e n2 = 5, o procedimento 
irá imprimir 2, 3, 4, 5.
2) Faça um procedimento que receba por parâmetro o 
tempo de duração de um experimento expresso 
em segundos e imprima na tela esse mesmo 
tempo em horas, minutos e segundos. 
3) Faça uma função que receba por parâmetro o raio 
de uma esfera e calcula o seu volume:
v = (4 * PI * R3) /3. 
4) Faça uma função que receba a idade de uma 
pessoa em anos, meses e dias e retorna essa 
idade expressa em dias.
Exercícios
5) Faça um programa que apresente o seguinte Menu para o usuário:
Escolha uma opção de cálculo para dois números:
1) Soma
2) Produto
3) Quociente
4) Sair
Opção:__ 
O Menu acima deve ser apresentado para o usuário enquantoele não 
escolher a opção 4 (sair do programa). O usuário fornecerá 2 
números se escolher as opções de cálculo 1, 2 ou 3. Para cada 
opção de cálculo deve existir (obrigatoriamente) uma função definida 
(soma, produto e quociente dos dois números fornecidos pelo 
usuário). O resultado do cálculo deve ser escrito na tela.
Exercícios
6) Idem ao exercício 5, agora com o seguinte Menu
Escolha uma opção de cálculo para um número:
a) Fatorial
b) Exponencial
c) Raiz quadrada
d) Sair
Opção: __ 
Nas opções b e c pode-se utilizar funções predefinidas do C.