Parámetros

Los parámetros se dividen en parámetros formales y parámetros reales

Parámetros formales

Su nombre en inglés es Formal Parameter, normalmente llamado parámetro formal.

Un parámetro formal es una variable local especial que se escribe dentro de los paréntesis en la declaración del método, no es una variable definida dentro del cuerpo del método.

Las dos variables que aparecen entre paréntesis tras el nombre de la función que mostramos abajo son parámetros formales. Quien haya estudiado el lenguaje C reconocerá este concepto fácilmente.

// x, y son dos parámetros formales
public void PrintArea(int x, float y )
{
}
Lenguaje del código: C# (cs)

1. Tienen tipo de dato y nombre de variable, permiten lectura y escritura;
2. Se definen fuera del cuerpo del método y se inicializan automáticamente antes de ejecutar el método (salvo los parámetros de salida out);
3. Varios parámetros se separan con comas y no hay límite en su cantidad;
4. Se usan dentro del cuerpo del método exactamente igual que las variables locales normales.

En definitiva, el parámetro formal es una variable local especial, destinada a recibir los valores enviados al invocar la función. Su asignación ocurre en el momento de la llamada; cuando el flujo de ejecución entra dentro de la función, el parámetro formal ya tiene valor asignado.

public void PrintArea( int x, float y )
{
    float area = x * y; // x, y son parámetros formales, area es una variable local común para guardar el producto de x e y
    Console.WriteLine($"Calcular área: { x } * { y } = { area }");
}
Lenguaje del código: C# (cs)

Ejemplo ejecutable

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 son parámetros formales, area es una variable local común para guardar el producto de x e y
        Console.WriteLine($"Calcular área: {x} * {y} = {area}");
    }
}Lenguaje del código: C# (cs)

Salida

Calcular área: 10 * 6.5 = 65

Al invocar la función, equivale a inicializar x con valor 10 e y con valor 6.5

La letra F tras 6.5F indica que se trata de un número de coma flotante de precisión simple float. Sin el sufijo F, el compilador lo interpreta como tipo double y dará error.

El float de precisión simple y el double de precisión doble ocupan distinta cantidad de bits en memoria, por eso difiere la precisión al almacenar valores.

La precisión es la cantidad máxima de dígitos decimales que un tipo puede guardar de forma fiable. Si se supera ese límite, los valores pueden volverse imprecisos, y esto depende de los bits reservados en memoria.

x e y son parámetros formales. Al realizar la invocación

es equivalente a inicializar dos variables locales con esos valores.

int x = 10;

float y = 6.5F;Lenguaje del código: C# (cs)

Aviso:

El tipo, orden y formato de los parámetros formales junto al nombre del método forman la firma del método. Podemos entender la firma como el documento de identidad de la función. Estudiaremos las firmas más adelante: si coinciden las firmas se considera el mismo método, también veremos la sobrecarga de funciones.

---

Parámetros reales

Término en inglés: Actual Parameters (parámetros reales, también llamados argumentos)

Al invocar un método, las variables o expresiones que sirven para asignar valores a los parámetros formales se denominan parámetros reales. Antes de ejecutar el método, los valores de los parámetros reales inicializan los parámetros formales correspondientes.

1. Los parámetros reales se escriben dentro de los paréntesis en la invocación del método;
2. Regla de compatibilidad de tipos: el tipo del parámetro real debe coincidir con el parámetro formal asociado o el compilador debe admitir la conversión implícita de tipos;
3. Correspondencia posicional: por defecto se emparejan en orden (parámetros posicionales).

Por ejemplo, modificamos la función Main del código anterior como se muestra. El primer argumento de la llamada es el literal 5, el segundo es la variable local f.

Program program = new Program();
float f = 6.3F;
program.PrintArea(5,f);
// 5 es parámetro real como expresión constante, f es parámetro real de variable
// Correspondencia posicional: 5 → x, f → y
Lenguaje del código: C# (cs)

En la invocación, los valores de los parámetros reales se copian a los parámetros formales de la misma posición y después se ejecuta el cuerpo del método.

---

Parámetros posicionales

class Calculate
{
    // Dos parámetros formales de tipo int
    public int Sum(int x, int y)
    {
        return x + y;
    }

    // Dos parámetros formales de tipo 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 coincide con parámetro formal int
        Console.WriteLine("Sum: {0} and {1} is {2}",
            5, num, cal.Sum(5, num));

        // Avg: parámetro real int convertido implícitamente a float
        Console.WriteLine("Avg: {0} and {1} is {2}",
            5, num, cal.Avg(5, num));
    }
}
Lenguaje del código: PHP (php)

Resultado de salida

Sum: 5 and 6 is 11
Avg: 5 and 6 is 5.5Lenguaje del código: HTTP (http)

C# admite la conversión implícita de tipos de menor rango a tipos de mayor rango (int → float). La conversión inversa float → int genera error de compilación y requiere conversión explícita manual.

num es variable tipo int. Al pasarla como parámetro real al parámetro float de la función Avg, el compilador hace la conversión implícita automáticamente sin errores. El rango de valores de int está totalmente incluido dentro del rango de float.

Por eso al pasar un int a float no hay pérdida de datos. Es como meter una caja pequeña dentro de una grande. Al revés no se puede meter una caja grande en una pequeña.

Parámetros