Los operadores de incremento / decremento incrementan o reducen el valor del objeto.

Nombre del operador Sintaxis Sobrecarga capaz Ejemplos de prototipos (para class T)
Definición de clase interna Definición de clase externa
preincremento ++a sí T& T::operator++(); T& operator++(T& a);
pre-decremento --a sí T& T::operator--(); T& operator--(T& a);
post-incremento a++ sí T T::operator++(int); T operator++(T& a, int);
post-decremento a-- sí T T::operator--(int); T operator--(T& a, int);
Notas

  • Las versiones de prefijo de los operadores incorporados regresan referencias y regresan las versiones postfix valores, y las sobrecargas típicas definidas por el usuario siguen el patrón para que los operadores definidos por el usuario se puedan usar de la misma manera que los integrados. Sin embargo, en una sobrecarga de operador definida por el usuario, se puede utilizar cualquier tipo como tipo de retorno (incluido void).
  • los int parámetro es un parámetro ficticio que se utiliza para diferenciar entre prefix y versiones postfijas de los operadores. Cuando se llama al operador de sufijo definido por el usuario, el valor pasado en ese parámetro es siempre cero, aunque puede cambiarse llamando al operador utilizando la notación de llamada de función (p. Ej., a.operator++(2) o operator++(a, 2)).

Explicación

Pre-incremento y pre-decremento Los operadores aumentan o disminuyen el valor del objeto y devuelven una referencia al resultado.

Post-incremento y post-decremento crea una copia del objeto, incrementa o disminuye el valor del objeto y devuelve la copia anterior al incremento o decremento.

Incorporado prefix operadores

los prefix Las expresiones de incremento y decremento tienen la forma.

++expr
--expr

1) prefix incremento (preincremento)2) prefix decremento (pre-decremento)

El operando expr de un incorporado prefix El operador de incremento o decremento debe ser un valor l modificable (no constante) de tipo aritmético no booleano o puntero al tipo de objeto completo. Para operandos no booleanos, la expresión ++x es exactamente equivalente a x += 1y la expresión --x es exactamente equivalente a x -= 1, eso es el prefix incremento o decremento es una expresión lvalue que identifica el operando modificado. Todas las reglas de conversión aritmética y las reglas aritméticas de puntero definidas para los operadores aritméticos se aplican y determinan la conversión implícita (si existe) aplicada al operando, así como el tipo de retorno de la expresión.

Si el operando del operador de preincremento es de tipo bool, está configurado para true(obsoleto).(hasta C ++ 17).

En resolución de sobrecarga contra operadores definidos por el usuario, para cada tipo aritmético calificado opcionalmente volátil A otro que bool, y para cada puntero calificado opcionalmente volátil P Para el tipo de objeto calificado opcionalmente cv, las siguientes firmas 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&)

Operadores de postfijo incorporados

Las expresiones de incremento y decremento de sufijo tienen la forma.

expr++
expr--

1) incremento postfijo (incremento posterior)2) decremento postfijo (decremento posterior)

El operando expr de un operador incorporado de incremento o decremento postfijo debe ser un valor l modificable (no constante) de tipo aritmético no booleano o puntero al tipo de objeto completo. El resultado es una copia prvalue del valor original del operando. Como efecto secundario, para operandos no booleanos, la expresión x++ modifica el valor de su operando como si evaluara x += 1y la expresión x-- modifica el valor de su operando como si evaluara x -= 1. Todas las reglas de conversión aritmética y las reglas aritméticas de puntero definidas para los operadores aritméticos se aplican y determinan la conversión implícita (si existe) aplicada al operando, así como el tipo de retorno de la expresión.

Si el operando del operador de incremento posterior es de tipo bool, está configurado para true(obsoleto).(hasta C ++ 17).

En resolución de sobrecarga contra operadores definidos por el usuario, para cada tipo aritmético calificado opcionalmente volátil A otro que bool, y para cada puntero calificado opcionalmente volátil P Para el tipo de objeto calificado opcionalmente cv, las siguientes firmas de función participan en la resolución de sobrecarga:

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

