Você está na página 1de 22

Fundamentos da Programação

1.4 – Procedimentos, Funções e


Passagem de Parâmetros
Gilson Gonçalves de Lima

1 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


Referências
01- Introdução
02- Funções
03- Definições de funções
04- Protótipos de funções
05- Arquivos de cabeçalho
06- Recursão
07- Referências e parâmetros por referência
08- Argumentos default
09- Sobrecarga de funções
10- Gabaritos de funções
11- Referências

2 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


01- Introdução

 A maioria dos programas de computador que resolvem


problemas do mundo real são muito maiores do que os
programas vistos por nós nas aulas anteriores
 A solução é usar a técnica de dividir para conquistar, isto é usar
funções e outros recursos modulares como classes

3 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


02- Funções

 As funções permitem fragmentar um programa. Isso facilita a


identificação de erros e o reuso de código
 Variáveis declaradas em funções são variáveis locais
 A maioria das funções tem uma lista de parâmetros que
provêem os meios para transferir informações entre funções
 Tanto procedimentos quanto funções são subrotinas
 Procedimentos e funções coexistem em poucas linguagens
como Pascal. Em C, fala-se apenas de funções

4 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


02- Funções
Principais diferenças entre funções e procedimentos

 1 – Quando coexistem, funções são usadas para cálculos ao


passo que procedimentos tratam de operações lógicas
 2 – funções precisam retornar um valor, procedimentos não

5 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


03- Definições de funções

 Em C++, cada programa consiste de uma função chamada


main que chama as funções da biblioteca padrão para realizar
suas tarefas.
 No exemplo a seguir, a função square é chamada ou
invocada em main.
 Antes de ser chamada, square foi prototipada.
 Depois de main, a função square foi definida.

6 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


03- Definições de funções
#include <iostream>
using std::cout;
using std::endl;
int square( int ); // protótipo da função
int main()
{
for ( int x = 1; x <= 10; x++ )
cout << square( x ) << " "; // x é parâmetro da função

cout << endl;


return 0;
}
int square( int y ) // definição da função
{
return y * y;
}

7 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


04- Protótipos de funções

 Um protótipo de função diz ao compilador o nome da


função, o tipo de dados retornados pela função, o número
de parâmetros que a função espera receber, os tipos dos
parâmetros e a ordem na qual esses parâmetros são
esperados.

8 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


04- Protótipos de funções

Tipos de dados (do maior tipo para o menor)

long double
double
Float
unsigned long int (sinônimo de unsigned long)
long int (sinônimo de long)
unsigned int (sinônimo de unsigned)
int
unsigned short int (sinônimo de unsigned short)
short int (sinônimo de short)
unsigned char
char
bool (false tornas-se 0, true torna-se 1)

9 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


05- Arquivos de cabeçalho

 Cada biblioteca padrão tem um arquivo de cabeçalho


correspondente, contendo protótipos de todas as funções
daquela biblioteca e definições de vários tipos de dados e
constantes necessários por elas.
 Em C++, um arquivo de cabeçalho definido pelo
programador pode ser incluído usando-se a diretiva de pré-
processador #include.
 Por exemplo podemos criar um arquivo de cabeçalho
square e incluí-lo no programa principal escrevendo
#include “square.h”

10 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


06- Recursão

 Uma função recursiva é uma função que chama a si mesma,


direta ou indiretamente (por meio de outra função).
 A etapa da recursão pode levar a outras partes recursivas , à
medida que a função dividir cada problema em duas partes
conceituais.

11 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


06- Recursão
 Cálculo recursivo de 5!

12 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


06- Recursão
#include <iostream>
using std::cout;
using std::endl;
#include <iomanip>
using std::setw;
unsigned long factorial( unsigned long );
int main()
{
for ( int i = 0; i <= 10; i++ )
cout << setw( 2 ) << i << "! = " << factorial( i ) << endl;
return 0;
}
unsigned long factorial( unsigned long number )
{
if ( number <= 1 ) // caso base
return 1;
else // caso recursivo
return number * factorial( number - 1 );
}
13 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009
07- Referências e parâmetros por
referência
 Há duas maneiras de invocar funções, em muitas linguagens
de programação, são chamadas por valor e chamadas por
referência.
 Quando os argumentos são passados por chamadas por valor, é
feita uma cópia do valor dos argumentos, que é passada para
a função chamada. Até agora, só vimos programas com
chamadas por valor
 Quando os argumentos são passados por chamada por
