Operadores de incremento y decremento

Los operadores de incremento y decremento son operadores unarios que aumentan o disminuyen su operando en uno.

Son comunes en los lenguajes de programación imperativos . Los lenguajes tipo C presentan dos versiones (previa y posterior) de cada operador con semánticas ligeramente diferentes.

En los lenguajes sintácticamente derivados de B (incluidos C y sus diversos derivados), el operador de incremento se escribe como ++y el operador de decremento se escribe como --. Varios otros lenguajes utilizan las funciones inc(x) y dec(x).

El operador de incremento aumenta, y el operador de decremento disminuye, el valor de su operando en 1. El operando debe ser de tipo aritmético o puntero , y debe hacer referencia a un objeto de datos modificable . Los valores de los punteros se incrementan (o disminuyen) en una cantidad que hace que apunten al siguiente (o anterior) elemento adyacente en la memoria.

En los idiomas que admiten ambas versiones de los operadores:

• Los operadores de preincremento y predecremento incrementan (o decrementan) su operando en 1, y el valor de la expresión es el valor incrementado (o decrementado) resultante.
• Los operadores de postincremento y postdecremento aumentan (o disminuyen) el valor de su operando en 1, pero el valor de la expresión es el valor del operando antes de la operación de incremento (o decremento).

En lenguajes donde el incremento/decremento no es una expresión (por ejemplo, Go ), solo se necesita una versión (en el caso de Go, solo operadores post).

Dado que el operador de incremento/decremento modifica su operando, el uso repetido de dicho operando dentro de la misma expresión puede generar resultados indefinidos según el lenguaje. En C, por ejemplo ^{[ 1 ]} , en expresiones como x - ++x, no está claro en qué secuencia deben realizarse las operaciones de resta e incremento. En ese caso, dichas expresiones provocan un comportamiento indefinido y deben evitarse.

En lenguajes con punteros tipados como C, el operador de incremento mueve el puntero al siguiente elemento de ese tipo, aumentando el valor del puntero en el tamaño de ese tipo. Cuando un puntero (del tipo correcto) apunta a cualquier elemento de un array, incrementarlo (o decrementarlo) hace que el puntero apunte al siguiente (o anterior) elemento de ese array. Así, incrementar un puntero a un entero hace que apunte al siguiente entero (normalmente aumentando el valor del puntero en 4); ^{[ 2 ]} incrementar un puntero a una estructura de tamaño 106 bytes hace que apunte a la siguiente estructura aumentando el valor del puntero en 106. ^{[ 3 ]}

El siguiente fragmento de código C ilustra la diferencia entre los operadores de incremento y decremento previos y posteriores :

entero x ; entero y ;// Operadores de incremento // Preincremento: x se incrementa en 1, luego a y se le asigna el valor de x x = 1 ; y = ++ x ; // x ahora es 2, y también es 2// Postincremento: a y se le asigna el valor de x, luego x se incrementa en 1 x = 1 ; y = x ++ ; // y es 1, x ahora es 2// Operadores de decremento // Predecremento: x se decrementa en 1, luego a y se le asigna el valor de x x = 1 ; y = -- x ; // x ahora es 0, y también es 0// Postdecremento: a y se le asigna el valor de x, luego x se decrementa en 1 x = 1 ; y = x -- ; // y es 1, x ahora es 0

En los lenguajes que carecen de estos operadores, los resultados equivalentes requieren una línea de código adicional:

# Preincremento: y = ++x x = 1 x = x + 1 # x ahora es 2 (se puede escribir como "x += 1" en Python) y = x # y también es 2# Postincremento: y = x++ x = 1 y = x # y es 1 x = x + 1 # x ahora es 2

El operador de postincremento se usa comúnmente con subíndices de matrices . Por ejemplo:

// Suma los elementos de un array float sum_elements ( float arr [], int n ) { float sum = 0.0 ; int i = 0 ;while ( i < n ) suma += arr [ i ++ ]; // Postincremento de i, que avanza // a través de n elementos del array return suma ; }

El operador de postincremento también se usa comúnmente con punteros :

// Copia un array a otro void copy_array ( float * src , float * dst , int n ) { while ( n -- > 0 ) // Bucle que cuenta hacia atrás desde n hasta cero * dst ++ = * src ++ ; // Copia el elemento *(src) a *(dst), // luego incrementa ambos punteros }

Estos ejemplos también funcionan en otros lenguajes similares a C, como C++ , Java y C# .

• El operador de incremento se puede ilustrar con un ejemplo:

  #include <stdio.h> int main () { int c = 2 ; printf ( "%d \n " , c ++ ); // esta instrucción muestra 2, luego c se incrementa en 1 a 3. printf ( "%d" , ++ c ); // esta instrucción incrementa c en 1, luego se muestra c. return 0 ; }

  • Producción:

    2 4

La siguiente lista, aunque no es exhaustiva ni completa, enumera algunos de los principales lenguajes de programación que admiten los operadores de incremento y decremento.

El Swift de Apple alguna vez admitió estos operadores, pero han sido descontinuados desde la versión 2.2 ^{[ 14 ]} y eliminados a partir de la versión 3.0. ^{[ 15 ] [ 16 ]}

Pascal , Delphi , Modula-2 y Oberon utilizan funciones ( inc(x)y dec(x)) en lugar de operadores. Tcl utiliza el incrcomando.

Cabe destacar que Python , Ruby y Rust no admiten estos operadores.

El concepto fue introducido en el lenguaje de programación B alrededor de 1969 por Ken Thompson . ^{[ 17 ]}

Thompson fue un paso más allá al inventar los operadores ++ y --, que incrementan o decrementan; su posición prefija o postfija determina si la modificación ocurre antes o después de anotar el valor del operando. No estaban presentes en las primeras versiones de B, pero aparecieron posteriormente. A menudo se supone que se crearon para utilizar los modos de direccionamiento de autoincremento y autodecremento proporcionados por el DEC PDP-11, en el que C y Unix se popularizaron inicialmente. Esto es históricamente imposible, ya que no existía el PDP-11 cuando se desarrolló B. Sin embargo, el PDP-7 sí tenía algunas celdas de memoria de "autoincremento", con la propiedad de que una referencia de memoria indirecta a través de ellas incrementaba la celda. Esta característica probablemente le sugirió a Thompson la creación de dichos operadores; la generalización para que fueran tanto prefijos como postfijos fue suya. De hecho, las celdas de autoincremento no se utilizaron directamente en la implementación de los operadores, y una motivación más fuerte para la innovación fue probablemente su observación de que la traducción de ++x era menor que la de x=x+1.

• Asignación aumentada – +=para -=operadores
• PDP-7
• PDP-11
• Función sucesora