Modularização - Assiatura

O objetivo deste tópico é auxiliar aqueles que possuem alguma dificuldade na sintaxe em pseudocódigo de uma função ou procedimento. No entanto, tudo será explicado de maneira clara e objetiva, por isso é um tutorial que não será breve mas isto é devido as linhas de algoritmos (mesmo sendo curtos).

Entendo o Escopo de uma Rotina

Podemos entender como escopo de uma rotina, o bloco de código que delimita o início e o fim de um módulo.

procedimento calc()
inicio
fimprocedimento

Um procedimento e uma função têm o mesmo escopo, exceto o retorno. De resto, a assinatura de uma função pode ser igual a de um procedimento (exceto o retorno). Exemplos:

Rotinas sem Parâmetros

Procedimento
procedimento calc()
var
 x: real
inicio
 x = x + 1
fimprocedimento

Função
funcao calc(): real
var
 x: real
inicio
 x = x + 1
retorne x
fimfuncao

Tanto este procedimento acima, quanto a função realizam o mesmo cálculo. Porém, não recebem nenhum valor como argumento. Nota-se que primeiro é declarado o tipo de rotina (função ou procedimento), depois o nome que este módulo será chamado no programa principal ou em outros módulos dependendo tipo (global, local) e entre parênteses se declara os parâmetros, caso haja ou não.

Se o tipo de rotina é um procedimento, então após escrever o código virá um fimprocedimento. Se a rotina for uma função, depois do código virá fimfuncao. Simples, porém é preciso ficar extremamente atento nesse detalhe.

Uma função merece mais atenção ainda, porque antes do fimfuncao ela precisa ter um retorno, senão não faz sentido ser uma função. O tipo de retorno é declarado após os parênteses.

Rotinas com Parâmetros

Parâmetro é um valor que uma rotina espera receber do programa principal ou de outro módulo para poder trabalhar. Tanto uma função quanto procedimento podem ter parâmetros. Exemplos:

Procedimento
procedimento calc(x: real)
var
 y: real
inicio
 y = x  * x
fimprocedimento

Função
funcao calc(x: real): real
var
 y: real
inicio
 y = x * x
 retorne y
fimfuncao

O número de parâmetros que uma rotina pode ter depende muito da necessidade do programa. Exemplo:

funcao calc(m: real, a: real): real
var
 f: real
inicio
 f = m * g
 retorne f
fimfuncao

A função acima possui dois parâmetros: a e m. É um exemplo de módulo que calcula a força de um corpo, que é o produto da massa pela aceleração por ele adquirida. Nesse exemplo foi utilizado dois parâmetros em uma função, mas o mesmo é válido em um procedimento, porém, procedimentos como é importante enfatizar, não possuem retorno.

Também é importante ressaltar que os parâmetros são separados por vírgula.

Parâmetros e Retorno de uma Função

Será que o tipo de retorno de uma função deve ser sempre igual ao tipo de parâmetro e vice-versa? A resposta é não.
Posso ter um módulo que recebe argumentos de tipos diferentes e ainda faz um retorno com outro tipo. Exemplo:

funcao cadastro(nome: caractere, idade: inteiro): logico
var
situacao: logico
inicio
se (nome <> "") e (idade >= 18) entao
   retorne VERDADEIRO
senao
   retorne FALSO
fimse
fimfuncao

Nesse caso acima temos uma peculiaridade. A função pode retornar um valor ou outro, "VERDADEIRO" ou "FALSO" que são constantes que assumem o valor 0 ou 1. Mas o detalhe desse exemplo, é que ele recebe como parâmetro valores do tipo inteiro e literais (ou caracteres) e retorna um valor do tipo lógico.

Argumento x Parâmetro - Qual a Diferença?

Argumento é aquilo que eu passo para o parâmetro. É um valor que eu irei jogar dentro de um módulo.
Parâmetro é aquilo que um módulo espera receber.

Um Argumento e um Parâmetro devem ter o mesmo nome?

