Parâmetros

Os parâmetros são divididos em parâmetros formais e parâmetros reais

Parâmetros formais

O termo em inglês é Formal Parameter, normalmente chamado apenas de parâmetro formal.

Um parâmetro formal é uma variável local especial escrita dentro dos parênteses na declaração do método, não é uma variável definida no interior do corpo do método.

As duas variáveis dentro dos parênteses após o nome da função abaixo são parâmetros formais. Quem já estudou a linguagem C deve estar familiarizado com esse conceito.

// x, y são dois parâmetros formais
public void PrintArea(int x, float y )
{
}
Code language: C# (cs)

1. Possui tipo de dado e nome de variável, permite leitura e gravação;
2. Definido fora do corpo do método, é inicializado automaticamente antes da execução do método (exceto parâmetros de saída out);
3. Vários parâmetros são separados por vírgulas, não há limite para a quantidade;
4. Dentro do corpo do método, sua utilização é idêntica às variáveis locais comuns.

Em outras palavras, o parâmetro formal é uma variável local especial usada para receber os valores passados na chamada da função. A atribuição acontece no momento da invocação; quando o fluxo de execução entra na função, o parâmetro formal já tem seu valor definido.

public void PrintArea( int x, float y )
{
    float area = x * y; // x, y são parâmetros formais, area é uma variável local comum para guardar o produto de x e y
    Console.WriteLine($"Calcular área: { x } * { y } = { area }");
}
Code language: C# (cs)

Exemplo executável

class Program
{
    static void Main()
    {
        Program program = new Program();
        program.PrintArea(10,6.5F);
    }

    public void PrintArea(int x, float y)
    {
        float area = x * y; // x, y são parâmetros formais, area é uma variável local comum para guardar o produto de x e y
        Console.WriteLine($"Calcular área: {x} * {y} = {area}");
    }
}Code language: C# (cs)

Saída

Calcular área: 10 * 6.5 = 65

Ao chamar a função, é equivalente a inicializar x com 10 e y com 6.5

A letra F após 6.5F indica que esse valor é um número de ponto flutuante de precisão simples float. Sem o sufixo F, o compilador interpreta como tipo double e gera um erro.

O float de precisão simples e o double de precisão dupla ocupam quantidades diferentes de bits na memória, por isso diferem na precisão dos valores armazenados.

A precisão representa o número máximo de casas decimais que um tipo consegue armazenar corretamente. Ultrapassar esse limite pode causar imprecisões, e isso depende da quantidade de bits reservada na memória.

x e y são parâmetros formais. Na chamada da função

funciona como se inicializássemos duas variáveis locais com esses valores.

int x = 10;

float y = 6.5F;Code language: C# (cs)

Atenção:

O tipo, a ordem e o formato dos parâmetros formais junto ao nome do método formam a assinatura do método. Podemos encarar a assinatura como um documento de identidade da função. Estudaremos assinaturas mais tarde: assinaturas iguais significam métodos idênticos, também veremos a sobrecarga de funções.

---

Parâmetros reais

Termo em inglês: Actual Parameters (parâmetros reais, também chamados argumentos)

Ao invocar um método, as variáveis ou expressões usadas para atribuir valores aos parâmetros formais são chamadas de parâmetros reais. Antes da execução do método, os valores dos parâmetros reais inicializam os parâmetros formais correspondentes.

1. Os parâmetros reais ficam dentro dos parênteses na chamada do método;
2. Regra de compatibilidade de tipos: o tipo do parâmetro real deve combinar com o parâmetro formal correspondente ou o compilador aceitar a conversão implícita de tipos;
3. Combinação por posição: por padrão, o pareamento ocorre sequencialmente (parâmetros posicionais).

Por exemplo, altere a função Main do código anterior conforme abaixo. No ponto de chamada, o primeiro argumento é o literal 5 e o segundo é a variável local f.

Program program = new Program();
float f = 6.3F;
program.PrintArea(5,f);
// 5 é parâmetro real como expressão constante, f é parâmetro real de variável
// Combinação posicional: 5 → x, f → y
Code language: C# (cs)

Na invocação, os valores dos parâmetros reais são copiados para os parâmetros formais da mesma posição e depois o corpo do método é executado.

---

Parâmetros posicionais

class Calculate
{
    // Dois parâmetros formais int
    public int Sum(int x, int y)
    {
        return x + y;
    }

    // Dois parâmetros formais float
    public float Avg(float x, float y)
    {
        return (x + y) / 2.0F;
    }
}

class Program
{
    static void Main()
    {
        Calculate cal = new Calculate();
        int num = 6;

        // Sum: parâmetro real int corresponde ao parâmetro formal int
        Console.WriteLine("Sum: {0} and {1} is {2}",
            5, num, cal.Sum(5, num));

        // Avg: parâmetro real int convertido implicitamente para float
        Console.WriteLine("Avg: {0} and {1} is {2}",
            5, num, cal.Avg(5, num));
    }
}
Code language: PHP (php)

Resultado da saída

Sum: 5 and 6 is 11
Avg: 5 and 6 is 5.5Code language: HTTP (http)

C# suporta a conversão implícita de tipos de menor alcance para tipos de maior alcance (int → float). A conversão inversa float → int causa erro de compilação e necessita de conversão explícita manual.

num é uma variável int. Quando passada como parâmetro real para o parâmetro float da função Avg, o compilador faz conversão implícita de int para float automaticamente sem erros. O intervalo de valores do int está totalmente contido no intervalo do float.

Por isso, passar um int para float não causa perda de dados. É como colocar uma caixa pequena dentro de uma caixa maior. O contrário não funciona, não dá para colocar uma caixa grande dentro de uma pequena.

Parâmetros