AGRUPAMENTO DE ESCOLAS DE SANTA COMBA DO

CURSO PROFISSIONAL DE TCNICO DE GESTO E PROGRAMAO DE SISTEMAS

INFORMTICOS
2012-2015
PROGRAMAO E SISTEMAS DE INFORMAO

MDULO 3 Mecanismos de Controlo de Execuo (48 aulas/45min)

Objetivos do mdulo:

Adquirir a noo de subprograma;

Conhecer as regras de declarao de subprogramas;

Conhecer as regras de execuo de subprogramas;

Utilizar corretamente parmetros;

Distinguir os diferentes tipos de subprogramas;

Elaborar programas com recurso a subprogramas;

Conhecer as regras para a criao de bibliotecas de subprogramas;

Conhecer os mecanismos de utilizao de bibliotecas de subprogramas;

Contedos do mdulo:

Variveis globais e locais;

Passagem por Parmetros (por valor e por referncia);

Estrutura do subprograma;

Retorno de valores;

Recursividade;

Construo de Bibliotecas de funes;

Verso C

Estrutura de um programa

Como j sabemos do mdulo anterior um programa em C tem a seguinte estrutura:

Exemplo-1
#include <stdio.h>
int main(int argc,char *argv[])
{
printf(Ol mundo\n);
return 1;
}

