Operadores de incremento y decremento

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda

Los Operadores de incremento y decremento son operadores unarios que agregan o sustraen uno de sus operandos, respectivamente. Son normalmente implementados en lenguajes de programación imperativos. En lenguajes tipo C es normal tener 2 versiones (pre- y post-) de cada operador con semántica ligeramente diferente.

En lenguajes tipo C, el operador de incremento es escrito como ++ y el de decremento como --.

El operador de incremento aumenta el valor de su operando en 1. El operando debe ser un tipo de dato aritmético o puntero, y debe hacer referencia a un objeto modificable. Similarmente, el operador de decremento disminuye el valor de su operando en 1. El valor de los punteros se incrementa (o disminuye) por una cantidad que hace que apunte al siguiente (o anterior) elemento adyacente en memoria.

En lenguajes que admiten ambas versiones de los operadores, los operadores de pre-incremento y pre-decremento aumentan (o disminuyen) sus operandos en 1, y el valor de la expresión es el resultado del incremento (o decremento). En contraste, los operadores de post-incremento y post-decremento incrementan (o decrementan) el valor de sus operandos en 1, pero el valor de la expresión es el valor original de su operando antes del incremento (o decremento). En lenguajes donde el incremento/decremento no es una expresión (Ej.: Go), sólo se necesita una versión (en el caso de Go, solo post operadores).

Dado que el operador de incremento/decremento modifica su operando, el uso de más de una vez dentro de la misma expresión puede producir resultados no definidos. Por ejemplo, en expresiones tales como x  ++x, no está claro en qué orden se deben realizar la resta y el operador de incremento. Situaciones como esta son aun peores cuando se aplican optimizaciones por el compilador, lo que podría dar lugar a un orden de ejecución de operaciones diferente de lo que pretende el programador.

Ejemplos[editar]

Los siguientes fragmentos de código C ilustran las diferencias entre operadores de pre y post incremento/decremento:

int  x;
int  y;
 
// Operadores de incremento
x = 1;
y = ++x;    // x es ahora 2, y es también 2
y = x++;    // x es ahora 3, y es 2
 
// Operadores de decremento
x = 3;
y = x--;    // x es ahora 2, y es 3
y = --x;    // x es ahora 1, y es también 1

El operador de post-incremento es comúnmente usado en los subíndices de vectores. Por ejemplo:

// Suma de elementos de un vector
float sumar_elementos(float vec[], int n)
{
    float  sum = 0.0;
    int    i =   0;
 
    while (i < n)
        sum += vec[i++];    // Post-incremento de i, que recorre
                            //  los n elementos del vector
    return sum;
}

Asimismo, el operador de incremento es comúnmente utilizado con punteros:

// Copia un vector a otro usando punteros
void copiar_vector(float *desde, float *hasta, int n)
{
    while (n-- > 0)            // Bucle que cuenta desde n hasta 0
        *hasta++ = *desde++;   // Copia el elemento *(desde) a *(hasta),
                               //  luego incrementa ambos punteros
}

Tenga en cuenta que estos ejemplos también funcionan en otros lenguajess de programación tipo C, como C++, Java, y C#.

Lenguajes soportados[editar]

En la siguiente lista, aunque incompleta, se enumeran algunos de los principales lenguajes de programación que soportan operadores de incremento/decremento.