Aula 06 - Funções

Conceitos-Chave:

- função, como declarar, definir e usá-la
- argumentos, como os parâmetros passados às funções
- alcance, uma variável dentro de uma função só pode ser acedida pela mesma
- return, devolve valores para fora da função
- do...while, diferente do operador while na ordem de execução
- for, como alternativa ao while
- operador ternário, como alternativa ao if...else

Funções

Uma função é um conjunto de instruções que pode (e deve) ser reutilizada (usada mais do que uma vez), em qualquer ponto do programa. Até agora temos utilizado sempre uma função: a função main.

São muito úteis pois permitem que muitas linhas de código sejam substituídas numa só. Por exemplo, o seguinte código seria possível caso Como expliquei na primeira aula, a função main é sempre a primeira a ser chamada pelo programa Finalmente chegamos a uma das partes mais divertidas de programação com C++: as funções! Isso porque podemos criar funções para praticamente tudo e depois usá-las. Por exemplo poderíamos fazer:


desenharPersonagem();
moverPersonagem();
mostrarVideo(SEQUENCIA_DE_VIDEO_23);

Resumindo, uma função é uma simples linha de código que permite executar várias linhas mais complexas.
Vou criar uma função simples para perceberem a ideia:

#include <iostream>
using namespace std;

int criarPersonagem()
{
    cout << "Personagem Criada.\nNome: Agnor" << endl;
    return 0;
}

int main()
{
    criarPersonagem();
    cin.get();
    return 0;
}

Na primeira lição vimos a estrutura básica de uma função:

tipo_de_retorno nome_da_funcao (argumentos)
{ instruções }

Esta função segue uma estrutura próxima da função main: não tem argumentos e o tipo de retorno é um int.

No entanto, esta função pode ser chamada por outras funções (neste caso, é chamada pela função main). Por exemplo, o seguinte código é possível:

#include <iostream>
using namespace std;

int criarPersonagem()
{
    cout << "Personagem Criada.\nNome: Agnor" << endl;
    return 0;
}

int main()
{
    criarPersonagem();
    criarPersonagem();
    criarPersonagem();
    cin.get();
    return 0;
}

Como vêm, as funções ajudam em muito a encurtar o código e na sua compreensão (temos uma linha de código, em vez de 200, por exemplo). Além disso, se quisermos alterar a forma de criar personagens, basta alterá-la apenas uma vez (a função), não é preciso alterar o código em cada ponto.

Argumentos de Funções

Uma dada função pode possuir vários (ou nenhuns) argumentos. Os argumentos (ou parâmetros) de uma função servem para o programador passar algumas variáveis para a função tratar. Por exemplo, se quiséssemos criar uma função Soma (cujo objectivo fosse mostrar a soma de dois números), teríamos que passar duas variáveis à função.

Os argumentos encontram-se entre os parêntises '()' da função e apresentam o tipo de variável e o identificador ("int x", por exemplo). Uma função pode ter os argumentos que desejarmos. Vejam o seguinte exemplo:

#include <iostream>
using namespace std;

/************* FUNÇÃO SOMA ****************
* Desc: Mostra no output o valor de a + b *
******************************************/
int soma (int a, int b)
{
    int valor = a + b;

    cout << "\nA soma de " << a << "+" << b << " e igual a " << valor << endl;

    return 0;
}

int main()
{
    soma(8, 19);    // 8 é o valor que 'a' vai assumir e 19 o valor de 'b'
    soma(21, 32);
    soma(26, 27);
    soma(1, 1);
    soma(5, 2);

    cin.get(); // Pára o programa até o utilizador premir uma tecla

    return 0;
}

Aqui podem vêr a versatilidade das funções: com apenas algumas linhas de código temos uma calculadora de somar totalmente personalizável. Por exemplo, em vez do ambiente em modo de texto, poderíamos criar um ambiente totalmente em 3D, sem necessitarmos de alterar o código dentro da função main.

Noções básicas de alcance (scope)

Uma variável que seja declarada dentro do bloco de uma função (ou nos argumentos) só existe dentro da mesma. Assim, o exemplo abaixo está incorrecto:

#include <iostream>
using namespace std;

int soma (int a, int b)     //a e b só existem dentro da função soma!
{
    int valor = a + b;  //valor só existe dentro da função soma!

    cout << "\nA soma de " << a << "+" << b << " e igual a " << valor << endl;

    return 0;
}

