Los operadores de incremento y decremento son operadores unarios que aumentan o disminuyen su operando en uno.
Se encuentran comúnmente en lenguajes de programación imperativos . Los lenguajes como C presentan dos versiones (pre y post) de cada operador con semánticas ligeramente diferentes.
En los lenguajes derivados sintácticamente de B (incluido C y sus diversos derivados), el operador de incremento se escribe como ++y el operador de decremento 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 tener un tipo de datos aritmético o de puntero , y debe hacer referencia a un objeto de datos modificable . Los valores de los punteros se incrementan (o disminuyen) en una cantidad que los hace apuntar al siguiente (o anterior) elemento adyacente en la memoria.
En idiomas que admiten ambas versiones de los operadores:
En los idiomas donde incremento/decremento no es una expresión (por ejemplo, Go ), solo se necesita una versión (en el caso de Go, solo operadores posteriores).
Dado que el operador de incremento/decremento modifica su operando, el uso de dicho operando más de una vez dentro de la misma expresión puede producir resultados indefinidos. Por ejemplo, en expresiones como x - ++x, no está claro en qué secuencia se deben realizar las operaciones de resta e incremento. Tales expresiones generalmente invocan un comportamiento indefinido y se deben evitar.
En lenguajes con punteros tipados como C, el operador de incremento hace que el puntero avance hasta el siguiente elemento de ese tipo, incrementando el valor del puntero en el tamaño de ese tipo. Cuando un puntero (del tipo correcto) apunta a cualquier elemento de una matriz, el incremento (o decremento) hace que el puntero apunte al elemento "siguiente" (o "anterior") de esa matriz. Por lo tanto, el incremento de un puntero a un entero hace que apunte al siguiente entero (normalmente incrementando el valor del puntero en 4); [1] el incremento de un puntero a una estructura de tamaño 106 bytes hace que apunte a la siguiente estructura incrementando el valor del puntero en 106. [2]
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 // Pre-incremento: 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 // Post-incremento: 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 // Pre-decremento: 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 // Post-decremento: 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 idiomas 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# Post-incremento: y = x++ x = 1 y = x # y es 1 x = x + 1 # x ahora es 2
El operador de post-incremento se utiliza habitualmente con subíndices de matriz . Por ejemplo:
// Suma los elementos de una matriz float sum_elements ( float arr [], int n ) { float sum = 0.0 ; int i = 0 ; mientras ( i < n ) suma += arr [ i ++ ]; // Incremento posterior de i, que recorre // n elementos de la matriz return suma ; } El operador post-incremento también se utiliza comúnmente con punteros :
// Copiar una matriz a otra void copy_array ( float * src , float * dst , int n ) { while ( n -- > 0 ) // Bucle que cuenta regresivamente 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# .
#include <stdio.h> int main () { int c = 2 ; printf ( "%d \n " , c ++ ); // esta declaración muestra 2, luego c se incrementa en 1 hasta 3. printf ( "%d" , ++ c ); // esta declaración incrementa c en 1, luego se muestra c. return 0 ; } 2 4La siguiente lista, aunque no es completa ni exhaustiva, enumera algunos de los principales lenguajes de programación que admiten los operadores de incremento y decremento.
Swift de Apple alguna vez admitió estos operadores, pero se dejaron de usar a partir de la versión 2.2 [13] y se eliminaron a partir de la versión 3.0. [14] [15]
Pascal , Delphi , Modula-2 y Oberon utilizan funciones ( inc(x)y dec(x)) en lugar de operadores.
Cabe destacar que Python y Rust no admiten estos operadores.
El concepto fue introducido en el lenguaje de programación B alrededor de 1969 por Ken Thompson . [16]
Thompson fue un paso más allá al inventar los operadores ++ y --, que incrementan o decrementan; su posición de prefijo o sufijo determina si la alteración ocurre antes o después de anotar el valor del operando. No estaban en las primeras versiones de B, pero aparecieron a lo largo del camino. La gente suele suponer que fueron creados para utilizar los modos de dirección de incremento y decremento automático proporcionados por el DEC PDP-11 en el que C y Unix se hicieron populares por primera vez. Esto es históricamente imposible, ya que no había PDP-11 cuando se desarrolló B. El PDP-7, sin embargo, tenía algunas celdas de memoria de "incremento automático", con la propiedad de que una referencia de memoria indirecta a través de ellas incrementaba la celda. Esta característica probablemente sugirió tales operadores a Thompson; la generalización para convertirlos en prefijos y sufijos fue suya. De hecho, las celdas de incremento automático 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.
+=y-={{cite book}}: CS1 maint: varios nombres: lista de autores ( enlace )