Sub-rotinas
Uma sub-rotina é uma parte separada do programa que tem um nome e resolve sua própria tarefa separada. A sub-rotina está localizada no início do programa principal e pode ser iniciada (chamada) a partir do programa principal especificando o nome.
O uso de sub-rotinas permite evitar a duplicação de código, caso seja necessário escrever o mesmo código em locais diferentes do programa.
As bibliotecas que são importadas para o programa (por exemplo, a biblioteca matemática сmath.h) consistem em sub-rotinas que já foram compiladas por alguém. Os programadores não precisam pensar em quais algoritmos implementam, mas simplesmente aplicá-los, pensando apenas no que exatamente estão fazendo. Esta é uma grande economia de tempo. Não há necessidade de escrever um algoritmo que já foi escrito por outra pessoa.
Cada rotina deve fazer apenas uma tarefa, apenas calcule algo, ou forneça alguns dados, ou faça outra coisa.
As sub-rotinas são de dois tipos - procedimentos e funções.
As sub-rotinas executam algumas ações, por exemplo, exibem o resultado na tela de uma determinada forma (um exemplo simples, o operador printf() é uma sub-rotina padrão que imprime informações na tela)
As sub-rotinas de função retornam um resultado (número, cadeia de caracteres, etc.) que podemos usar no programa principal.
Vamos tentar escrever um procedimento simples:
Suponha que queremos exibir a string " Erro" toda vez que um erro pode ocorrer no código devido à falha do usuário (por exemplo, quando ele insere dados incorretos)
Isso pode ser feito escrevendo a declaração
cout << "Erro";
E agora imagine que tal linha precise ser inserida em vários lugares do programa. Claro, você pode simplesmente escrevê-lo em todos os lugares. Mas esta solução tem duas desvantagens.
1) esta string será armazenada na memória muitas vezes
2) se quisermos alterar a saída em caso de erro, teremos que alterar esta linha ao longo do programa, o que é bastante inconveniente
Para tais casos, são necessários procedimentos.
Um programa com um procedimento pode se parecer com isto:
#include<iostream>
usando namespace std;
void printError() // descrição do procedimento
{
cout << "Erro"; // corpo do procedimento - comandos que o procedimento irá executar
}
principal()
{
...
printError() // inicia o procedimento para execução. Apenas especificamos o nome do procedimento que queremos executar.
...
printError()
...
}
O procedimento começa com a palavra void. Existem colchetes vazios após o nome do procedimento.
Todas as instruções executadas em um procedimento são recuadas.
Os procedimentos são escritos antes da função principal main()
Para executar um procedimento, no programa principal você precisa chamá-lo pelo nome e lembre-se de colocar parênteses!
Você pode chamar um procedimento em um programa quantas vezes quiser.
|
Agora vamos imaginar que precisamos exibir diferentes mensagens em resposta ao erro de um usuário, dependendo do tipo de erro que ele cometeu.
Nesse caso, você pode escrever seu próprio procedimento para cada erro:
void imprimirErroZero()
{
cout << "Erro. Divisão por zero!";
}
void printErrorInput()
{
cout << "Erro na entrada!";
}
E se houver muitos outros erros possíveis? Esta solução não nos convém!
Precisamos aprender a controlar o procedimento, informando qual mensagem de erro exibir.
Para fazer isso, precisamos de parâmetros que escreveremos entre parênteses após o nome do procedimento
void printError(strings)
{
cout << s;
}
Neste procedimento, s é um parâmetro - uma variável especial que permite controlar o procedimento.
O parâmetro é uma variável que determina como a sub-rotina funciona. Os nomes dos parâmetros são listados separados por vírgulas no cabeçalho do subprograma. O tipo de parâmetro é escrito antes do parâmetro.
Agora, ao chamar o procedimento, você precisa indicar entre parênteses o valor real que será atribuído ao parâmetro (variável s) dentro do nosso procedimento
printError("Erro! Divisão por zero!");
Esse valor é chamado de argumento.
O argumento é o valor do parâmetro que é passado para a sub-rotina quando ela é chamada.
Um argumento pode ser não apenas um valor constante, mas também uma variável ou uma expressão aritmética.
|
Variáveis locais e globais
Muitas vezes é necessário utilizar variáveis adicionais que serão utilizadas somente na sub-rotina. Tais variáveis são denominadas locais (ou locais) e só podem ser manipuladas dentro da sub-rotina em que são criadas.
Escopo de variável local é o bloco entre colchetes dentro do qual é declarado
O programa principal em C++ também é uma sub-rotina, então todas as variáveis declaradas dentro de main() são variáveis locais.
Outras sub-rotinas não "sabem" nada sobre as variáveis locais de outras sub-rotinas.
Assim, é possível limitar o escopo (scope) de uma variável apenas à sub-rotina onde ela é realmente necessária. Na programação, essa técnica é chamada de encapsulamento - ocultar uma variável de ser alterada de fora.
Se for necessário declarar uma variável que seria visível em qualquer lugar do programa (em qualquer sub-rotina), então tais variáveis são declaradas fora de todas as sub-rotinas (ver programa 3 da tabela abaixo).
Essas variáveis são chamadas globais.
Em C++, quando o programa inicia, todas as variáveis globais são automaticamente zeradas (variáveis booleanas assumem o valor false ).
Analise três programas:
| 1) Neste programa, a variável i é local. Uma variável local é declarada dentro de uma sub-rotina |
2) Aqui, mesmo que exista uma variável i no programa principal (com valor 7), uma nova variável local i com valor 5 será criada.
Ao executar este programa, a tela exibirá o valor 75 |
3) Este programa possui uma variável global i. Seu valor pode ser alterado dentro de uma sub-rotina, e dentro do programa principal
O procedimento funcionará com a variável global i e será atribuído a ela um novo valor igual a 2. O valor 2 | é exibido na tela
|
teste nulo()
{
int i = 5;
cout << eu;
}
|
teste nulo()
{
int i = 5;
cout << eu;
}
principal()
{
int i = 7;
cout << eu;
teste();
}
|
#include <iostream>
usando namespace std;
int eu;
teste nulo()
{
i = 2;
}
principal()
{
teste();
cout << eu;
}
|
|
Tarefa
Escreva um procedimento que troque os valores de duas variáveis.
A peculiaridade dessa tarefa é que precisamos que as alterações feitas no procedimento se tornem conhecidas pelo programa chamador.
Vamos tentar escrever o procedimento assim:
void Swap ( int a, int b ) // com tal descrição dos parâmetros do procedimento,
{ // os valores dos argumentos (x e y) serão copiados,
int c; // variáveis a e b são variáveis independentes não relacionadas a x e y
c = a; a = b; b=c;
}
principal()
{
int x=1, y=2;
Trocar(x, y); // os valores das variáveis x e y (argumentos) são copiados nos parâmetros a e b
cout << "x=" << x<< ", y=" << y; // x=1, y=2
}
Se você executar este programa, poderá ver que os valores das variáveis x e y não foram alterados. Para que os parâmetros alterem os valores dos argumentos, deve-se utilizar passagem de dados por referência. Para isso, após o nome do tipo de dado no cabeçalho da sub-rotina, você deve colocar o sinal & ("e comercial").
void Swap ( int & a, int & b ) // agora as variáveis a e b obtêm os endereços das variáveis x e y na memória
{
int c;
c = a; a = b; b=c;
}
Uso: Se você passar um argumento por referência, somente o nome da variável (NÃO um número e NÃO uma expressão aritmética) pode estar neste local ao chamar o procedimento!< br />
NÃO chame um procedimento como este:
Swap(x, 4 );
Swap(5+x, y);
|