Next: 11 Mais sobre funções: Up: 1 Programação Básica em Previous: 9 Estruturas de Repetição
Quando queremos resolver um problema, em geral tentamos dividi-lo em subproblemas mais simples e relativamente independentes, e resolvemos os problemas mais simples um a um. A linguagem C++ dispõe de construções (abstrações) que auxiliam o projeto de programas de maneira top-down. Uma função cria uma maneira conveniente de encapsular alguns detalhes de “processamento”, ou seja, como algum resultado é obtido. Quando esta “computação” é necessária, a função é chamada, ou invocada. Desta forma, quando uma função é chamada o usuário não precisa se preocupar como a computação é realizada. É importante saber o que a função faz (qual o resultado da execução de uma função) e também como se usa a função. Criando funções, um programa C++ pode ser estruturado em partes relativamente independentes que correspondem as subdivisões do problema.
Você já viu algumas funções: cin.get(), sqrt(). Elas são funções de uma biblioteca padrão (do C++ ). Você não sabe como elas foram escritas, mas já viu como utilizá-las. Ou seja, você sabe o nome das funções e quais informações específicas você deve fornecer a elas (valores que devem ser passados para as funções) para que a função produza os resultados esperados.
Quando nos referirmos a uma função neste texto usaremos a maneira frequentemente utilizada que é o nome da função seguido de ().
Tomemos como exemplo o programa abaixo, que recebe 2 conjuntos de 3 números e soma o maior valor de cada conjunto:
/* ---------------------------------------------------------------------- Recebe 2 conjuntos de 3 números e soma o maior valor de cada conjunto. ---------------------------------------------------------------------- */ #include <iostream> #include <cmath> using namespace std; int main() { int a, b, c, maior_1, maior_2; /* Lê o primeiro conjunto de 3 valores */ cin >> a >> b >> c; /* Verifica o maior dos três valores informados */ /* Assume inicialmente que a variável 'a' tem o maior valor */ maior_1 = a; /* Somente muda o valor de 'maior' se os valores em 'b' ou 'c' forem maiores */ if (b > maior_1) { maior_1 = b; } if (c > maior_1) { maior_1 = c; } /* Neste ponto do programa, maior_1 contém o maior valor dentre os 3 primeiros valores informados */ /* Lê o segundo conjunto de 3 valores */ cin >> a >> b >> c; /* Verifica o maior dos três valores informados */ /* Algoritmo igual ao acima, exceto pela variável que recebe o maior valor */ /* Assume inicialmente que a variável 'a' tem o maior valor */ maior_2 = a; /* Somente muda o valor de 'maior' se os valores em 'b' ou 'c' forem maiores */ if (b > maior_2) { maior_2 = b; } if (c > maior_2) { maior_2 = c; } /* Neste ponto do programa, maior_2 contém o maior valor dentre os 3 valores informados no 2o. conjunto de entrada */ /* Calcula e exibe a soma solicitada */ cout << endl << maior_1 << " + " << maior_2 << " = " << maior_1 + maior_2 << endl; }
Observe que o código que verifica o maior valor dentre 3 números teve que ser reproduzido dentro do programa por duas vezes (para descobrir o maior valor de dois conjuntos diferentes de 3 números).
Um dos benefícios mais óbvios de usar funções é que podemos evitar repetição de código. Em outras palavras, se você quiser executar uma operação mais de uma vez, você pode simplesmente escrever a função uma vez e utilizá-la diversas vezes ao invés de escrever o mesmo código várias vezes. Outro benefício é que se você desejar alterar ou corrigir alguma coisa mais tarde, é mais fácil alterar em um único lugar.
O exemplo acima poderia ser simplificado pela criação de uma função
chamada maior, que dados três números 
, 
, e 
, dá como
resultado o maior valor dentre os três valores fornecidos:
#include <iostream> using namespace std; int main() { int a, b, c, maior; cout << "Entre com os tres numeros: "; cin >> a >> b >> c; if (a > b) maior = a; else maior = b; if (maior < c) maior = c; cout << "O Maior numero eh " << maior << endl; }
O exemplo pode ser então alterado e simplificado com o uso da função maior():
/* ---------------------------------------------------------------------- Recebe 2 conjuntos de 3 números e soma o maior valor de cada conjunto. ---------------------------------------------------------------------- */ #include <iostream> #include <cmath> using namespace std; /* Função que retorna o maior valor entre x, y e z */ int acheMaior (int x, int y, int z) { int maior; /* Assume inicialmente que a variável 'x' tem o maior valor */ maior = x; /* Somente muda o valor de 'maior' se os valores em 'y' ou 'z' forem maiores */ if (y > maior) { maior = y; } if (z > maior) { maior = z; } return maior; } int main() { int a, b, c, maior_1, maior_2; /* Lê o primeiro conjunto de 3 valores */ cin >> a >> b >> c; /* Verifica o maior dos três valores informados */ maior_1 = acheMaior(a,b,c); /* Neste ponto do programa, maior_1 contém o maior valor dentre os 3 primeiros valores informados */ /* Lê o segundo conjunto de 3 valores */ cin >> a >> b >> c; /* Verifica o maior dos três valores informados */ /* Usa a mesma função, pois o procedimento para encontrar o maior valor de 3 números é o mesmo. */ maior_2 = acheMaior(a,b,c); /* Neste ponto do programa, maior_2 contém o maior valor dentre os 3 valores informados no 2o. conjunto de entrada */ /* Calcula e exibe a soma solicitada */ cout << endl << maior_1 << " + " << maior_2 << " = " << maior_1 + maior_2 << endl; }
Como pode ser observado, sejam quais forem os conjuntos de 3 números fornecidos, não precisa escrever um código similar ao mostrado na função maior acima para cada número. Basta chamar a função maior(), passar os valores necessários para verificar o maior valor de cada conjunto, e utilizar os resultados.
Evitar repetição de código é a razão histórica que funções foram inventadas (também chamado de procedimento ou subrotinas em outras linguagens de programação). A maior motivação para utilizar funções nas linguagens contemporâneas é a redução da complexidade do programa e melhoria da modularidade do programa. Dividindo o programa em funções, é muito mais fácil projetar, entender e modificar um programa. Por exemplo, obter a entrada do programa, realizar as computações necessárias e apresentar o resultado ao usuário pode ser implementado como diferentes funções chamadas por main() nesta ordem.
Funções podem ser escritas independentemente uma da outra. Isto significa que, em geral, variáveis usadas dentro de funções não são compartilhadas pelas outras funções. Assim sendo, o comportamento da função é previsível. Se não for assim, duas funções completamente não relacionadas podem alterar os dados uma da outra. Se as variáveis são locais a uma função, programas grandes passam a ser mais fáceis de serem escritos. A comunicação entre funções passa a ser controlada - elas se comunicam somente através pelos valores passados as funções e os valores retornados.
Um programa C++ consiste de uma ou mais definições de funções (e variáveis). Há sempre uma função chamada main. Outras funções também podem ser definidas. Cada uma pode ser definida separadamente, mas nenhuma função pode ser definida dentro de outra função. Abaixo, mostramos um exemplo simples de um programa que consiste de duas funções: main() e alo(). Quando executado, este programa imprimirá a mensage Alo! três vezes.
#include <iostream>
using namespace std;
// definicao da funcao alo()
void alo(void)
{
cout << "Alo!" << endl;
}
// definicao da funcao main()
int main ()
{
int i;
i = 1;
while (i <= 3)
{
alo();
i = i + 1;
}
}
Todas as funções devem ser declaradas ou definidas antes de
serem usadas. As funções da biblioteca padrão, tais como
cin.get(), são pré-definidas, mas mesmo assim devem ser
declaradas (deve ser anunciado ao compilador que elas existem). É
por isso que incluímos a linha #include <iostream> no
início do código fonte.
O formato geral da definição de uma função é
tipo-do-resultado nome-da função (lista-de-argumentos)
{
declarações e sentenças
}
A primeira linha da definição é o cabeçalho da função. Ela têm três partes principais: o nome da função, o tipo do resultado (que é um valor) que a função computa e retorna, e entre parênteses uma lista de parâmetros (também chamado de argumentos formais). Se a função não retorna nenhum valor, o tipo é chamado de void, e esta palavra é escrita no cabeçalho na frente do nome da função. Se a função não tiver argumentos formais, a palavra void pode ser escrita no lugar da lista de argumentos formais entre os parênteses. Para simplificar a exposição, falaremos sobre o tipo do retorno e os argumentos formais mais tarde. Eles servem para permitir que as funções troquem informações entre si.
void nome-da-função(void)
{
declarações e senteças (corpo da função)
}
O primeiro void significa que esta função não tem tipo de retorno (não retorna um valor), e o segundo significa que a função não tem argumentos (ela não precisa de nenhuma informação externa para ser executada). Isso não significa que a função não faz nada. Ela pode realizar alguma ação, como imprimir uma mensagem. O exemplo abaixo mostra um programa que usa uma função como essa:
#include <iostream>
using namespace std;
// DEFINIÇÃO da função alo()
void alo(void)
{
cout << "Alo." << endl;
}
// Programa Principal
int main()
{
alo();
}
Neste exemplo, o programa consiste de duas funções, main() e alo().
A função alo() imprime a mensagem Alo. quando chamada. A sentença cout é o corpo da função. Dentro da função main() há uma chamada a função alo(). A função é chamada pelo seu nome seguido de () (já que a função alo não tem argumentos, nenhuma expressão é escrita dentro dos parênteses). A função alo() não retorna um valor, ela é chamada simplesmente para realizar uma ação (imprimir a mensagem). A chamada de função é uma sentença válida em C++ , portanto deve ser terminada por ponto e vírgula (;).
alo();
Observe que a ordem em que as funções são definidas dentro do código-fonte é importante, sendo que uma função deve sempre ser definida ANTES das funções em que ela é CHAMADA. No nosso exemplo, como a função alo() é chamada pela função main(), então a DEFINIÇÃO da função alo() deve vir antes da definição da função main(). O uso de protótipos pode ser usado para definir as funções em qualquer ordem dentro do código-fonte, o que será visto na Seção 10.9.
Outra coisa que você deve ter notado é que main() também é uma função. A função main() não difere em nada das demais funções, com a exceção de que contém o programa principal, isto é, ao se executar um programa, ela á a primeira função a ser executada. As demais funções são executadas somente quando chamadas a partir da execução da função main().
#include <iostream>
using namespace std;
void cumprimenta(char inic1, char inic2)
{
cout << "Ola, " << inic1 << inic2 << "!" << endl;
}
int main()
{
char primeiro, segundo;
cout << "Entre com duas iniciais (sem separacao): ";
cin >> primeiro >> segundo ;
cumprimenta(primeiro, segundo);
}
A função main() chama a função cumprimenta(). Ao fazer esta chamada, main() passa para cumprimenta() os valores dos dois caracteres para serem impressos. Veja um exemplo de execução do programa:
Entre com duas iniciais (sem separacao): YK Alo, YK!Note que há uma correspondência entre a quantidade, a ordem e tipo dos valores que main() passa (estes são chamados de parâmetros reais ou argumentos reais) e os argumentos listados no cabeçalho da função cumprimenta() (denominados argumentos formais).
Funções que não retornam nenhum valor (como alo(), main()) possuem tipo void.
Além de executarem ações (como imprimir) uma função também pode retornar um valor para o programa que o chamou. Uma função que retorna um valor tem no cabeçalho o nome do tipo do resultado. O valor retornado pode ser de qualquer tipo, incluindo int, float e char (é claro que uma vez definida, a função só é de um tipo específico). Uma função que retorna um tipo diferente de void executa alguns cálculos, e retorna o resultado (que é um único valor) para quem a chamou. A função chamadora pode então usar o resultado. Para retornar um valor para a função chamadora, a função usa a sentença return.
O formato da sentença return é a seguinte:
return expressão;
A expressão é avaliada e o seu valor é convertido ao tipo de retorno da função (o tipo da função é dado no cabeçalho da função antes do nome da função).
Considere o seguinte exemplo. O programa consiste de duas funções: main() e quadrado. O programa pede que o usuário digite três números e verifica se eles podem ser os lados de um triângulo reto.
// programa que verifica se 3 numeros podem ser os lados de um
// triangulo reto.
//
#include <iostream>
using namespace std;
// funcao que calcula o quadrado de um numero
int quadrado(int n)
{
return n * n;
}
int main()
{
int s1, s2, s3;
cout << "Entre tres inteiros: ";
cin >> s1 >> s2 >> s3;
if ( s1 > 0 && s2 > 0 && s3 > 0 &&
(quadrado(s1) + quadrado(s2) == quadrado(s3) ||
quadrado(s2) + quadrado(s3) == quadrado(s1) ||
quadrado(s3) + quadrado(s1) == quadrado(s2)) )
{
cout << " " << s1 << " " << s2 << " " << s3
<< " podem formar um triangulo reto\n";
}
else
{
cout << " " << s1 << " " << s2 << " " << s3
<< " nao podem formar um triangulo reto\n";
}
}
Note que quando chamamos a função quadrado() passamos o valor no qual desejamos executar o cálculo, e também usamos o valor retornado pela função em expressões. O valor de quadrado(s1) é o valor que a função quadrado() retorna quando chamado com o valor do argumento sendo igual ao valor da variável s1.
Os valores retornados pelas chamadas de funções podem ser usados em todos os lugares onde valores podem ser usados. Por exemplo,
y = quadrado(3);
Aqui quadrado(3) tem o valor 9, portanto 9 pode
ser atribuído a variável y;
x = quadrado(3) + quadrado(4);
atribuirá 25 a variável x, e
area = quadrado(tamanho);
atribuirá a variável area o valor da variável tamanho
elevado ao quadrado.
O próximo exemplo tem uma função chamada cinco:
#include <iostream>
using namespace std;
int cinco(void)
{
return 5;
}
int main()
{
cout << "cinco = " << cinco() << endl;
}
A saída do programa será
cinco = 5
porque o valor de cinco() dentro da sentença cout é 5. Olhando na sentença return, 5 é a expressão retornada para o chamador.
Outro exemplo:
#include <iostream>
using namespace std;
int obtem_valor(void)
{
int valor;
cout << "Entre um valor: ";
cin >> valor;
return valor;
}
int main()
{
int a, b;
a = obtem_valor();
b = obtem_valor();
cout << "soma = " << a + b << endl;
}
Este programa obtém dois inteiros do usuário e mostra a sua soma.
Ele usa a função obtem
valor() que mostra uma mensagem e
obtém o valor do usuário.
Um exemplo de saída deste programa é:
Entre um valor: 15
Entre um valor: 4
soma = 19
O seguinte exemplo mostra uma função (uma versão para int da função obtemvalor) que pede para
usuário um valor e se o usuário digitar um valor negativo,
imprime uma mensagem e retorna um valor positivo.
int obtem_valor_positivo(void)
{
int valor;
cout << "Entre um valor: ";
cin >> valor;
if (valor >= 0)
return valor;
cout << "Tornando o valor positivo..." << endl;
return -valor;
}
Em uma função void, return; (só com ;) pode ser usado para sair de uma função. O exemplo seguinte, pede instruções ao usuário. Se o usuário reponder nao, a função termina. Do contrário, ele imprime as instruções e depois termina.
void instrucoes(void)
{
int ch;
cout << "Voce quer instrucos? (s/n): ";
ch = cin.get();
/* Termina se resposta for n */
if (ch == 'n' || ch == 'N')
return;
/* Mostra instrucoes */
cout << "As regras do jogo sao . . . ";
.
.
.
return;
}
O return final (antes de fechar as chaves do corpo da função) na função é opcional. Se omitido, a função atingirá o final da função e retornará automaticamente. Note que o return é opcional somente para funções void.
A comunicação entre uma função e o chamador pode ser nas duas direções. Argumentos podem ser usados pelo chamador para passar dados para a função. A lista de argumentos é definida pelo cabeçalho da função entre parênteses.. Para cada argumento você precisa especificar o tipo do argumento e o nome do argumento. Se houver mais de um argumento, eles são separados por vírgula. Funções que não possuem argumentos tem void como lista de argumento. No corpo da função os argumentos (também chamados de argumentos formais ou parâmetros formais) são tratados como variáveis. É erro defini-los dentro do corpo da função porque eles já estão definidos no cabeçalho. Antes da execução da função os valores passados pelo chamador são atribuídos aos argumentos da função.
Considere o seguinte programa com a função abs() que calcula o valor absoluto de um número.
#include <iostream>
using namespace std;
/* Definicao da funcao abs */
int abs(int x)
{
if (x < 0)
x = -x;
return x;
}
int main()
{
int n;
cout << "Entre um numero: ";
cin >> n;
cout << "Valor absoluto de " << n << " eh " << abs(n) << endl;
}
A função abs() tem um argumento do tipo int, e seu nome é x. Dentro da função, x é usado como uma variável x.
Uma vez que abs() tem um único argumento, quando ela é chamada, há sempre um valor dentro do parênteses, como em abs(n). O valor de n é passado para a função abs(), e antes da execução da função, o valor de n é atribuído a x.
Aqui está um exemplo de uma função que converte uma temperatura de Farenheit para Celsius:
float fahr_para_cels(float f)
{
return 5.0 / 9.0 * (f - 32.0);
}
Como você pode ver, esta função tem somente um argumento do tipo float. Um exemplo de chamada desta função poderia ser:
fervura = fahr_para_cels(212.0);
O resultado da função fahrparacels(212.0)
é atribuído a fervura. Portanto, depois da
execução desta sentença, o valor de fervura (que é
do tipo float) será 100.0.
O exemplo seguinte possui mais de um argumento:
float area(float largura, float altura)
{
return largura * altura;
}
Esta função possui dois argumentos do tipo float. Para chamar uma função com mais de um argumento, os argumentos devem ser separados por vírgula. A ordem em que os argumentos são passados deve ser na mesma em que são definidos. Neste exemplo, o primeiro valor passado será a largura e o segundo a altura. Um exemplo de chamada seria
tamanho = area(14.0, 21.5);
Depois desta sentença, o valor de tamanho (que é do tipo float) será 301.0.
Quando passar os argumentos, é importante ter certeza de passá-los na ordem correta e que eles são do tipo correto. Se isso não for observado, pode ocorrer erro ou aviso de compilação, ou resultados incorretos podem ser gerados.
Uma última observação. Os argumentos que são passados pelo chamador podem ser expressões em geral e não somente constantes e variávies. Quando a função é chamada durante a execução do programa, estas expressões são avaliadas, e o valor resultante passado para a função chamada.
Considere novamente a função quadrado().
Se esta função é chamada de main() como
p = quadrado(x);
somente o valor (não o endereço) de x é passado para quadrado. Por exemplo, se a variável tem valor 5, para a função quadrado(), quadrado(x) ou quadrado(5) são o mesmo. De qualquer forma, quadrado() receberá somente o valor 5. quadrado() não sabe se na chamada da função o 5 era uma constante inteira, o valor de uma variável do tipon int, ou alguma expressão como 625/25 - 4 * 5. Quando quadrado() é chamado, não interessa qual a expressão entre parênteses, ela será avaliada e o valor passado para quadrado().
Esta maneira de passar argumentos é chamada de chamada por valor. Argumentos em C++ são passados por valor. Portanto, a função chamada não pode alterar o valor da variável passada pelo chamador como argumento, porque ela não sabe em que endereço de memória o valor da variável está armazenado.
Estas variáveis são restritas a função dentro da qual elas são definidas. Só esta função pode “enxergar” suas próprias variáveis. Por exemplo:
#include <iostream>
using namespace std;
void obtem_int(void)
{
int x;
cout << "Entre um valor: ";
cin >> x;
cout << "Obrigado!\n";
}
int main()
{
obtem_int();
/* **** Isto esta' errado **** */
cout << "Voce digitou " << x << endl;
}
A função main() usou um nome x, mas x não é
definido dentro de main; ele é uma variável local a
getint(), não a
main(). Este programa gera erro de compilação.
Note que é possível ter duas funções que usam variáveis locais com o mesmo nome. Cada uma delas é restrita a função que a define e não há conflito. Analise o seguinte programa (ele está correto):
#include <iostream>
using namespace std;
int obtem_novo_int(void)
{
int x;
cout << "Entre um valor: ";
cin >> x;
cout << "Obrigado!\n";
return x;
}
int main()
{
int x;
x = obtem_novo_int();
/* ****Isto nao esta errado !! **** */
cout << "Voce digitou " << x << endl;
}
A função obtemnovoint() usa uma variável
local chamada x para armazenar o valor digitado e retorna como
resultado o valor de x. main() usa outra variável
local, também chamada de x para receber o resultado retornado
por obtemnovoint(). Cada função tem sua
própria variável x.
Os protótipos servem para dar ao compilador informações sobre as funções. Isso para que você possa chamar funções antes que o compilador tenha a definição (completa) das funções. O protótipo de uma função é idêntico ao cabeçalho da função, mas o nome dos argumentos podem ser omitidos e ele é terminado com um ponto e vírgula. Protótipos declaram uma função ao invés de defini-las. O formato de um protótipo é:
tipo-de-retorno nome-da-função(lista-dos-tipos-dos-argumentos);
Definindo protótipos, você não precisa se preocupar com a ordem em que define as funções dentro do código-fonte do programa. A principal vantagem de definir protótipos é que erros de chamada de funções (como chamar uma função com o número incorreto de argumentos, ou com argumentos de tipo errado) são detectados pelo compilador. Sem protótipos, o compilador só saberia que há erro depois de encontrar a definição da função.
Abaixo, mostramos a definição de duas funções e seus respectivos protótipos:
float volume(float, float, float);
float dinheiro(int, int, int, int);
float volume(float comprimento, float largura, float altura)
{
return comprimento * largura * altura;
}
float dinheiro(int c25, int c10, int c5, int c1)
{
return c25 * 0.25 + c10 * 0.10 +
c5 * 0.05 + c1 * 0.01;
}
Ação - o que a função faz
Entrada - descrição dos argumentos passados para a função
Saída - descrição do valor retornado pela função
Suposições - o que você assume ser verdade para que a função funcione apropriadamente
Algoritmo - como o problema é resolvido (método)
Estas informações devem ser colocadas como comentário antes da definição da função.
Comentários em C++ são textos que começam com // em cada linha, ou são delimitados por /* e */. Os símbolos // não possuem espaço entre si. Alguns exemplos:
// Este é um comentário sem graça
// Este é um comentário um pouco
// maior que tem diversas linhas
/* Este é um outro comentário maior
ainda e que tem várias linhas
explicando qualquer aspecto mais detalhado
do programa
*/
É sempre uma boa idéia colocar comentários em seu programa das coisas que não são claras. Isto vai ajudar quando mais tarde você olhar o programa que escreveu já há algum tempo ou vai ajudar a entender programas escritos por outra pessoa.
Um exemplo de comentário útil:
/* converte temperatura de farenheit para celsius */
celsius = (fahrenheit - 32) * 5.0 / 9.0;
O comentário deve ser escrito em português e não em C++ . No exemplo abaixo
/* usando scanf, obter valor de idade e multiplicar por 365 para
* obter dias */
cin >> idade;
dias = idade * 365;
o comentário é basicamente uma transcrição do código do programa. Em seu lugar, um comentário como
/* obtem idade e transforma em numero de dias */
seria mais informativo neste ponto.
Em outras palavras, você deve comentar o código, e não codificar o comentário.
Você também deve evitar comentários inúteis ou óbvios. Por exemplo:
// Incrementa i
i = i + 1;
Não há necessidade de comentários já que i = i + 1 já é auto explicativo.
Abaixo está um exemplo de como você deve comentar uma função.
/* função instrucoes()
* acao: mostra instrucoes do programa
* entrada: nenhuma
* saida: nenhuma
* suposicoes: nenhuma
* algoritmo: imprime as instrucoes
*/
void instrucoes(void)
{
/* mostra instrucoes */
cout << "O processo de purificacao do Uranio-235 e' . . . ";
.
.
}