referência, a função chamadora permite que a função chamada
realmente modifique o valor original da variável.

14 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


07- Referências e parâmetros por
referência
int squarePorValor( int );
void squarePorReferencia( int & );
int main()
{
int x = 2, z = 4;
cout << "x = " << x << " antes squarePorValor\n”<< "Valor retornado por squarePorValor: “
<< squarePorValor( x ) << endl
<< "x = " << x << " depois squarePorValor\n" << endl;
cout << "z = " << z << " antes squarePorReferencia" << endl;
squarePorReferencia( z );
cout << "z = " << z << “depois squarePorReferencia" << endl;
return 0;
}
int squarePorValor( int a ){ a=2
return a *= a; //argumento não-modificado}
void squarePorReferencia( int &cRef ){ Z=4
cRef *= cRef; // argumento modificado}

x=2 cRef
15 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009
08- Argumentos default

 Chamadas a funções devem geralmente passar um valor


particular de um argumento. O programador pode
especificar que tal argumento um argumento default e o
programador pode fornecer um valor default para esse
argumento.

16 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


08- Argumentos default

int VolumeCaixa( int comprimento = 1, int largura = 1, int altura = 1 ); //Protótipo


int main()
{
cout << "O volume default da caixa e': " << VolumeCaixa()
<< "\n\nO volume da caixa com comprimento 10,\n"
<< "largura 1 e altura 1 e': " << VolumeCaixa( 10 )
<< "\n\nO volume da caixa com comprimento 10,\n"
<< "largura 5 e altura 1 e': " << VolumeCaixa( 10, 5 )
<< "\n\nO volume da caixa com comprimento 10,\n"
<< "largura 5 e altura 2 e': " << VolumeCaixa( 10, 5, 2 )
<< endl;
system("PAUSE");
return 0;
}
int VolumeCaixa( int comprimento, int largura, int altura ) //definição
{
return comprimento * largura * altura;
}

17 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


09- Sobrecarga de funções

 O C++, como outras linguagens, possibilita que sejam


definidas varias funções com o mesmo nome, desde que estas
funções tenham conjuntos de parâmetros diferentes (pelo
menos quanto a seus tipos).
 Esse recurso é chamado de sobrecarga de funções.
 Quando uma função é sobrecarregada, o compilador
seleciona a função apropriada pelo exame da quantidade, dos
tipos e da ordem dos argumentos na chamada.

18 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


09- Sobrecarga de funções

int square( int x ) { return x * x; } // definição da função antes do main. não precisa de proto'tipo

double square( double y ) { return y * y; }

int main()
{
cout << "The square of integer 7 is " << square( 7 )
<< "\nThe square of double 7.5 is " << square( 7.5 )
<< endl;
system("PAUSE");
return 0;
}

19 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


10- Gabaritos de funções
 Funções sobrecarregadas são usadas normalmente para
executar operações semelhantes que envolvem lógicas de
programação distintas.
 Se a lógica dos programas e suas operações são idênticas, para
vários tipos de dados, isso pode ser codificado de forma mais
compacta usando gabaritos de funções.
 Definições de gabarito começam com a palavra template
seguido por uma lista formal precedida pela palavra
typename ou class.

20 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


10- Gabaritos de funções

template < class T > double double1, double2, double3;


T maximum( T valor1, T valor2, T valor3 )
{ cout << "\nEntre com tres valores double: ";
T max = valor1; cin >> double1 >> double2 >> double3;
if ( valor2 > max ) cout << "O ma'ximo valor double e': "
max = valor2; << maximum( double1, double2, double3 ); // double
version
if ( valor3 > max )
max = valor3;
char char1, char2, char3;
return max;
}
cout << "\nEntre com tres caracteres: ";
int main()
cin >> char1 >> char2 >> char3;
{
cout << "O ma'ximo valor de caractere e': "
int int1, int2, int3;
<< maximum( char1, char2, char3 ) // char version
<< endl;
cout << "Entre com tres valores inteiros: ";
system("PAUSE");
cin >> int1 >> int2 >> int3;
return 0;
cout << "O ma'ximo valor inteiro e': "
}
<< maximum( int1, int2, int3 ); // int version

21 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009


11- Referências

 DEITEL, M., DEITEL,P. C++ Como Programar. 3ª Edição.


Bookman.2001.

22 Gilson G. de Lima - gilsongl@gmail.com 11/04/2009