Espacios de nombres
Variantes
Acciones

Operadores de incremento/decremento

De cppreference.com
< cpp‎ | language
 
 
 
Expresiones
General
categorías de valores (lvalue, rvalue, xvalue)
orden de evaluación (puntos de secuencia)
expresiones constantes
Operadores
Operadores de asignación: a=b, a+=b, a-=b, a*=b, a/=b, a%=b, a&=b, a|=b, a^=b, a<<=b, a>>=b
Operadores aritméticos: +a, -a, a+b, a-b, a*b, a/b, a%b, ~a, a&b, a|b, a^b, a<<b, a>>b
Incremento y decremento: ++a, --a, a++, a--
Operadores lógicos: a||b, a&&b, !a
Operadores de comparación: a==b, a!=b, a<b, a>b, a<=b, a>=b, a<=>b(C++20)
Operadores de acceso a miembro: a[b], *a, &a, a->b, a.b, a->*b, a.*b
Otros operadores: a(...), a,b, a?b:c
sizeof
alignof (C++11)
expresión new
expresión delete
typeid
 

Los operadores de incremento/decremento aumentan o disminuyen el valor del objeto.

Nombre operador Sintaxis Sobrecargable Ejemplos de prototipo (para class T)
Definición dentro de la clase Definición fuera de la clase
pre-incremento ++a Si T& T::operator++(); T& operator++(T& a);
pre-decremento --a Si T& T::operator--(); T& operator--(T& a);
post-incremento a++ Si T T::operator++(int); T operator++(T& a, int);
post-decremento a-- Si T T::operator--(int); T operator--(T& a, int);
Notas
  • La versión con prefijo del operador integrado devuelve referencias y las versión con postfijo devuelve valores, y las sobrecargas definidas por usuario típicas siguen este patrón luego los operadores definidos por usuario se pueden usar dela misma manera que los integrados. Sin embargo, en una sobrecarga de operador definida por usuario, se puede usar cualquier tipo como tipo de retorno (incluyendo void).
  • El parámetro int es un parámtero ficticio que se usa para distinguir entre las versiones prefijas y postfijas de los operadores. Cuando se llama al operador postfijo definido por usuario, el valor que se pasa en el parámetro siempre es cero, aunque se puede modificar llamando al operador mediante la notación de llamada (por ejemplo, a.operator++(2) o operator++(a, 2)).

Contenido

[editar] Explicación

Los operadores de pre-incremento y pre-decremento incrementan o decrementan el valor del objeto y devuelven una referencia al resultado.

Post-incremento y post-decremento crean una copia del objeto, incrementan o decrementan el valor del objeto y devuelven la copia realizada antes del incremento o decremento.

[editar] Operadores de prefijo integrados

Las expresiones de incremento y decremento con prefijo tienen la forma:

++ expr
-- expr
1) prefijo incremento (pre-incremento)
2) prefijo decremento (pre-decremento)

El operando expr del operador prefijo de incremento o decremento integrado debe ser un lvalue modificable (no constante) de tipo aritmético no booleano o puntero a tipo objecto completo. Para operandos no booleanos, la expresión ++x es exactamente equivalente a x += 1, y la expresión --x es exactamente equivalente a x -= 1, es decir, el prefijo incremento o decremento es una expresión lvalue que identifica el operando modificado. Todas las reglas de conversión aritmética y aritmética de punteros definidas para operadores aritméticos se aplican y determina la conversión implícita (si hay) aplicada al operando y al tipo de retorno de la expresión.

Si el operando del operador de pre-incremento es de tipo bool, se pone a true (obsoleto). (hasta C++17)

En la resolución de sobrecarga de operadores definidos por usuario, para cada tipo aritmético opcionalmente cualificado volátil A que no sea bool, y para cada puntero opcionalmente cualificado volátil P a tipo objeto opcionalmente calificado constante y/o volátil, los siguientes modelos de función participan en la resolución de sobrecarga:

A& operator++(A&)
bool& operator++(bool&)
(obsoleto)(hasta C++17)
P& operator++(P&)
A& operator--(A&)
P& operator--(P&)

[editar] Operadores postfijos integrados

Las expresiones postfijas de incremento y decremento tienen la forma:

expr ++
expr --
1) incremento postfijo (post-incremento)
2) decremento postfijo (post-decremento)

El operando expr de un operador postfijo de incremento o decremento integrado debe ser un lvalue modificable (no constante) de tipo aritmético no booleano o puntero a tipo objeto completo. El resultado es un prvalue copia del valor original del operando. Como efecto secundario, para operandos no booleanos, la expresión x++ modifica el valor de su operando mediante la evaluación de x += 1, y la expresión x-- modifica el valor de su operando mediante la evaluación de x -= 1. Se aplican todas las reglas de conversión aritmética y aritmética de punteros definida para los operadores aritméticos y se determina la conversión implícita (si la hay) aplicada al operando y al tipo de retorno de la expresión.

