Fundamentos de Programação

Subprogramação
Baseado nos materiais dos
Prof. Ms. Ricardo Theis Geraldi
Prof. Dr Yandre Maldonado

Prof. Nilton Luiz Queiroz Jr

Subprogramação
● São blocos de instruções que realizam tarefas específicas;
● É uma ferramenta que contribui com a tarefa de programar
○ Facilita a estruturação do programa;
○ Melhora a legibilidade do código;
○ Permite a divisão do problema a ser resolvido;
○ Reduz a quantidade de código escrito;
● Subprogramas podem ser dependentes uns dos outros
○ Porém tal dependência deve ser a mínima possível;
● A subprogramação tende a facilitar a solução de um problema
○ Atenção voltada apenas a uma parte do problema;
Subprogramação
● Podemos dividir subprogramas em dois tipos:
○ Procedimentos;
■ Não retornam valores
○ Funções;
■ Retornam valores

Obs: A linguagem C em específico possui somente funções, porém,

iremos aqui chamar um tipo específico de função (“funções void”) como
procedimento por seu comportamento similar;
Procedimentos
● Quando se faz necessário que uma rotina seja repetida dentro da solução
de um problema;
● Para se criar um procedimento é necessário:
○ Um identificador;
○ Uma lista de parâmetros;
○ As ações que serão executadas;
■ Tais ações formam o corpo do procedimento;
Procedimentos
● Suponha que você deseja escrever na tela os valores de 1 a N, e depois os
valores de 1 a M;
● Com o que foi visto até agora, seria necessário escrever dois laços de
repetição em seguida:
for(i=1;i<=n;i++){
printf("%d\n",i);
}
for(i=1;i<=m;i++){
printf("%d\n",i);
}
Procedimentos
● Note que os dois laços são praticamente os mesmos, só se altera o valor
final;
● Assim, podemos usar um procedimento para tal fim;
Procedimentos em C
● Para a criação de procedimentos em C usamos a seguinte sintaxe:

void <nome do procedimento> ( <par1>,<par2>, … , <parN>){

<instr1>;
…
<instrN>;
}
Procedimentos em C
● Onde:
○ void é uma palavra reservada da linguagem C;
○ <nome do procedimento> é o identificador do procedimento;
■ Uma vez usado o identificado para um procedimento, variáveis não podem usar
esse identificador;
○ <par1>, <par2>, …, <parN> são parâmetros do procedimento;
■ Esses parâmetros são variáveis que podem ser usadas no corpo do procedimento,
sua declaração é igual a usada para variáveis;
○ <instr1>, …, <instrN> são as instruções que formam o corpo do procedimento;
■ Dentre essas instruções podem estar declarações de variáveis, chamadas de outros
procedimentos, laços de repetição, etc.
Exemplos

void mostra_ponto(int x, int y){

printf("( %d, %d )\n",x,y);
}