int main()
{
    a = 5;  //erro... 'a' só pode ser usado dentro da função soma

    int a; //este 'a' é diferente do 'a' dentro da função soma

    a = 4;  //correcto, pois 'a' existe dentro da função main, porém é
            //diferente do 'a' que está na função soma

    cin.get(); // Pára o programa até o utilizador premir uma tecla

    return 0;
}

Há uma lição dedicada ao alcance de variáveis, a lição 10, onde este tema será visto em pormenor.

Retorno de Valores

Até agora temos sempre utilizado a instrução return no fim de cada função, mas sem saber o seu verdadeiro significado. A função soma do exemplo 6.3 encontra-se ainda limitada, pois o programador não pode aceder à variável "valor" (a variável que contém a soma). A instrução return devolve (ou retorna) um valor que esteja dentro da função. No caso da calculadora, iremos usar a instrução return valor; :

#include <iostream>
using namespace std;

int soma (int a, int b)     //a e b só existem dentro da função soma!
{
    int valor = a + b;  //valor só existe dentro da função soma!

    return valor;
}

int main()
{
    int a;  //como sabem, estes dois valores não são os mesmos que os que estão
    int b;  //dentro da função soma
    int resultado;

    cout << "Insira o primeiro valor: ";
    cin >> a;

    cout << "Insira o segundo valor: ";
    cin >> b;

    resultado = soma(a, b);    //resultado vai ser igual ao valor retornado pela
                               //função soma
    cout << "\nA soma entre os dois numeros inseridos e de " << resultado << endl;

    cin.get();
    cin.get();

    return 0;
}

Também é possível criar uma função que não retorne nada. Esta função terá de ser do tipo void (vazio). De notar que, segundo os standards de C++, a função main terá obrigatoriamente de ser to tipo int:

void falar()
{
    cout << "Bem-Vindo: ";
    //sem return!
}

Declaração e Definição de funções

Ao fazermos:

int a; - estamos apenas a declarar a variável
a = 5; - estamos a definir a variável
int b = 5; - estamos a declarar e a definir a variável

As funções também seguem este esquema. Até agora temos declarado a função e definido ao mesmo tempo, mas podemos declarar primeiro e definir apenas no fim:

#include <iostream>
using namespace std;

int soma(int a, int b)
{
    return (a + b);   //nem precisamos de criar uma variável intermédia
}
//estamos a fazer a declaração e definição da função ao mesmo tempo


int subtraccao(int a, int b);
int multiplicacao(int a, int b);
int divisao(int a, int b);
/* só fizemos a declaração, a definição está em baixo. Notem a presença do
   ponto e vírgula ';', como na declaração de variáveis                 */

int main()
{
    int a, b;

    cout << "Insira dois valores:" << endl;
    cin >> a >> b;

    cout << "\nSoma: " << soma(a, b) << endl;
    cout << "Subtraccao: " << subtraccao(a, b) << endl;
    cout << "Multiplicacao: " << multiplicacao(a, b) << endl;
    cout << "Divisao: " << divisao(a, b) << endl;

    cin.get();
    cin.get();

    return 0;
}

/*DEFINIÇÕES DAS FUNÇÕES*/

int subtraccao(int a, int b)
{
    return (a - b);
}

int multiplicacao(int a, int b)
{
    return (a * b);
}

int divisao(int a, int b)
{
    return (a / b);
}

Função Random

Vou colocar aqui uma função que será muito útil: A função random. Esta função gera números aleatórios!

#include <iostream>
#include <stdlib.h>     //para poderem usar o rand()

#include <windows.h>    //para poderem usar o GetTickCount()
using namespace std;

/***********************************************************
            int getRandom(int de, int ate)
DESC: gera números aleatórios que vão desde "de" até "ate"

***********************************************************/

int getRandom(int de, int ate);

int main()
{
    srand( GetTickCount() );    //explicarei isto quando falar de arrays.
                                //experimentem retirar e correr o programa varias vezes!
    for (int x = 0; x < 10; x++)
        cout << getRandom(0,5) << endl;     //não é necessário { } porque é so uma linha


    cin.get();
    return 0;
}

int getRandom(int de, int ate)
{
    int random;
    ate -= de;
    random = rand() % (ate + 1) + de;
    return random;
}

O srand() não precisam de entender por agora, só precisam de saber que sem ele o programa gerava os mesmos números sempre que o iniciamos (experimentem retirá-lo, só a experimentar e a criar é que aprendem programação).

Vou só tentar explicar a linha: random = rand() % (ate +1) + de;

