@
 Paso por referencia-unario                      (Especial)
------------------------------------------------------------------------------
 Sintaxis

     @<idVar>

 Operandos

     <idVar> es cualquier identificador de variable válido de CA-Clipper
     que se pasa por referencia. No puede ser ni un campo de base de datos,
     ni un elemento de matriz, pues estos sólo pueden pasarse por valor.

 Descripción

     El operador paso por referencia (@) pasa variables por referencia a
     funciones o procedimientos invocados con la sintaxis de llamada de
     funciones. Es un operador unario que se utiliza como prefijo y cuyo
     operando puede ser cualquier nombre de variable.

     Pasar una variable por referencia significa que se pasa una referencia
     al valor del argumento en lugar de una copia del valor. El parámetro
     receptor hace referencia a la misma posición en la memoria que la del
     argumento. Si la rutina invocada cambia el valor del parámetro
     receptor, también cambia el argumento pasado por la rutina invocante.

     Cuando se pasa una variable por valor se evalúa el argumento y su valor
     se copia en el parámetro receptor. Los cambios que se realicen en el
     parámetro receptor sólo tienen vigencia en la rutina invocada y se
     pierden cuando termina. El método por defecto de pasar argumentos es
     por valor para todos los tipos de datos, incluidas las referencias a
     matrices y objetos.

 Ejemplos

      Este ejemplo muestra la diferencia entre pasar por valor y por
        referencia un argumento a una función definida por el usuario.

        LOCAL nNum := 1                     // Valores iniciales
        LOCAL aMatriz := { "a", "b", "c" }
        //
        CLS
        // Imprimir valores iniciales
        ? VALTYPE(nNum), nNum
        ? VALTYPE(aMatriz), aMatriz[1], aMatriz[2], aMatriz[3]
        //
        Udf1(nNum)                          // Pasar por valor
                                            // (por defecto)
        ? VALTYPE(nNum), nNum               // Resultado:  N, 1
        //
        Udf1(aMatriz[1])                    // Pasar por valor
                                            // (por defecto)
        ? VALTYPE(aMatriz), aMatriz[1],;
              aMatriz[2], aMatriz[3]        // Resultado:
                                            // A, "a" "b" "c"
        //
        Udf2(aMatriz)                       // Pasar una referencia a
           ? VALTYPE(aMatriz),;             // la matriz (por defecto)
             aMatriz[1],;                   // A, "Oi" "b" "c"
                aMatriz[2], aMatriz[3]
        //
        Udf1(@nNum)                         // Obligar a pasar por
                                            // referencia
        ? VALTYPE(nNum), nNum               // Resultado:  N, 1000
        //
        Udf3(@aMatriz)                      // Pasar matriz
                                            // por referencia
        ? VALTYPE(aMatriz)                  // Resultado:  N
        //
        RETURN NIL


        FUNCTION Udf1(nParam)               // Recibir como un
        ? nParam                            // parámetro local
        nParam := 1000
        ? nParam
        RETURN NIL
        //
        FUNCTION Udf2( aParam )             // Recibir como un
        ? VALTYPE(aParam), aParam[1]        // parámetro local
        aParam[1] := "Oi!"
        ? aParam[1]
        RETURN NIL
        //
        FUNCTION Udf3(aParam)               // Recibir como un
        ? VALTYPE(aParam), aParam[1]        // parámetro local
        aParam := 1000
        ? aParam
        RETURN NIL


 To download this example - click here.

See Also: FUNCTION PROCEDURE