++
 Incremento-unario                               (Matemático)
------------------------------------------------------------------------------
 Sintaxis

     ++<idVar>           (preincremento)
     <idVar>++           (postincremento)

 Tipo

     Fecha, numérico

 Operandos

     <idVar> es cualquier identificador válido de CA-Clipper, incluidas
     las variables de campo. Si <idVar> es un campo, debe ir precedido de un
     alias o haber sido declarado con una sentencia FIELD.

     El preincremento sólo puede utilizarse con un valor inicializado de
     tipo numérico o de fecha.

 Descripción

     El operador incremento (++) aumenta en 1 el valor de su operando. Este
     operador suma 1 al valor de <idVar> y asigna este nuevo valor a
     <idVar>.

     El operador ++ puede aparecer antes o después de <idVar>. Si se
     especifica antes de <idVar>, aumenta y asigna su valor antes de
     utilizar <idVar>. Esta notación se denomina notación prefija y es la
     forma utilizada con más frecuencia. Si se especifica el operador
     después de <idVar>, notación sufija, aumenta y asigna el valor después
     de utilizar <idVar>. En otras palabras, la notación sufija retrasa la
     parte de la operación correspondiente a la asignación hasta que no se
     evalúe el resto de la expresión, y la notación prefija da prioridad a
     la parte de asignación sobre el resto de las operaciones.

     Si la referencia a <idVar> es ambigua (es decir, no se declara en el
     momento de la compilación y no se ha identificado explícitamente con un
     alias) se considerará que <idVar> es una variable de memoria (MEMVAR).
     Puede asignar variables de campo declarando el nombre de la variable
     de campo en una sentencia FIELD o haciendo referencia al nombre de
     campo precedido por FIELD->alias o el nombre del área de trabajo.

 Ejemplos

      Este código utiliza el operador preincremento en una sentencia
        de asignación. Por tanto, cuando se consultan, ambas variables
        tienen el mismo valor:

        nValor := 0
        nValorNuevo := ++nValor
        ? nValorNuevo                // Resultado:  1
        ? nValor                     // Resultado:  1

      En este ejemplo, el operador postincremento incrementa en 1 el
        primer operando de la multiplicación y define así su valor en 11. No
        obstante, este nuevo valor no se asigna a la variable nValor hasta
        que no se evalúa toda la expresión. Por lo tanto, su valor sigue
        siendo 10 cuando se realiza la multiplicación, y el resultado de
        10*11 es 110. Finalmente, cuando se vuelve a consultar nValor una
        vez evaluada la expresión, la asignación del postincremento refleja
        su nuevo valor, 11.

        nValor := 10
        ? nValor++ * nValor          // Resultado: 110
        ? nValor                     // Resultado:  11

 To download this example - click here.

See Also: + -- := = (compuesta)