Ejemplo

#includeintmain()int n1 =1;int n2 =++n1;int n3 =++++n1;int n4 = n1++;//  int n5 = n1++ ++;   // error//  int n6 = n1 + ++n1; // undefined behavior
    std::cout <<"n1 = "<< n1 <<'n'<<"n2 = "<< n2 <<'n'<<"n3 = "<< n3 <<'n'<<"n4 = "<< n4 <<'n';

Producción:

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

Notas

Debido a los efectos secundarios involucrados, los operadores de incremento y decremento integrados deben usarse con cuidado para evitar un comportamiento indefinido debido a violaciones de las reglas de secuenciación.

Debido a que se construye una copia temporal del objeto durante el post-incremento y post-decremento, preincremento o pre-decremento Los operadores suelen ser más eficientes en contextos en los que no se utiliza el valor devuelto.

Biblioteca estándar

Los operadores de incremento y decremento están sobrecargados para muchos tipos de bibliotecas estándar. En particular, cada LegacyIterator sobrecarga el operador ++ y cada LegacyBidirectionalIterator sobrecarga el operador, incluso si esos operadores no son operativos para el iterador en particular.

sobrecargas para tipos aritméticos
operador ++operador ++(En t)operador–operador–(En t) aumenta o disminuye el valor atómico en uno
(función de miembro público de std::atomic)
operador ++operador ++(En t)operador–operador–(En t) aumenta o disminuye el recuento de ticks
(función de miembro público de std::chrono::duration)
sobrecargas para tipos de iteradores
operador ++operador ++(En t) avanza el iterador
(función de miembro público de std::raw_storage_iterator)
operador ++operador ++(En t)operador + =operador +operador–operador–(En t)operador- =operador- avanza o disminuye el iterador
(función de miembro público de std::reverse_iterator)
operador ++operador ++(En t)operador + =operador +operador–operador–(En t)operador- =operador- avanza o disminuye el iterador
(función de miembro público de std::move_iterator)
operador ++operador ++(En t) sin operación
(función de miembro público de std::front_insert_iterator)
operador ++operador ++(En t) sin operación
(función de miembro público de std::back_insert_iterator)
operador ++operador ++(En t) sin operación
(función de miembro público de std::insert_iterator)
operador ++operador ++(En t) avanza el iterador
(función de miembro público de std::istream_iterator)
operador ++operador ++(En t) sin operación
(función de miembro público de std::ostream_iterator)
operador ++operador ++(En t) avanza el iterador
(función de miembro público de std::istreambuf_iterator)
operador ++operador ++(En t) sin operación
(función de miembro público de std::ostreambuf_iterator)
operador ++operador ++(En t) avanza el iterador a la siguiente coincidencia
(función de miembro público de std::regex_iterator)
operador ++operador ++(En t) avanza el iterador a la siguiente subcoincidencia
(función de miembro público de std::regex_token_iterator)

Ver también

Precedencia del operador.

Sobrecarga del operador.

Operadores comunes
asignación incremento
decremento		 aritmética lógico comparación miembro
acceso		 otro

a = b 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[b] *a &a a->b a.b a->*b a.*b.

a(...) a, b ? :
Operadores especiales

static_cast convierte un tipo en otro tipo relacionado
dynamic_cast convierte dentro de las jerarquías de herencia
const_cast agrega o elimina calificadores de cv
reinterpret_cast convierte el tipo en un tipo no relacionado
El elenco de estilo C convierte un tipo en otro mediante una mezcla de static_cast, const_cast, y reinterpret_cast
new crea objetos con una duración de almacenamiento dinámica
delete destruye objetos previamente creados por la nueva expresión y libera el área de memoria obtenida
sizeof consulta el tamaño de un tipo
sizeof... consulta el tamaño de un paquete de parámetros(desde C ++ 11)
typeid consulta la información de tipo de un tipo
noexcept comprueba si una expresión puede lanzar una excepción (desde C ++ 11)
alignof requisitos de alineación de consultas de un tipo (desde C ++ 11).