alunosnet@gmail.com alunosnet.pt.vu Pgina 1 de 9

 Resumindo: primeiro as instrues do pr-processador (#include e/ou #define) depois a main e dentro desta as
instrues.

Este mtodo de programar muito limitado e no pode ser aplicado no desenvolvimento de aplicaes complexas,
alm disso no permite a reutilizao do cdigo, algo fundamental para permitir a colaborao na programao.

Assim este mdulo introduz a criao de funes/instrues criadas pelo programador.

Uma funo um grupo de instrues que so executadas quando so chamadas num determinado ponto do
programa. O formato o seguinte:

tipo_dados nome(valor,valor,){
Instrues;
}

Em que:
tipo_dados - refere-se ao tipo de dados devolvido pela funo
nome - um identificador, o nome atribudo funo
valor - so valores passados, ou fornecidos funo, podem no existir
instrues - so os comandos que so executados dentro da funo

Exemplo-2
#include <stdio.h>

int soma(int n1,int n2)

{
int r; n1 e n2 recebem os valores passados, neste
r=n1+n2;
exemplo 5 e 3.
return r;
} Esta linha termina a execuo do cdigo da
funo e devolve o valor da varivel r
int main(int argc,char *argv[])
{
int z;
Quando a execuo do programa chega a
z=soma(5,3); este ponto salta para dentro do cdigo da
A varivel z guarda printf(Soma %d\n,z); funo chamada.
o valor devolvido
pela funo return 1;
}

Estudando detalhadamente a execuo do cdigo podemos dizer que:

1. A execuo comea na funo main;

2. Depois de definir a varivel z a execuo chega linha z=soma(5,3);
3. Nessa linha a execuo na funo main para espera que a funo soma faa o que tem a fazer;
4. Assim a funo soma chamada e as variveis n1 e n2 so declaradas e inicializadas com 5 e 3
respetivamente.
5. Estas variveis so tambm chamadas de parmetros;

alunosnet@gmail.com alunosnet.pt.vu Pgina 2 de 9

 6. Dentro da funo declaramos outra varivel (int r);
7. Esta varivel s pode ser utilizada dentro da funo onde declarada;
8. Depois executada a soma e o resultado guardado na varivel r;
9. Por fim termina a execuo da funo com a instruo return;
10. Mas como estamos dentro da funo soma que, por sua vez, foi chamada a partir da funo main o
programa no termina, uma vez que a execuo volta para o ponto onde tinha parado na funo main;
11. Nessa linha guardamos o valor devolvido pela funo na varivel z, que local funo main e por isso no
pode ser utilizada dentro de outra funo;
12. Por fim temos o printf e outro return;
13. Na funo main o return termina o programa uma vez que terminada a funo main no existe mais
nenhuma funo a executar e a execuo volta ao sistema operativo.

Muito importante:
preciso deixar bem claro ao que acontece sempre que uma funo chamada.
Quando um programa executado a primeira funo a ser chamada a main. No computador, sempre que
uma funo chamada, ela colocada no topo de uma pilha de funes a serem executadas, ou seja, a main est na
base dessa pilha e sempre que se chama outra funo essa colocada sobre a main ou sobre a funo que a chamou.
Sempre que o computador encontra a funo return para a execuo dentro da funo e retira da pilha essa funo.
O modo como o computador sabe para onde deve voltar processa-se de modo muito simples, antes de saltar
para dentro da funo a posio de memria de retorno guardada numa rea de memria denominada stack,
tambm nesta parte da memria em que so declaradas as variveis que so declaradas dentro da funo.

Situao 1:
Pilha de funes
Execuo dentro da funo main

main()

Situao 2: Pilha de funes

Durante a execuo na funo main chamada a funo soma.

Nesta situao, a nica maneira de parar a execuo do programa

terminando as duas funes, um programa s termina quando no existe
nenhuma funo a ser executada. Tambm no existe nenhuma maneira de
terminar a funo main sem antes terminar a funo soma. soma()

main()

alunosnet@gmail.com alunosnet.pt.vu Pgina 3 de 9

Situao 3:

Durante a execuo da funo soma executada a funo return, Pilha de funes

sendo retirada da memria a funo soma e voltando a execuo para a
linha onde esta tinha sido chamada. A memria que tinha sido utilizada
com as variveis desta funo libertada e a informao que estas tinham
perdida.

main()

Argumentos

Como j vimos as funes podem receber valores, o modo como se processa muito simples, quando
definimos a funo indicamos entre parntesis o nome das variveis locais que vo receber esses valores. Por
exemplo:

Exemplo-3a
#include <stdio.h>
#include psi_tools.h
Os argumentos recebem os valores pela
void mostrar(int x,int y,char *texto) mesma ordem em que so passados:
{ x 5
goto_xy(x,y); y 1
printf(%s,texto); texto Ol mundo
return;
}
int main(int argc,char *argv[])
{
mostrar(5,1,Ol mundo);
return 1; Chama a funo e passa os valores
} entre parntesis

Exemplo-3b

void mostrar(int x,int y,char *texto)

{

}

int main(int argc,char *argv[])

{
Int c,l;
c=5;
l=1;
mostrar(c,l,Ol mundo);
return 1;
}

alunosnet@gmail.com alunosnet.pt.vu Pgina 4 de 9

Nestes exemplos os argumentos so passados por valor, o que significa que os argumentos recebem os valores no
ficando com nenhuma ligao aos dados ou variveis que so utilizadas quando a funo chamada.

Isto quer dizer que se as variveis forem alteradas dentro das funes nada acontece s variveis que tinham os
dados originais que lhe foram passados.

Comparando este exemplo com o anterior podemos verificar que quando uma funo no devolve nenhum valor o
tipo de dados da funo void e o return no tem nada a devolver.

Exemplo-4
#include <stdio.h>
int par(int x)
2
{
x=x%2;
3 if(x==0)
return 1;
else
return 0;
}
int main(int argc,char *argv[]) 1.Quanto a funo par chamada n tem o valor 5
{
int n=5; 2.Dentro da funo par o argumento x recebe o
if(par(n)) 1
valor 5
printf(PAR\n);
else 3.Apesar de x ser alterado no afeta a varivel n que
printf(IMPAR\n); tinha o valor original, esta continua a ter 5
return 1;
}

Passagem por referncia

Por vezes necessrio devolver mais do que um valor, ou pretendemos alterar um dos parmetros utilizados, assim
passamos os argumentos por referncia.

Exemplo-5
#include <stdio.h>
void troca(int n1,int n2)
{
int t;
t=n1;
n1=n2;
n2=t;
return ;
}
int main(int argc,char *argv[])
{
int x=2,y=5;
troca(x,y);
printf(%d - %d,x,y);
return 1;
}

alunosnet@gmail.com alunosnet.pt.vu Pgina 5 de 9

Se executarmos o exemplo anterior podemos verificar que as variveis x e y mantm o mesmo valor aps a execuo
da funo, isto porque utilizamos a passagem por valor.

Exemplo-6
#include <stdio.h>
void troca(int &n1,int &n2)
{ Colocando um & antes de cada parmetro
int t; este passa a receber o endereo da varivel
t=n1; utilizada quando a funo chamada e assim
n1=n2;
qualquer alterao no valor do parmetro vai
n2=t;
afetar tambm a varivel
return ;
}
int main(int argc,char *argv[])
{
int x=2,y=5;
troca(x,y);
printf(%d - %d,x,y);
return 1;
}
Assim com esta alterao ao alterar o valor de n1 e n2 dentro da funo troca alteramos tambm os valores de x e y
na funo main.

Outro mtodo de definir e utilizar passagem por referncia pode ser o do exemplo seguinte:

Exemplo-7
#include <stdio.h>
void troca(int *n1,int *n2)
{ Colocando um * antes de cada parmetro
int t; definimos um ponteiro assim quando
t=*n1; chamamos a funo temos de passar um
*n1=*n2;
endereo para a varivel com um &.
*n2=t;
return ; De notar os * antes das variveis dentro da
} funo.
int main(int argc,char *argv[])
{
int x=2,y=5;
troca(&x,&y);
printf(%d - %d,x,y);
return 1;
}
claro que para um parmetro passado por referncia no podemos utilizar uma constante.

Variveis globais e locais

Olhando para o exemplo anterior podemos verificar que todas as variveis esto definidas dentro de funes, umas
na funo main outras na funo troca.

A este tipo de variveis d-se o nome de variveis locais, ou seja, so variveis que s existem dentro da funo
onde definida.

alunosnet@gmail.com alunosnet.pt.vu Pgina 6 de 9

Se na funo main tentarmos alterar o valor da varivel t, que foi declarada dentro da funo troca, o compilador d
um erro a indicar que a varivel no foi declarada.

Tambm muito importante lembrar que estas variveis so destrudas quando a funo termina, perdendo, assim,
os dados que continham.

Alm de variveis locais podemos ter variveis globais, estas so declaradas fora das funes e podem ser utilizadas
em qualquer parte do programa.

A utilizao de variveis globais deve ser limitada ao mnimo necessrio, pois so uma possvel fonte de problemas
difceis de detetar.

Variveis static

Exemplo-8
#include <stdio.h>
#include <conio.h>
void mostrar_contagem(void) Varivel local por isso quando a funo
{
termina torna a ser redefinida.
int t=0;

t++;
printf("Contagem em %d\n",t);
return;
}
int main(int argc,char *argv[])
{
int i;

for(i=0;i<5;i++)
mostrar_contagem();
return 1;
}

Este exemplo mostra sempre o valor 1 no ecr.

Exemplo-9
#include <stdio.h>
#include <conio.h>
void mostrar_contagem(void) Varivel local mas uma varivel static por isso
{
s definida uma vez, a primeira vez que a
Static int t=0;
funo executada. Assim mantm o valor
t++; da til execuo.
printf("Contagem em %d\n",t);
return;
}

Com o modificador static definimos variveis locais que s so definidas na primeira que a funo executada no
perdendo os dados quando a funo termina. Assim com esta alterao aparece 1,2,3,4,5.

alunosnet@gmail.com alunosnet.pt.vu Pgina 7 de 9

Prottipos de funes

Exemplo-10
#include <stdio.h>
#include <conio.h>
void mostrar_menu(void) Cdigo da funo aparece antes do cdigo da
{
main
printf("1.Abrir\n2.Fechar\n3.Sair\n");

return;
}

int main(int argc,char *argv[])

{

mostrar_menu();

getch();
return 1;
}

At agora todas as funes que utilizamos so criadas antes da funo main, isto devesse ao facto de que durante a
compilao do programa o compilador tem de conhecer a funo antes de esta ser chamada, da que os include
dos header files esto tambm no incio do programa.

Quando os programas comeam a ser grandes natural querer manter a main no local fcil de encontrar, assim
podemos definir s a funo antes da main e inserir o cdigo da funo depois, o modo como definimos as funes
atravs de prottipos das funes.

Exemplo-11
#include <stdio.h>
#include <conio.h>
void mostrar_menu(void); Prottipo da funo, s o cabealho, permite
ao compilador conhecer o valor de retorno e
int main(int argc,char *argv[])
{ os parmetros.

mostrar_menu();

getch();
return 1;
}
void mostrar_menu(void) Cdigo da funo j pode estar depois da
{ main permitindo um rpido acesso a esta.
printf("1.Abrir\n2.Fechar\n3.Sair\n");

return;
}

alunosnet@gmail.com alunosnet.pt.vu Pgina 8 de 9

Recursividade

Em C, e na maior parte das linguagens de programao, as funes podem se chamar a si prprias. Assim uma funo
que utiliza a recursividade uma funo cujo seu prprio cdigo invoca a funo.

Um exemplo de recursividade para calcular uma potncia.

Exemplo-12
#include <stdio.h>
#include <conio.h>
int potencia(int base,int expoente) Recursividade dentro da funo potencia
{ chamamos a funo potencia
int resultado;

if(expoente==1) return base;

else resultado=base*potencia(base,expoente-1);
return resultado;
}
int main(int argc,char *argv[])
{

printf("2 elevado a 10 = %d",potencia(2,10));

return 1;
}

Header files

Agora que sabemos como criar funes podemos juntar as funes em bibliotecas de funes que depois podemos
reutilizar em diferentes programas.

Para isso criamos um ficheiro com a extenso h que tem a mesma estrutura de um programa exceo da main que
no existe no header file.

Os header files pode conter variveis locais e globais bem como pode incluir outros header files.

alunosnet@gmail.com alunosnet.pt.vu Pgina 9 de 9