03. Revisão de Funções

Prévia do material em texto

REVISÃO DE FUNÇÕES
Estrutura de Dados I
 Funções são módulos a partir dos quais os 
programas em C++ são construídos
system
Revisão de Funções
strlen
main
Programa
Sistema 
Operacional
Revisão de Funções
// funcuse.cpp – exemplo do uso de funções
#include <iostream>
#include <cstring>
using namespace std;
int main()
{
char nome[40];
cout << "Digite o seu nome: ";
cin >> nome;
int comprimento;
comprimento = strlen(nome);
cout << nome << ", o seu nome tem " << comprimento
<< " letras e começa com " << nome[0] << endl; 
system("pause");
return 0;
}
Escrever no 
quadro
 As funções se apresentam de duas formas:
 Funções com valor de retorno
 Funções sem valor de retorno
Revisão de Funções
system
strlen
Entrada: 
"texto"
Resultado: 
5
Entrada:
"pause"
Revisão de Funções
 Para usar uma função é preciso:
 Fornecer uma definição para a função: a 
seqüência de instruções que serão executadas 
sempre que a função for chamada
 Fornecer um protótipo para a função: um 
cabeçalho que especifica os tipos de informações 
que a função recebe e retorna
 Chamar a função: uma instrução que invoca a 
função passando argumentos para ela
Revisão de Funções
 Ao usar uma função de biblioteca:
 A função já foi definida e pré-compilada num 
arquivo separado 
 O protótipo é obtido incluindo-se um arquivo de 
cabeçalho no programa
 Resta apenas chamar a função
#include <iostream>
#include <cstring>
comprimento = strlen(nome);
system("pause");
Criando Funções
 Ao se criar funções, todos os aspectos devem 
ser tratados:
 Definição: pode ser feita no mesmo arquivo fonte 
do programa principal ou em um arquivo fonte 
separado (.cpp)
// definição da função simples
void simples()
{
cout << "Eu sou uma função simples" << endl; 
}
Criando Funções
 Ao se criar funções, todos os aspectos devem 
ser tratados:
 Prototipagem: pode ser feita no mesmo arquivo 
do programa principal ou em um arquivo de 
cabeçalho (.h)
 Se feita em arquivo de cabeçalho, o programa 
principal deve incluir este arquivo usando #include
void simples(); // protótipo da função
Criando Funções
 Ao se criar funções, todos os aspectos devem 
ser tratados:
 Chamada: pode ser feita em qualquer parte do 
programa principal, ou mesmo dentro de outras 
funções
 Contanto que o protótipo da função esteja visível, 
não importa em que arquivo a função foi definida
simples(); // chamada da função
Criando Funções
// unico.cpp – definindo, prototipando e chamando uma função
#include <iostream>
using namespace std;
void simples(); // protótipo da função
int main()
{
cout << "main() vai chamar a função simples():\n";
simples(); // chamada da função
system("pause"); 
return 0;
}
// definição da função
void simples()
{
cout << "Eu sou uma função simples" << endl; 
}
Criando Funções
// principal.cpp – programa com chamada da função
#include "biblioteca.h" 
int main()
{
cout << "main() vai chamar a função simples():\n";
simples(); // chamada da função
system("pause"); 
return 0;
}
// biblioteca.h – prototipo da função
#include <iostream>
using namespace std;
void simples(); 
// biblioteca.cpp - definição da função
#include "biblioteca.h" 
void simples()
{
cout << "Eu sou uma função simples" << endl; 
}
Biblioteca.h
Biblioteca.cpp
Principal.cpp
Definindo Funções
 Funções que não retornam valores são 
função de tipo void e têm a seguinte forma:
 A lista de parâmetros especifica o tipo e o 
número de parâmetros (informações) 
passados para a função
void nomeDaFunção (listaDeParâmetros)
{ 
instruções
return; // opcional
}
Definindo Funções
 Tipicamente usa-se funções sem valor de 
retorno para executar alguma ação:
 A lista de parâmetros da função tchau indica 
que na chamada da função deve-se passar 
um valor inteiro como argumento
void tchau (int n)
{ 
for (int i = 0; i < n; i++)
cout << "Tchau! ";
cout << endl;
}
Definindo Funções
 Funções que retornam valores têm a 
seguinte forma geral:
 O valor de retorno é obrigatório e pode ser 