A resposta é: não. Geralmente dá-se nomes diferentes para não bagunçar o código, mas se ambos tiverem o mesmo nome, o que for feito em um módulo não irá afetar o valor que também foi passado ou está em outro módulo, a menos que seja global. Exemplo:

algoritmo "ex"
var
 x: inteiro
inicio
 x = 5
 modificaX(x) //x está sendo passado como argumento
 escreva("Principal: ", x)
fimalgoritmo

procedimento modificaX(x: inteiro) //x é o parâmetro que irá receber o valor de algum argumento
var
inicio
 x = x - 1
 escreva("Módulo: ", x)
fimprocedimento

Saída
Módulo: 4
Principal: 5


Motivo
Embora x seja modificado no módulo, o x que está no escopo do módulo é só uma cópia do valor de x que está no programa principal mas com o mesmo nome. Confuso?? Bem, o que importa saber é que o x do módulo e o x do programa principal são variáveis diferentes. Se o x fosse global, aí a história mudaria, mas ela não é. Esse tipo de passagem se chama passagem por referência, estou dizendo que um hipotético endereço 0x0004000 = 5 e que 0x0006810 é igual 5 também, mas dei a mesma etiqueta para essas variáveis diferentes.

Obs.: dentro do mesmo escopo, variáveis iguais ou diferentes não podem ter o mesmo nome.

Matrizes e Vetores - Os Diferentões

Em pseucódigo temos vetor dessa forma: vetorX[3]: inteiro.

• nome: pode ser qualquer nome que comece com uma letra e não utilize símbolos especiais, como qualquer outra variável.
  
• tamanho: é a quantidade de elementos que o vetor possuirá.
  
• tipo: é o tipo do vetor (inteiro, caractere ou também chamado de literal, lógico, real...).
  

Com matrizes a situação é semelhante, porém a dimensão aumenta. Com uma matriz bidimensional temos:
matrizY[3][3]: inteiro

Sendo que o primeiro par colchetes indica o número de linhas e o segundo o número de colunas.

E como passar um vetor e uma matriz para uma rotina? Será explicado a seguir:

Passando um vetor ou uma matriz para uma Rotina

É preciso passar apenas o nome da matriz ou vetor. Exemplo:

notas[5]: real
gabarito[5][5]: real
calculaMedia(notas, gabarito)

Retornando um vetor ou matriz

Um módulo que possui em sua assinatura parâmetros que são vetores ou matrizes, precisa que os mesmos sejam declarados assim:
nomeDoVetor[]: <tipoDoVetor>
nomeDaMatriz[][]: <tipoDaMatriz>

Obs.: não precisa informar o tamanho do vetor ou matriz, mas em algumas linguagens de programação é preciso informar o tamanho da coluna da matriz como nomeDaMatriz[][<tamanho>]. Exemplos:


Procedimento
procedimento calculaMedia(notas[]: real)
...

Função
funcao brasileirao(jogos[][]: inteiro): inteiro
var
final[6][6]: inteiro
...
retorne final
fimfuncao

Chamando uma Função e Procedimento

Procedimentos podem ser chamados dessa forma:
calcAlgumacoisa()

Já funções, elas retornam valor, por isso é importante que uma variável seja igual ao retorno da função.
...
var
x: inteiro
inicio
x = calcOutracoisa()
...

Assim o valor retornado no programa pode ser tratado, exemplo:

algoritmo "ordenaVetor"
var
  vetor[5]: inteiro
  i: inteiro
inicio
vetor = ordena(vetor)

para (i = 1; i <= 5; i++) faca
 escrevaL(vetor[i])
fimpara
fimalgoritmo

funcao ordena(vet[]: inteiro): inteiro
...
retorne vet
fimfuncao

Tendo em mente esses princípios básicos da lógica de algoritmos, já é um meio caminho andado para assuntos futuros que virão e que isto auxilia tanto na lógica em si como na construção de algoritmos mais fáceis de serem implementados ou codificados em linguagem de programação.

*Este tópico será editado mais vezes, achou um erro? Comente!