Si el operando del operador de post-incremento es de tipo bool, se establece a true (obsoleto). (hasta C++17)

En la resolución de sobrecarga de operadores definidos por usuario, para cada tipo aritmético opcionalmente calificado volátil A que no sea bool, y para cada puntero opcionalmente calificado volátil P a un tipo objeto opcionalmente calificado constante y/o volátil, los siguientes modelos de función participan en la resolución de sobrecarga:

A operator++(A&, int)
bool operator++(bool&, int)
(obsoleto)(hasta C++17)
P operator++(P&, int)
A operator--(A&, int)
P operator--(P&, int)

[editar] Ejemplo

#include <iostream>
 
int main()
{
    int n1 = 1;
    int n2 = ++n1;
    int n3 = ++ ++n1;
    int n4 = n1++;
//  int n5 = n1++ ++;   // error
//  int n6 = n1 + ++n1; // comportamiento indeterminado
    std::cout << "n1 = " << n1 << '\n'
              << "n2 = " << n2 << '\n'
              << "n3 = " << n3 << '\n'
              << "n4 = " << n4 << '\n';
}

Salida:

n1 = 5
n2 = 2
n3 = 4
n4 = 4

[editar] Notas

Debido a los efectos secundarios involucrados, los operadores integrados de incremento y decremento deben usarse con cuidado para evitar comportamientos indeterminados por la violación de las reglas de secuenciación.

Debido a que se crea una copia temporal del objeto durante el post-incremento y el post-decremento, los operadores pre-incremento y pre-decremento son usualmente más eficientes en contexto donde no se utiliza el valor devuelto.

[editar] Biblioteca estándar

Los operadores de incremento y decremento están sobrecargados para varios tipos de la biblioteca estándar. En particular, cada sobrecarga de operador ++ en Iterator y cada sobrecarga de operador -- en BidirectionalIterator, incluso si esos operadores no son operativos para el iterador en particular.

sobrecargas para tipos aritméticos
aumenta o disminuye el valor atómico en uno
(función miembro público de std::atomic) [editar]
aumenta o disminuye el contador marcas de tiempo
(función miembro público de std::chrono::duration)
sobrecargas para tipos de iterador
avanza el iterador
(función miembro público de std::raw_storage_iterator)
avanza el iterador
(función miembro público de std::reverse_iterator)
Disminuye el iterador
(función miembro público de std::reverse_iterator)
no-op
(función miembro público de std::back_insert_iterator)
no-op
(función miembro público de std::front_insert_iterator)
no-op
(función miembro público de std::insert_iterator)
avanza el iterador
(función miembro público de std::move_iterator)
Disminuye el iterador
(función miembro público de std::move_iterator)
avanza el istream_iterator
(función miembro público de std::istream_iterator)
no-op
(función miembro público de std::ostream_iterator)
avanza la istreambuf_iterator
(función miembro público de std::istreambuf_iterator)
no-op
(función miembro público de std::ostreambuf_iterator)
avanza la regex_iterator
(función miembro público de std::regex_iterator)
avanza el regex_token_iterator
(función miembro público de std::regex_token_iterator)

[editar] Ver también

Precedencia de operador

Sobrecarga de operador


Operadores comunes
asignación incremento/decremento aritmético lógico comparación acceso a miembro otros

a = b
a = rvalue
a += b
a -= b
a *= b
a /= b
a %= b
a &= b
a |= b
a ^= b
a <<= b
a >>= b

++a
--a
a++
a--

+a
-a
a + b
a - b
a * b
a / b
a % b
~a
a & b
a | b
a ^ b
a << b
a >> b

!a
a && b
a || b

a == b
a != b
a < b
a > b
a <= b
a >= b

a[b]
*a
&a
a->b
a.b
a->*b
a.*b

a(...)
a, b
(type) a
? :

Operadores especiales

static_cast convierte de un tipo a otro tipo compatible
dynamic_cast convierte de clase base virtual a clase derivada
const_cast convierte de un tipo a otro compatible con diferentes calificadores constante/volátil
reinterpret_cast convierte el tipo a tipo incompatible
new asigna memoria
delete desasigna memoria
sizeof consulta el tamaño de un tipo
sizeof... consulta el tamaño de un parámetro de paquete (desde C++11)
typeid consulta la información de un tipo
noexcept comprueba si una expresión puede lanzar una excepción (desde C++11)
alignof consultas requisitos de alineación de un tipo (desde C++11)

Documentacion C de Operadores de incremento/decremento