O que o rand() faz é originar um número aleatório (que poderá ser por exemplo 9828383893 ou 36). Como queremos limitar o número a um certo valor usamos o módulo ou resto (%). Assim se ate for 5, o resto de 36 a dividir por 5 é 1 por isso o número vai ser 1. Porém só gera números de 0 a 4 e não até 5. Por isso adicionamos mais 1 valor. O de faz com que acrescente o valor pretendido. A linha ate -= de faz com que só acrescente a diferença entre ate e de.

Confuso? Neste momento só precisam de saber que funciona!

Jogo de adivinhar o Número - Versão 2

Deixo como trabalho de casa perceberem o que esta nova versão do jogo de adivinhar o número faz. Só há uma coisa que ainda não falei: variáveis globais, mas acho que se explicam por si próprias:

/********************************************
            ADIVINHA O NÚMERO
Versão: 2.0
Autor: João Portela a.k.a. Agnor
Data de Desenvolvimento: 27 de Março de 2005
*********************************************/

#include <iostream>
#include <stdlib.h>     //para poderem usar o rand()
#include <windows.h>    //para poderem usar o GetTickCount()
using namespace std;

/* VARIÁVEIS GLOBAIS
   Estas variáveis podem ser usadas por todas as funções do programa! */

int escolha;    //as escolhas do utilizador
int numero;     //o numero para adivinhar
int ContadorTentativa;  //conta o numero de tentativas
int numeroTentativa;    //numero disponivel de tentativas
bool done = false;

void Dica(int escolha);         //mostra uma dica
void Menu();                    //menu do jogo
void inGame();                  //dentro do jogo
void novoJogo();                //cria novo jogo
void Ganhou();                  //mensagem mostrada a quem ganhou
void Perdeu();                  //... a quem perdeu

int getRandom(int de, int ate)  //gera numeros aleatorios
{
    int random;
    ate -= de;
    random = rand() % (ate + 1) + de;
    return random;
}

int main()
{
    srand(GetTickCount());
    cout << "Bem-Vindo ao JOGO ADIVINHA O NUMERO - VERSAO 2" << endl;
    cout << "Por Joao Portela a.k.a. Agnor" << endl;

    while(!done)
    {
        Menu();
    }

    cin.get();
    return 0;
    //ja viram que main pequeno? :P
}

void Menu()
{
    cout << "\nO que pretende fazer?" << endl;
    cout << "\n1 - Novo jogo" << endl;
    cout << "2 - Sair" << endl;
    cin >> escolha;

    switch(escolha)
    {
        case 1:
            novoJogo();
            break;
        case 2:
            done = true;    //acaba o loop do while
            break;
        default:
            cout << "\nErro...Tecla errada" << endl;
            Menu(); //volta ao menu
            break;
    }
}

void novoJogo()
{
    ContadorTentativa = 0;
    cout << "\nEscolha o nivel de dificuldade:" << endl;
    cout << "1 - 1 a 10" << endl;
    cout << "2 - 1 a 20" << endl;
    cout << "3 - 1 a 30" << endl;
    cout << "4 - 1 a 40" << endl;
    cout << "E por ai a diante :P" << endl;
    cin >> escolha;

    if (escolha <= 0)
    {
        cout << "\nErro, numero menor ou igual a 0...\nIniciando com nivel 1" << endl;
        escolha = 1;
    }

    cout << "\nEscolheu de 1 a " << escolha * 10 << endl;

    numeroTentativa = escolha + 1;

    numero = getRandom(1, 10*escolha);

    inGame();

}

void inGame()
{
    if ((numeroTentativa - ContadorTentativa) > 0)
    {
        cout << "\nNumero de tentativas restantes: " << numeroTentativa - ContadorTentativa << endl;
        cout << "Insira um numero: ";
        cin >> escolha;
        ContadorTentativa++;

        if (escolha == numero)
        {
            Ganhou();
        }

        else
        {
            Dica(escolha);
        }
    }

    else
    {
        Perdeu();
    }
}

void Ganhou()
{
    cout << "\nParabens, Ganhou!!!" << endl;
}

void Perdeu()
{
    cout << "\nPode ser que tenhas mais sorte para a proxima... perdeste..." << endl;
}

void Dica(int escolha)
{
    if (escolha < numero)
        cout << "\nTem que apostar mais para cima" << endl;
    else
        cout << "\nTem que apostar mais para baixo" << endl;

    inGame();
}