++
 Incremento -- unário                              (Matemático)
------------------------------------------------------------------------------

 Sintaxe

     ++<idVar>              (pré-incremento)
     <idVar>++              (pós-incremento)

 Tipo:  Data, numérico

 Operandos

     <idVar> é qualquer identificador válido do Clipper, inclusive
     variáveis de campo.  Caso <idVar> seja um campo, ela deve ser
     referenciada através de um alias ou declarada com a FIELD.

     Além disso, <idVar> deve ser inicializada antes de executar a operaçao
     de incremento, e a variável deve ser do tipo numérico ou data.

 Descriçao

     O operador de incremento (++) incrementa, ou aumenta o valor de seu
     operando em um.  Este operador funciona adicionando um ao valor de
     <idVar> e atribuindo o novo valor a <idVar>.

     O operador ++ pode aparecer antes ou depois de <idVar>.  Especificar o
     operador antes de <idVar>, incrementa e atribui o valor antes que o
     valor seja utilizado.  Isto é chamado de pré-incremento, e é a
     utilizaçao mais comum.  Especificar o operador depois de <idVar>,
     incrementa e atribui o valor depois que ele for utilizado.  Esta
     forma é chamada de pós-incremento.  Declarada de forma diferente, o
     pós-incremento atrasa a porçao de atribuiçao da operaçao até que o
     resto da expressao seja avaliada, e a forma pré-incremento dá
     precedência à atribuiçao antes de todas as outras operaçoes da
     expressao.

     Caso a referência a <idVar> seja ambígua (ou seja, nao declarada em
     tempo de compilaçao e nao explicitamente qualificada com um alias,
     <idVar> sempre é assumida como sendo uma MEMVAR.  As variáveis de campo
     podem ser atribuidas declarando-se o nome da variável de campo em uma
     declaraçao FIELD, ou referindo-se ao nome da variável de campo
     precedido pelo alias FIELD-> ou o nome da área de trabalho.

 Exemplos

       O código a seguir demonstra o operador pré-incremento em uma
        declaraçao de atribuiçao.  Como o incremento ocorre antes que a
        atribuiçao aconteça, ambas as variáveis têm o mesmo valor quando
        consultadas:

        nValue := 0
        nNewValue := ++nValue
        ? nNewValue             // Resulta:   1
        ? nValue                // Resulta:   1

       Neste exemplo, o operador pós-incremento é utilizado para
        aumentar o primeiro operando da operaçao de multiplicaçao em um,
        tornando seu valor 11; porém, a atribuiçao deste novo valor à
        variável nValue nao acontecerá até que toda a expressao seja
        avaliada.  Portanto, seu valor ainda é 10 quando a operaçao de
        multiplicaçao ocorre, e o resultado de 11 * 10 é 110.  Finalmente,
        quando nValue for consultada novamente após a expressao ser
        avaliada, a atribuiçao de pós-incremento é refletida em seu novo
        valor, 11.

        nValue := 10
        ? nValue++ * nValue     // Resulta: 110
        ? nValue                // Resulta:  11
 To download this example - click here.

See Also: + -- := op=