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 tipo C presentan dos versiones (pre y post) de cada operador con una semántica ligeramente diferente.
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 se escribe como --. Varios otros lenguajes usan 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 aumentan (o disminuyen) en una cantidad que los hace apuntar al elemento siguiente (o anterior) adyacente en la memoria.
En idiomas que admiten ambas versiones de los operadores:
En 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 de publicación).
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. Este tipo de expresiones generalmente invocan un comportamiento indefinido y deben evitarse.
En lenguajes con punteros escritos como C, el operador de incremento lleva 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 una matriz, al incrementarlo (o disminuirlo) el puntero apunta al elemento "siguiente" (o "anterior") de esa matriz. Por lo tanto, incrementar un puntero a un número entero hace que apunte al siguiente número entero (normalmente aumenta el valor del puntero en 4); [1] 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. [2]
El siguiente fragmento de código C ilustra la diferencia entre los operadores de incremento y decremento previos y posteriores :
intx ; int 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 reduce en 1 x = 1 ; y = x- ; // y es 1, x ahora es 0 En idiomas que carecen de estos operadores, los resultados equivalentes requieren una línea adicional de código:
# Pre-incremento: y = ++x x = 1 x = x + 1 # x ahora es 2 (puede escribirse 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 post-incremento se usa comúnmente 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 yo = 0 ; mientras ( i < n ) suma += arr [ i ++ ]; // Incremento posterior de i, que avanza // a través de n elementos de la matriz return sum ; } El operador post-incremento también se usa comúnmente con punteros :
// Copiar una matriz a otra void copy_array ( float * src , float * dst , int n ) { while ( n - > 0 ) // Bucle que cuenta atrás de n a 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 de 1 a 3. printf ( "%d" , ++ c ); // esta declaración incrementa c en 1, luego se muestra c. devolver 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 depreció desde la versión 2.2 [13] y se eliminó a partir de la versión 3.0. [14]
Pascal , Delphi , Modula-2 y Oberon utilizan funciones ( inc(x)y dec(x)) en lugar de operadores.
En particular, Python y Rust no admiten estos operadores.
El concepto fue introducido en el lenguaje de programación B alrededor de 1969 por Ken Thompson . [15]
Thompson fue un paso más allá al inventar los operadores ++ y --, que incrementan o disminuyen; su posición de prefijo o posfijo 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 en el 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 existía el 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ó a Thompson tales operadores; la generalización para convertirlos tanto en prefijo como en sufijo 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 traslación de ++x era menor que la de x=x+1.
+=y-={{cite book}}: CS1 maint: multiple names: authors list (link)