uma constante, uma variável ou uma 
expressão, contanto que redutível a um valor 
de tipo nomeDoTipo
nomeDoTipo nomeDaFunção (listaDeParâmetros)
{ 
instruções
return valor; // valor é convertido para nomeDoTipo
}
Definindo Funções
 Tipicamente usam-se funções com valor de 
retorno para obter um resultado após a 
execução da função:
 A chamada da função é substituída pelo valor 
retornado
int maior (int a, int b)
{ 
if (a > b)
return a;
else
return b;
}
Mecanismo de Retorno
 Uma função retorna um valor copiando o 
valor de retorno para um registrador da CPU 
ou para uma posição de memória específica
 A função que chama e a função chamada
precisam entrar num acordo sobre o tipo do dado 
que será armazenado nessa posição de memória
 Uma função termina após a execução da 
instrução de retorno
Mecanismo de Retorno
double cubo(double x); // protótipo da função
int main()
{
...
double q = cubo (1.2); // chamada da função
...
}
double cubo(double x) // definição da função
{
return x * x * x;
}
1.728
cubo() calcula o valor de 
retorno e o coloca na 
memória; o cabeçalho da 
função diz a cubo para usar 
um tipo double.
main() olha a memória para 
obter o valor de retorno e 
atribuí-lo a q; o protótipo 
de cubo() diz a main() que 
espere por um valor tipo 
double.
Memória auxiliar
Prototipagem e Chamada
 As chamadas de funções podem ser vistas em 
praticamente todo programa C++
 Os protótipos são menos conhecidos porque 
eles estão muitas vezes escondidos nos 
arquivos de inclusão
#include <iostream>
#include <cstring>
comprimento = strlen(nome);
system("pause");
Prototipagem e Chamada
// protos.cpp – usando protótipos e chamadas de função
#include <iostream>
using namespace std;
void tchau(int); // protótipo: sem valor de retorno
double cubo(double x); // protótipo: retorna um double
int main(void)
{
tchau(5); // chamada de função
cout << "Digite um numero: ";
double lado;
cin >> lado;
double volume = cubo(lado); // chamada de função
tchau(cubo(2)); // chamada de função
system("pause"); 
return 0;
}
Prototipagem e Chamada
// (continuação)
// imprime Tchau n vezes
void tchau (int n)
{ 
for (int i = 0; i < n; i++)
cout << "Tchau! ";
cout << endl;
}
// calcula o cubo de um valor
double cubo (double x)
{ 
return x * x * x;
}
Prototipagem e Chamada
 O protótipo de função é uma instrução, assim 
ele deve sempre terminar com ponto e 
vírgula
 A forma mais simples de ter o protótipo é 
copiando o cabeçalho da função
 Entretanto o protótipo não requer nomes 
para as variáveis
double cubo(double x);
double cubo(double);
Passagem de Argumentos
 C++ passa argumentos por valor: 
 O valor do argumento é passado para a função
 Na função o valor é atribuído a uma nova variável
int main()
{
double lado = 2;
double volume = cubo(lado);
}
double cubo(double x)
{ 
...
}
Passagem de Argumentos
 C++ passa argumentos por valor: 
 Isso protege os dados da função main() de ações 
da função cubo(): a função cubo trabalha com 
uma cópia dos dados
int main()
{
double lado = 2;
double volume = cubo(lado);
}
double cubo(double x)
{ 
...
}
Passagem de Argumentos
Passagem de argumentos por valor
double cubo(double x); 
int main()
{
...
double lado = 5;
double volume = cubo(lado);
...
}
double cubo(double x)
{
return x * x * x;
}
Cria variávellado e atribui 
o valor 5 a ela
5
lado
valor 
original
Passa o valor 5 para a função cubo()
Cria variável x
e atribui o valor 
recebido
5
x
valor 
copiado
Passagem de Argumentos
 As variáveis usadas para receber os valores 
são chamadas de parâmetros da função
 Os valores passados para a função são 
chamados de argumentos da função
int main()
{
double lado = 2;
double volume = cubo(lado);
}
double cubo(double x) // x é o parâmetro da função
{ // o argumento é o valor da variável lado
...
}
Variáveis Locais
 Variáveis, incluindo os parâmetros, 
declaradas dentro de uma função são 
privadas à função
 Quando a função é chamada, o computador aloca 
a memória necessária para estas variáveis
 Quando a função termina, o computador libera a 