void mostra_media(float a, float b){

float m;
m = (a+b)/2.0;
printf("media entre %f e %f = %f ",a,b,m);
}
Procedimentos
● Suponha que você deseja escrever na tela os valores de 1 a N, e depois os
valores de 1 a M;
#include <stdio.h> #include <stdio.h>
void print_ate(int limite){ int main(){
int i; int n,m,i;
for(i=1;i<=limite;i++){ scanf("%d",&n);
printf("%d\n",i); scanf("%d",&m);
} for(i=1;i<=n;i++){
} printf("%d\n",i);
int main(){ }
int n,m; for(i=1;i<=m;i++){
scanf("%d",&n); printf("%d\n",i);
scanf("%d",&m); }
print_ate(n); }
print_ate(m);
}
Execução de um procedimento
#include <stdio.h>
void print_ate(int limite){
int i;
for(i=1;i<=limite;i++){
printf("%d\n",i);
}
}
int main(){
int n,m;
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
Execução de um procedimento
#include <stdio.h> ● A execução do programa sempre
void print_ate(int limite){
int i;
começa pela primeira linha da
for(i=1;i<=limite;i++){ função main;
printf("%d\n",i);
}
}
int main(){
int n,m;
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n

m
Execução de um procedimento
#include <stdio.h>
void print_ate(int limite){
int i;
for(i=1;i<=limite;i++){
printf("%d\n",i);
}
}
int main(){
int n,m;
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m
Execução de um procedimento
#include <stdio.h>
void print_ate(int limite){
int i;
for(i=1;i<=limite;i++){
printf("%d\n",i);
}
}
int main(){
int n,m;
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m 5
Execução de um procedimento
● Um programa composto por
#include <stdio.h>
void print_ate(int limite){ subprogramas é executado
int i;
for(i=1;i<=limite;i++){
normalmente até que se alcance
printf("%d\n",i); algum subprograma;
}
}
● No momento que o subprograma é
int main(){ alcançado, a lista de parâmetros é
int n,m;
scanf("%d",&n);
limite 3 transferida;
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m 5
Execução de um procedimento
#include <stdio.h>
void print_ate(int limite){ ● Assim que um procedimento ou função
int i; é alcançado, o fluxo de execução é
desviado para a primeira linha de código
for(i=1;i<=limite;i++){
printf("%d\n",i);
} do procedimento (ou função)
} limite 3
int main(){
int n,m; i
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m 5
Execução de um procedimento
#include <stdio.h>
● O subprograma é executado como se
void print_ate(int limite){ fosse parte do programa;
int i;
for(i=1;i<=limite;i++){
● A lista de parâmetros de um
printf("%d\n",i); subprograma pode ser usada no corpo
}
}
limite 3 do mesmo;
int main(){
int n,m; i 1
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m 5
Execução de um procedimento
#include <stdio.h>
void print_ate(int limite){
int i;
for(i=1;i<=limite;i++){
printf("%d\n",i);
}
} limite 3
int main(){
int n,m; i 1
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m 5
Execução de um procedimento
#include <stdio.h>
void print_ate(int limite){
int i;
for(i=1;i<=limite;i++){
printf("%d\n",i);
}
} limite 3
int main(){
int n,m; i 2
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m 5
Execução de um procedimento
#include <stdio.h>
void print_ate(int limite){
int i;
for(i=1;i<=limite;i++){
printf("%d\n",i);
}
} limite 3
int main(){
int n,m; i 3
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m 5
Execução de um procedimento
#include <stdio.h>
void print_ate(int limite){
int i;
for(i=1;i<=limite;i++){
printf("%d\n",i);
}
} limite 3
int main(){
int n,m; i 4
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m 5
Execução de um procedimento
#include <stdio.h> ● O laço de repetição é
void print_ate(int limite){ encerrado, e como não existe
mais nada no procedimento, a
int i;
for(i=1;i<=limite;i++){
printf("%d\n",i); execução voltará a seu fluxo
normal;
}
}
int main(){ ○ Na linha imediatamente
int n,m;
scanf("%d",&n); abaixo do procedimento
scanf("%d",&m); chamado;
print_ate(n);
print_ate(m); ● Com o programa de volta a
n 3
} função main, as variáveis
m 5 limite e i deixam de existir;
Execução de um procedimento
● Novamente um subprograma é
chamado
#include <stdio.h>
void print_ate(int limite){
int i; ● Os parâmetros da chamada do
for(i=1;i<=limite;i++){
printf("%d\n",i); procedimento são novamente
} transferidos;
}
int main(){
int n,m; limite 5
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m 5
Execução de um procedimento
#include <stdio.h>
● O procedimento é novamente
void print_ate(int limite){ executado, porém com os novos
int i;
for(i=1;i<=limite;i++){ parâmetros;
printf("%d\n",i);
}
} limite 5
int main(){
int n,m; i
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
n 3
}
m 5
Execução de um procedimento
#include <stdio.h>
void print_ate(int limite){
int i;
for(i=1;i<=limite;i++){
printf("%d\n",i);
}
} limite 5
int main(){
int n,m; i 1
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m 5
Execução de um procedimento
#include <stdio.h>
void print_ate(int limite){
int i;
for(i=1;i<=limite;i++){
printf("%d\n",i);
}
} limite 5
int main(){
int n,m; i 1
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m 5
Execução de um procedimento
#include <stdio.h>
void print_ate(int limite){
int i;
for(i=1;i<=limite;i++){
printf("%d\n",i);
}
} limite 5
int main(){
int n,m; i 2
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m 5
Execução de um procedimento
#include <stdio.h>
void print_ate(int limite){
int i;
for(i=1;i<=limite;i++){
printf("%d\n",i);
}
} limite 5
int main(){
int n,m; i 3
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m 5
Execução de um procedimento
#include <stdio.h>
void print_ate(int limite){
int i;
for(i=1;i<=limite;i++){
printf("%d\n",i);
}
} limite 5
int main(){
int n,m; i 4
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m 5
Execução de um procedimento
#include <stdio.h>
void print_ate(int limite){
int i;
for(i=1;i<=limite;i++){
printf("%d\n",i);
}
} limite 5
int main(){
int n,m; i 5
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m 5
Execução de um procedimento
#include <stdio.h>
void print_ate(int limite){
int i;
for(i=1;i<=limite;i++){
printf("%d\n",i);
}
} limite 5
int main(){
int n,m; i 6
scanf("%d",&n);
scanf("%d",&m);
print_ate(n);
print_ate(m);
}
n 3

m 5
Execução de um procedimento
#include <stdio.h> ● O procedimento se encerra, e a
void print_ate(int limite){ execução volta novamente a função
int i;
for(i=1;i<=limite;i++){ main;
}
printf("%d\n",i); ● Novamente as variáveis do
} procedimento são excluídas
int main(){
int n,m;
● Neste exemplo, não existem mais
scanf("%d",&n); instruções a serem executadas, assim
scanf("%d",&m);
print_ate(n);
o programa se encerra.
print_ate(m);
}
n 3

m 5
Subprogramação
● Outra maneira de subprogramação são as funções;
● Da mesma forma que procedimentos, quando se faz necessário que uma
rotina seja executada diversas vezes;
● Uma função pode retornar valor, assim, pode-se atribuir a uma variável o
valor retornado pela função;
● Procedimentos não retornam valores;
○ Veremos mais pra frente que eles podem alterar os valores de seus parâmetros;
Funções
● Para se criar uma função é necessário:
○ O tipo de dado do valor retornado;
○ Um identificador;
○ Uma lista de parâmetros;
○ As ações que serão executadas;
■ Tais ações formam o corpo da função;
Funções em C
● Para a criação de funções em C usamos a seguinte sintaxe:

<tipo de dado retornado> <nome da função> ( <par1>,<par2>, … ,

<parN>){
<instr1>;
…
<instrN>;
}
Funções em C
● Onde:
○ <tipo de dado> é o tipo de dado a ser retornado pela função;
○ <nome da função> é o identificador da função;
○ <par1>, <par2>, …, <parN> são parâmetros da função;
○ <instr1>, …, <instrN> são as instruções que formam o corpo da função;
■ Dentre essas instruções podem estar declarações de variáveis, chamadas de outros
procedimentos, laços de repetição, etc.
■ Existe uma instrução especial para funções que é a instrução return;
● Quando executada essa instrução interrompe a execução da função faz com
que a função passe a valer o valor logo a sua frente
● Exemplos:
○ return 3.14;
○ return x;
● O tipo do valor a frente da instrução return deve ser do mesmo tipo da
função;
Exemplo
● Faça um algoritmo para calcular a combinação (análise combinatória) de
N elementos tomados P a P. Sabe-se que isto é possível através da
seguinte expressão:
Exemplo
● Note que para resolver o problema precisaríamos calcular o fatorial 3
vezes;
○ Calcular o fatorial de N e armazenar em uma variável;
○ Calcular o fatorial de P e armazenar em uma variável;
○ Calcular o fatorial de N-P e armazenar em uma variável;
○ Calcular a expressão FatN/(FatP*FatNP)
Exemplo
#include <stdio.h>
int main(){ #include <stdio.h>
int n,p,i,comb; int fat(int x){
int fat_n, fat_p, fat_np; int i,f;
scanf("%d",&n); f=1;
scanf("%d",&p); for(i=1;i<=x;i++){
fat_n=1; f*=i;
for(i=1;i<=n;i++){ }
fat_n*=i; return f;
} }
fat_p=1; int main(){
for(i=1;i<=p;i++){ int n,p,comb,fat_n,fat_p,fat_np;
fat_p*=i; scanf("%d",&n);
} scanf("%d",&p);
fat_np=1; fat_n=fat(n);
for(i=1;i<=(n-p);i++){ fat_p=fat(p);
fat_np*=i; fat_np=fat(n-p)
} comb=fat_n/(fat_p*fat_np);
comb = fat_n/(fat_p*fat_np); printf("%d",comb);
printf("%d",comb); }
}
Execução de uma função
#include <stdio.h> ● Programa iniciado na função
int fat(int x){
int i,f;
main
f=1;
for(i=1;i<=x;i++){
f*=i;
} n
return f;
}
int main(){
p
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb
scanf("%d",&p);
fat_n=fat(n); fat_n
fat_p=fat(p);
fat_np=fat(n-p) fat_p
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb
scanf("%d",&p);
fat_n=fat(n); fat_n
fat_p=fat(p);
fat_np=fat(n-p) fat_p
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb
scanf("%d",&p);
fat_n=fat(n); fat_n
fat_p=fat(p);
fat_np=fat(n-p) fat_p
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np
}
Execução de uma função
#include <stdio.h>
int fat(int x){
● Em funções, são também usados
int i,f; locais para armazenar o valor
f=1;
for(i=1;i<=x;i++){
que será retornado;
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb
scanf("%d",&p);
fat_n=fat(n); fat_n
fat_p=fat(p);
fat_np=fat(n-p) fat_p x 4
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f
scanf("%d",&p);
fat_n=fat(n); fat_n i
fat_p=fat(p);
fat_np=fat(n-p) fat_p x 4
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 1
scanf("%d",&p);
fat_n=fat(n); fat_n i
fat_p=fat(p);
fat_np=fat(n-p) fat_p x 4
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 1
scanf("%d",&p);
fat_n=fat(n); fat_n i 1
fat_p=fat(p);
fat_np=fat(n-p) fat_p x 4
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 1
scanf("%d",&p);
fat_n=fat(n); fat_n i 1
fat_p=fat(p);
fat_np=fat(n-p) fat_p x 4
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 2
scanf("%d",&p);
fat_n=fat(n); fat_n i 2
fat_p=fat(p);
fat_np=fat(n-p) fat_p x 4
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 6
scanf("%d",&p);
fat_n=fat(n); fat_n i 3
fat_p=fat(p);
fat_np=fat(n-p) fat_p x 4
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 24
scanf("%d",&p);
fat_n=fat(n); fat_n i 4
fat_p=fat(p);
fat_np=fat(n-p) fat_p x 4
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 24
scanf("%d",&p);
fat_n=fat(n); fat_n i 5
fat_p=fat(p);
fat_np=fat(n-p) fat_p x 4
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat 24
}
Execução de uma função
#include <stdio.h>
int fat(int x){
● Quando a execução retorna ao
int i,f; ponto de chamada, o valor
f=1;
for(i=1;i<=x;i++){
retornado pela função é
f*=i; substituído pela chamada da
}
return f;
n 4 função na expressão
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb
scanf("%d",&p);
fat_n=fat(n); fat_n 24
fat_p=fat(p);
fat_np=fat(n-p) fat_p
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat 24
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb
scanf("%d",&p);
fat_n=fat(n); fat_n 24
fat_p=fat(p);
fat_np=fat(n-p) fat_p x 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f
scanf("%d",&p);
fat_n=fat(n); fat_n 24 i
fat_p=fat(p);
fat_np=fat(n-p) fat_p x 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 1
scanf("%d",&p);
fat_n=fat(n); fat_n 24 i
fat_p=fat(p);
fat_np=fat(n-p) fat_p x 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 1
scanf("%d",&p);
fat_n=fat(n); fat_n 24 i 1
fat_p=fat(p);
fat_np=fat(n-p) fat_p x 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 1
scanf("%d",&p);
fat_n=fat(n); fat_n 24 i 1
fat_p=fat(p);
fat_np=fat(n-p) fat_p x 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 2
scanf("%d",&p);
fat_n=fat(n); fat_n 24 i 2
fat_p=fat(p);
fat_np=fat(n-p) fat_p x 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 2
scanf("%d",&p);
fat_n=fat(n); fat_n 24 i 3
fat_p=fat(p);
fat_np=fat(n-p) fat_p x 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat 2
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb
scanf("%d",&p);
fat_n=fat(n); fat_n 24
fat_p=fat(p);
fat_np=fat(n-p) fat_p 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat 2
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb
scanf("%d",&p);
fat_n=fat(n); fat_n 24
fat_p=fat(p);
fat_np=fat(n-p) fat_p 2 x 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f
scanf("%d",&p);
fat_n=fat(n); fat_n 24 i
fat_p=fat(p);
fat_np=fat(n-p) fat_p 2 x 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 1
scanf("%d",&p);
fat_n=fat(n); fat_n 24 i
fat_p=fat(p);
fat_np=fat(n-p) fat_p 2 x 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 1
scanf("%d",&p);
fat_n=fat(n); fat_n 24 i 1
fat_p=fat(p);
fat_np=fat(n-p) fat_p 2 x 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 1
scanf("%d",&p);
fat_n=fat(n); fat_n 24 i 1
fat_p=fat(p);
fat_np=fat(n-p) fat_p 2 x 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 2
scanf("%d",&p);
fat_n=fat(n); fat_n 24 i 2
fat_p=fat(p);
fat_np=fat(n-p) fat_p 2 x 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb f 2
scanf("%d",&p);
fat_n=fat(n); fat_n 24 i 3
fat_p=fat(p);
fat_np=fat(n-p) fat_p 2 x 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np fat 2
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb
scanf("%d",&p);
fat_n=fat(n); fat_n 24
fat_p=fat(p);
fat_np=fat(n-p) fat_p 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np 2 fat 2
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb 6
scanf("%d",&p);
fat_n=fat(n); fat_n 24
fat_p=fat(p);
fat_np=fat(n-p) fat_p 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np 2
}
Execução de uma função
#include <stdio.h>
int fat(int x){
int i,f;
f=1;
for(i=1;i<=x;i++){
f*=i;
} n 4
return f;
}
int main(){
p 2
int n,p,comb,fat_n,fat_p,fat_np;
scanf("%d",&n); comb 6
scanf("%d",&p);
fat_n=fat(n); fat_n 24
fat_p=fat(p);
fat_np=fat(n-p) fat_p 2
comb=fat_n/(fat_p*fat_np);
printf("%d",comb); fat_np 2
}
Execução de uma função
● Observe que na linha:
○ fat_np=fat(n-p);

A variável x foi associada ao valor de n-p. Ou seja, primeiro foi resolvida a

expressão n-p e depois ocorreu a associação;
○ No exemplo, n-p=2 assim, foi novamente calculado o fatorial de 2;
● Também é possível utilizar subprogramas em expressões;
○ Poderiamos fazer:
■ comb = fat(n)/(fat(p) * fat(n-p));
○ Quando as funções são utilizadas junto a outras operações (como soma, multiplicação e
etc) elas têm precedência maior, ou seja, antes de realizar tais operações, é feita a
chamada da função.
Subprogramas
● Observações
○ Subprogramas não podem ter o mesmo nome de variáveis;
○ Subprogramas deve estar fisicamente localizados antes de todas suas chamadas;
Exercícios
1. Faça um procedimento que receba um valor a e um valor b e escreva
todos números no intervalo [a,b], e faça uma chamada do procedimento
para valores informados pelo usuário.
2. Faça um procedimento que receba um número e imprima a tabuada do
número recebido, e faça uma chamada do procedimento para o valor
informado pelo usuário.
3. Use o procedimento do exercício dois para imprimir as tabuadas de 1 a
10.
Exercícios
4. Faça uma função que receba os valores x1, y1 e x2, y2 pontos cartesianos e
calcule a distância euclidiana entre os pontos. Faça uma chamada da
função que receba como parâmetros os valores informados pelo usuário
e retorne o valor em uma variável.
5. Faça uma função que receba uma base B e um expoente E e calcule B E
sendo E inteiro. Utilize a função para calcular Xy com x e y informados
pelo usuário
6. Faça uma função que receba x e y inteiros e calcule:

F(x,y) = xy+yx
Dica: use a função do exercício 3 para o cálculo.