Parâmetro (ciência da computação)

Na ciência da computação, um parâmetro é um valor contido em uma variável ou é o valor resultado de uma expressão mais complexa, que pode ser passado para uma função interna (sub-rotina); a sub-rotina utiliza o valor atribuído no parâmetro para alterar o seu comportamento durante a execução. A maioria das linguagens de programação aceitam a definição de sub-rotinas que aceitam zero ou mais parâmetros.

Parâmetro e Argumento

O termo parâmetro muitas vezes é utilizado como sinónimo de argumento, mas geralmente utiliza-se "parâmetros" quando se faz referência às variáveis situadas entre os parênteses de um método ou função e "argumentos" são os valores atribuídos a esses parâmetros. Na prática da programação, não é necessário distinguir essas diferenças para que a descrição de um código esteja correta.

Para melhor explicar a diferença entre os dois termos pode-se considerar a seguinte sub-rotina escrita na linguagem C:

int somar(int param1, int param2)
{
    return param1 + param2;
}

A sub-rotina "somar" tem dois parâmetros, "param1" e "param2". Ela soma os valores passados e retorna o resultado para o código que realizou a chamada. O código que realiza a chamada pode ser algo como o mostrado abaixo:

int variavelResultado;
int variavel1 = 40;
int variavel2 = 2;

variavelResultado = somar(variavel1, variavel2);

Durante a execução, as variáveis "variavel1" e "variavel2" são inicializadas e passadas (como argumentos) para a sub-rotina "somar". Dentro da rotina, os parâmetros são avaliados e os argumentos '40' e '2' são obtidos. Estes valores são somados, o resultado é retornado e atribuído à variável "variavelResultado". É importante notar que variáveis não são parâmetros e nem argumentos.

Parâmetros por valor

O parâmetro por valor, toda função interna em um programa computacional trabalha com parâmetros que são guardados em variáveis locais (ou variáveis de função); asism quando chamamos uma função devemos definir os valores que serão trabalhados como parâmetros dentro da função que são repassados a esta função armazenados nas variáveis locais durante a execução, este é um processo semelhante a uma atribuição.

Tipos de dados

Em linguagens de programação que utilizam explicitamente tipos de dados fortes, cada tipo de parâmetro é especificado na declaração da sub-rotina. As linguagens que utilizam inferência de tipos tentam descobrir automaticamente o tipo do parâmetro no corpo da função, enquanto as linguagens que utilizam tipos fracos descobrem o tipo do parâmetro em tempo de execução.

Algumas linguagens utilizam palavras reservadas especiais (void, por exemplo) para indicar que uma sub-rotina não possui parâmetros; na teoria dos tipos, estas funções levam uma lista vazia de parâmetros (cujo tipo não é void, mas unit).

Passagem de argumentos

O mecanismo exato para a atribuição de argumentos para parâmetros, chamada de "passagem de argumentos", depende da estratégia de avaliação utilizada para o parâmetro (tipicamente chamada por valor). Esta estratégia pode ser especificada através de palavras reservadas.

Argumento padrão

Algumas linguagens de programação permitem que argumentos padrão (ou, do inglês, default) sejam explicitamente passados através da declaração de uma sub-rotina. Isto permite a omissão do argumento durante a chamada da sub-rotina. Nestes casos, se não é passado um argumento na chamada da sub-rotina, o argumento padrão (que consta da declaração da sub-rotina) é utilizado. Em algumas linguagens é possível dizer que tal argumento é implícito (através da palavra reservada optional, por exemplo) e, quando a chamada não passar o valor, um valor bem conhecido é atribuído ao parâmetro (normalmente null, vazio ou zero).

Lista variável de parâmetros

Algumas linguagens permitem que sub-rotinas aceitem um número variável de parâmetros. O código, ou implementação, destas sub-rotinas deve percorrer esta lista para obter cada um dos parâmetros.

Parâmetros nomeados

Em algumas linguagens de programação os parâmetros de uma sub-rotina podem ser nomeados. Isto permite que o código que chama estas sub-rotinas "documente" a si próprio. Esta abordagem também dá maior flexibilidade ao código que chama a sub-rotina, permitindo a alteração na ordem dos argumentos passados ou mesmo a omissão de algum argumento, se necessário.