memória utilizada pela função, incluindo as 
variáveis
 Elas são chamadas de variáveis locais 
Variáveis Locais
void tchau(int n); 
int main()
{
int n = 20;
int i = 1000;
int y = 10;
...
tchau(y);
...
}
void tchau(int n)
{
for (int i=0; i<n; i++)
cout << "Tchau! ";
cout << endl;
}
n i y
Cada função tem suas 
variáveis com seus 
próprios valores
20 1000 10
variáveis em main()
n i
10 0
variáveis em tchau()
Variáveis Globais
 Variáveis declaradas fora de funções são 
públicas, ou seja, podem ser acessadas por 
todas as funções
 O computador aloca memória para estas variáveis 
no início da execução do programa
 O computador só libera a memória utilizada ao 
término do programa
 Elas são chamadas de variáveis globais
 Seu uso deve ser evitado ao máximo
Variáveis Globais
void atelogo(int n);
void tchau(); 
int a = 300;
int x = 500;
int main()
{
int x = 10;
int a = 20;
atelogo(x);
tchau();
...
}
void atelogo(int n)
{ cout << n; }
void tchau()
{ cout << a; }
a x
300 500
variáveis globais
a x
20 10
variáveis locais a main()
A saída do programa: 
10 300
Múltiplos Argumentos 
 Uma função pode ter múltiplos argumentos
 Ao definir a função usa-se uma lista de 
declarações de variáveis separadas por 
vírgulas
 Declarações não podem ser combinadas
n_chars('R', 25);
void n_chars(char c, int n);
void fifi(float a, float b); // declara cada variável
void fufu(float a, b); // ERRADO
Múltiplos Argumentos
// twoarg.cpp – função com dois argumentos
#include <iostream>
using namespace std;
void n_chars(char, int);
int main(void)
{
int vezes;
char ch;
cout << "Digite um caractere: ";
cin >> ch;
while (ch != 'q')
{
cout << "Digite um valor inteiro: ";
cin >> vezes;
n_chars(ch, vezes);
cout << "Digite outro caractere (q para sair): ";
cin >> ch;
}
system("pause"); 
return 0;
}
// mostra c n vezes
void n_chars (char c, int n)
{
while (n-- > 0)
cout << c;
}
Múltiplos Argumentos
 O exemplo a seguir calcula a probabilidade de 
vencer um jogo na loteria
 Se você escolher 6 valores de 51 possíveis, a 
matemática diz que você tem uma chance em R 
de vencer, onde R é dado pela fórmula:
1x2x3x4x5x6
46x47x48x49x50x51
R
Múltiplos Argumentos
// lotto.cpp – probabilidade de vencer na loteria
#include <iostream>
using namespace std;
long double probabilidade(unsigned, unsigned);
int main()
{
double total, escolhas; 
cout << "Entre com o total de números ";
cout << "no cartão de jogo e\n";
cout << "o número de escolhas feitas: ";
while ((cin >> total >> escolhas) && escolhas <= total)
{
cout << "Você tem uma chance em ";
cout << probabilidade(total, escolhas);
cout << " de ganhar.\n";
cout << "Próximos dois números (s para sair): ";
}
cout << "Bye!\n";
system("pause"); 
return 0;
}
 Saída do Programa:
Múltiplos Argumentos
long double probabilidade(unsigned numeros, unsigned aposta);
{
long double resultado = 1.0; // variável local
long double n;
unsigned p;
for (n = numeros, p = aposta; p > 0; n--, p--)
resultado = resultado * n / p; 
return resultado;
}
Entre com o total de números no cartão de jogo e
o número de escolhas feitas: 49 6
Você tem uma chance em 1.39838e+007 de ganhar.
Próximos dois números (s para sair): s
Bye!
Conclusão
 Funções são módulos a partir dos quais os 
programas em C++ são construídos
 Existem dois tipos de funções:
 Funções que retornam valores
 Funções sem valor de retorno
 Para usar uma função é preciso:
 Definir a função
 Criar seu protótipo
 Chamar a função
Conclusão
 Variáveis podem ser locais ou globais:
 Locais : declaradas dentro de funções
 Globais: declaradas fora de qualquer função
 Deve-se dar preferência ao uso de variáveis 
locais sobre as globais
 Use uma variável global apenas quando não tiver 
outra alternativa, ou por questões de desempenho
 Funções podem ter múltiplos parâmetros e 
todos eles são variáveis locais