Introdução
A criação e utilização de sub-rotina é uma das técnicas de programação mais antigas. Mesmo tendo suas origens em meados dos anos de 1960, a sua utilização continua sendo muito importante. No decorre deste artigo será feita uma abordagem inicial sobre sub-rotinas, além de apresentar a sintaxe e utilização das mesmo nas linguagens de programação PASCAL, DELPHI, C/C++, JAVA e PHP.
Rápida explicação
Neste artigo serão utilizadas as linguagens de programação PASCAL, DELPHI, C/C++, JAVA e PHP por um motivo simples, mostrar para o iniciante em programação que a maioria das ideias e conceitos vistos no decorrer da aprendizagem existem em diversas linguagens de programação, sendo mais importante aprender a lógica de programação que apenas a sintaxe da linguagem escolhida, pois a sintaxe pode mudar de uma linguagem para outra, mas para ser um bom desenvolvedor é necessário entender a semântica, independente da linguagem.
Mas o leitor pode sentir-se a vontade para se concentrar apenas na linguagem que mais lhe agrade, pois o artigo foi escrito de uma maneira que permita esse olhar direcionado a apenas uma das linguagens.
Definição
As sub-rotinas são blocos de comandos que realizam tarefas específicas, em outra palavras, são conjuntos de instruções projetadas cumprir uma atividade singular. Uma analogia possível entre uma sub-rotina e um objeto do mundo real, seria compara-la a um relógio. O relógio é criado para atender uma necessidade bem específica, mostrar as horas sempre que for solicitado, e independente de quem está solicitando. Da mesma maneira uma sub-rotina deve atender uma necessidade, independente de quando, onde ou quem a solicitar.
De uma forma geral, uma sub-rotina permitir abstrair muitos detalhes do programa, melhorando a legibilidade e facilitando a manutenção do código.
As sub-rotinas recebem diversos nomes dependendo da linguagem, paradigma ou da visão, alguns desses nomes são (i) sub-programas, (ii) função, (iii) procedimento, (iv) método. O nome método, em particular, é usado para designar uma sub-rotina de uma classe nas linguagens orientadas a objetos, assunto que será aprofundado em outro artigo.
Tipos de Sub-rotinas
Existem quatro tipos bem distintos de sub-rotinas.
1º - Sub-rotina sem retorno e sem parâmetros; 2º - Sub-rotina sem retorno e com parâmetros; 3º - Sub-rotina com retorno e sem parâmetros; 4º - Sub-rotina com retorno e com parâmetros.
Obs.: Embora usados muitas vezes como sinónimos, parâmetros e argumentos têm uma diferença básica. Ao se definir uma sub-rotinas são definidos os parâmetros. Mas quando a sub-rotina é chamada, passa-se os valores como argumentos para os parâmetros.
Exemplo
No decorrer desse artigo serão apresentados três tipos de sub-rotinas, sendo eles o 1º (primeiro), 2º (segundo) e 4º (quarto) tipos. O 3º (terceiro) tipo é uma mesclagem entre o 1º (primeiro) e 4º (quarto) tipo.
O exemplo básico que será utilizado está descrito abaixo, mas a cada novo tipo de sub-rotina haverá um refinamento no código.
Exemplo básico: Criar uma sub-rotina para calcular o fatorial de um número natural.
Sub-rotina sem retorno e sem parâmetros
Nesse caso, a sub-rotina será chamada e já saberá qual o número natural que será utilizado para calcular o fatorial.
Sintaxe em PASCAL e DELPHI
// Criação da sub-rotina
procedure NOME_SUB_ROTINA; // ou procedure NOME_SUB_ROTINA();
begin
// bloco de comandos
end;
// Chamada da sub-rotina
NOME_SUB_ROTINA; // ou NOME_SUB_ROTINA();
Utilização em PASCAL:
// Criação da sub-rotina
procedure Fatorial; // ou procedure Fatorial();
var
i, num, fat: integer;
begin
num := 5;
fat := 1;
for i := 1 to num do
begin
fat := fat * i;
end;
writeln(fat);
end;
// Chamada da sub-rotina
Fatorial; // ou Fatorial;
Utilização em DELPHI:
// Criação da sub-rotina como biblioteca
procedure Fatorial; // ou procedure Fatorial();
var
i, num, fat: integer;
begin
num := 5;
fat := 1;
for i := 1 to num do
begin
fat := fat * i;
end;
ShowMessage(IntToStr(fat)); // A função IntToStr() converte um valor inteiro numa string
end;
// Chamada da sub-rotina como biblioteca
Fatorial; // ou Fatorial();
// Criação da sub-rotina como método da classe TMinhaClasse
procedure TMinhaClasse.Fatorial; // ou procedure TMinhaClasse.Fatorial();
var
i, num, fat: integer;
begin
num := 5;
fat := 1;
for i := 1 to num do
begin
fat := fat * i;
end;
ShowMessage(IntToStr(fat)); // A função IntToStr() converte um valor inteiro numa string
end;
// Chamada da sub-rotina como método do objeto meuObjeto
meuObjeto.Fatorial; // ou meuObjeto.Fatorial();
Sintaxe em C/C++ e JAVA
// Criação da sub-rotina
void NOME_SUB_ROTINA() {
// bloco de comandos
}
// Chamada da sub-rotina
NOME_SUB_ROTINA();
Utilização em C/C++:
// Criação da sub-rotina
void fatorial() {
int i, num, fat;
num = 5;
fat = 1;
for (i = 1; i <= num; i++) {
fat = fat * i;
}
printf("%d\n", fat); // A máscara %d informa a função printf() que irá receber um valor inteiro
}
// Chamada da sub-rotina
fatorial();
// Criação da sub-rotina como método da classe MinhaClasse no C++
void MinhaClasse::fatorial() {
int i, num, fat;
num = 5;
fat = 1;
for (i = 1; i <= num; i++) {
fat = fat * i;
}
printf("%d\n", fat); // A máscara %d informa a função printf() que irá receber um valor inteiro
}
// Chamada da sub-rotina como método do objeto meuObjeto no C++
meuObjeto.fatorial();
Utilização em JAVA:
// Criação da sub-rotina como método da classe MinhaClasse
public void fatorial() {
int i, num, fat;
num = 5;
fat = 1;
for (i = 1; i <= num; i++) {
fat = fat * i;
}
System.out.println(fat);
}
// Chamada da sub-rotina como método do objeto meuObjeto
meuObjeto.fatorial();
Sintaxe em PHP
// Criação da sub-rotina
function NOME_SUB_ROTINA(){
// bloco de comandos
}
// Chamada da sub-rotina
NOME_SUB_ROTINA();
Utilização em PHP:
// Criação da sub-rotina
function fatorial() {
$num = 5;
$fat = 1;
for ($i = 1; $i <= $num; $i++) {
$fat = $fat * $i;
}
print $fat; // ou echo $fat;
}
// Chamada da sub-rotina
fatorial();
Sub-rotina sem retorno e com parâmetros
Nesse caso, ao chamar a sub-rotina, será passado um número natural como argumento para calcular o fatorial.
Obs.: Na sintaxe, os COLCHETES denotam uma parte opcional e as CHAVES indicam que partes podem ser repetidas indefinidamente ou omitidas completamente.
Sintaxe em PASCAL e DELPHI
// Criação da sub-rotina
procedure NOME_SUB_ROTINA(PARAMETRO: TIPO [{; PARAMETRO: TIPO}]);
begin
// bloco de comandos
end;
// Chamada da sub-rotina
NOME_SUB_ROTINA(ARGUMENTO [{, ARGUMENTO}]);
Utilização em PASCAL:
// Criação da sub-rotina
procedure Fatorial(num: integer);
var
i, fat: integer;
begin
fat := 1;
for i := 1 to num do
begin
fat := fat * i;
end;
writeln(fat);
end;
// Chamada da sub-rotina
Fatorial(5); // O número pode ser substituído por uma variável inteira
Utilização em DELPHI:
// Criação da sub-rotina como biblioteca
procedure Fatorial(num: integer);
var
i, fat: integer;
begin
fat := 1;
for i := 1 to num do
begin
fat := fat * i;
end;
ShowMessage(IntToStr(fat)); // A função IntToStr() converte um valor inteiro numa string
end;
// Chamada da sub-rotina como biblioteca
Fatorial(5); // O número pode ser substituído por uma variável inteira
// Criação da sub-rotina como método da classe TMinhaClasse
procedure TMinhaClasse.Fatorial(num: integer);
var
i, fat: integer;
begin
fat := 1;
for i := 1 to num do
begin
fat := fat * i;
end;
ShowMessage(IntToStr(fat)); // A função IntToStr() converte um valor inteiro numa string
end;
// Chamada da sub-rotina como método do objeto meuObjeto
meuObjeto.Fatorial(5); // O número pode ser substituído por uma variável inteira
Sintaxe em C/C++ e JAVA
// Criação da sub-rotina
void NOME_SUB_ROTINA(TIPO PARAMETRO [{, TIPO PARAMETRO}]) {
// bloco de comandos
}
// Chamada da sub-rotina
NOME_SUB_ROTINA(ARGUMENTO, [{, ARGUMENTO}]);
Utilização em C/C++:
// Criação da sub-rotina
void fatorial(int num) {
int i, fat;
fat = 1;
for (i = 1; i <= num; i++) {
fat = fat * i;
}
printf("%d\n", fat); // A máscara %d informa a função printf() que irá receber um valor inteiro
}
// Chamada da sub-rotina
fatorial(5); // O número pode ser substituído por uma variável inteira
// Criação da sub-rotina como método da classe MinhaClasse no C++
void MinhaClasse::fatorial(int num) {
int i, fat;
fat = 1;
for (i = 1; i <= num; i++) {
fat = fat * i;
}
printf("%d\n", fat); // A máscara %d informa a função printf() que irá receber um valor inteiro
}
// Chamada da sub-rotina como método do objeto meuObjeto no C++
meuObjeto.fatorial(5); // O número pode ser substituído por uma variável inteira
Utilização em JAVA:
// Criação da sub-rotina como método da classe MinhaClasse
public void fatorial(int num) {
int fat;
fat = 1;
for (int i = 1; i <= num; i++) {
fat = fat * i;
}
System.out.println(fat);
}
// Chamada da sub-rotina como método do objeto meuObjeto
meuObjeto.fatorial(5); // O número pode ser substituído por uma variável inteira
Sintaxe em PHP
// Criação da sub-rotina
function NOME_SUB_ROTINA(PARAMETRO [{, PARAMETRO}]){
// bloco de comandos
}
// Chamada da sub-rotina
NOME_SUB_ROTINA(ARGUMENTO [{, ARGUMENTO}]);
Utilização em PHP:
// Criação da sub-rotina
function fatorial($num) {
$fat = 1;
for ($i = 1; $i <= $num; $i++) {
$fat = $fat * $i;
}
print $fat; // ou echo $fat;
}
// Chamada da sub-rotina
fatorial(5); // O número pode ser substituído por uma variável inteira
Sub-rotina com retorno e com parâmetros
Nesse caso, ao chamar a sub-rotina, será passado um número natural como argumento para calcular o fatorial. Ao terminar o calculo, a sub-rotina retornará o valor que foi calculado e este valor será atribuído a variável inteira resultado.
Obs.: Na sintaxe, os COLCHETES denotam uma parte opcional e as CHAVES indicam que partes podem ser repetidas indefinidamente ou omitidas completamente.
Sintaxe em PASCAL e DELPHI
// Criação da sub-rotina
function NOME_SUB_ROTINA(PARAMETRO: TIPO [{; PARAMETRO: TIPO}]): TIPO;
begin
// bloco de comandos
NOME_SUB_ROTINA := VALOR_RETORNO;
end;
// Chamada da sub-rotina
RETORNO := NOME_SUB_ROTINA(ARGUMENTO [{, ARGUMENTO}]);
Utilização em PASCAL:
// Criação da sub-rotina
function Fatorial(num: integer): integer;
var
i, fat: integer;
begin
fat := 1;
for i := 1 to num do
begin
fat := fat * i;
end;
Fatorial := fat;
end;
// Chamada da sub-rotina
resultado := Fatorial(5); // O número pode ser substituído por uma variável inteira
Utilização em DELPHI:
// Criação da sub-rotina como biblioteca
function Fatorial(num: integer): integer;
var
i, fat: integer;
begin
fat := 1;
for i := 1 to num do
begin
fat := fat * i;
end;
Fatorial := fat;
end;
// Chamada da sub-rotina como biblioteca
resultado := Fatorial(5); // O número pode ser substituído por uma variável inteira
// Criação da sub-rotina como método da classe TMinhaClasse
function TMinhaClasse.Fatorial(num: integer): integer;
var
i, fat: integer;
begin
fat := 1;
for i := 1 to num do
begin
fat := fat * i;
end;
Fatorial := fat;
end;
// Chamada da sub-rotina como método do objeto meuObjeto
resultado := meuObjeto.Fatorial(5); // O número pode ser substituído por uma variável inteira
Sintaxe em C/C++ e JAVA
// Criação da sub-rotina
TIPO NOME_SUB_ROTINA(TIPO PARAMETRO [{, TIPO PARAMETRO}]) {
// bloco de comandos
return VALOR_RETORNO;
}
// Chamada da sub-rotina
RETORNO = NOME_SUB_ROTINA(ARGUMENTO, [{, ARGUMENTO}]);
Utilização em C/C++:
// Criação da sub-rotina
int fatorial(int num) {
int i, fat;
fat = 1;
for (i = 1; i <= num; i++) {
fat = fat * i;
}
return fat;
}
// Chamada da sub-rotina
resultado = fatorial(5); // O número pode ser substituído por uma variável inteira
// Criação da sub-rotina como método da classe MinhaClasse no C++
int MinhaClasse::fatorial(int num) {
int i, fat;
fat = 1;
for (i = 1; i <= num; i++) {
fat = fat * i;
}
return fat;
}
// Chamada da sub-rotina como método do objeto meuObjeto no C++
resultado = meuObjeto.fatorial(5); // O número pode ser substituído por uma variável inteira
Utilização em JAVA:
// Criação da sub-rotina como método da classe MinhaClasse
public int fatorial(int num) {
int fat;
fat = 1;
for (int i = 1; i <= num; i++) {
fat = fat * i;
}
return fat;
}
// Chamada da sub-rotina como método do objeto meuObjeto
resultado = meuObjeto.fatorial(5); // O número pode ser substituído por uma variável inteira
Sintaxe em PHP
// Criação da sub-rotina
function NOME_SUB_ROTINA(PARAMETRO [{, PARAMETRO}]){
// bloco de comandos
return VALOR_RETORNO;
}
// Chamada da sub-rotina
RETORNO = NOME_SUB_ROTINA(ARGUMENTO [{, ARGUMENTO}]);
Utilização em PHP:
// Criação da sub-rotina
function fatorial($num) {
$fat = 1;
for ($i = 1; $i <= $num; $i++) {
$fat = $fat * $i;
}
return $fat;
}
// Chamada da sub-rotina
resultado = fatorial(5); // O número pode ser substituído por uma variável inteira
Conclusão
As sub-rotinas são utilizadas para manter um conjunto de comandos que realizam determinadas tarefas em um único local, sempre que o desenvolvedor desejar executar a tarefa contida na sub-rotina basta fazer uma chamada a mesma. Essa técnica aumenta a legibilidade do código, facilitando futuras manutenções, sendo esse um dos grandes impulsionadores das sub-rotinas. Esse artigo apresentou os tipos de sub-rotinas, não se aprofundando em detalhes. Em artigos futuros serão apresentados exemplos mais detalhados.
Até o próximo artigo.
