Operadores de incremento/decremento

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Lenguaje C++

 

Expresiones

General
Categorías de valor Orden de evaluación Expresiones constantes Expresiones primarias	Expresiones lambda (C++11) Expresiones requires (C++20) Expresión de indexación de paquete (C++26) Expresiones potencialmente evaluadas
Literales
Literales de enteros Literales de punto flotante Literales booleanas Literales de carácter	Secuencias de escape Literales de cadena Literal de puntero nulo (C++11) Literal definida por el usuario (C++11)
Operadores
Operadores de asignación Incremento y decremento Operadores aritméticos Operadores lógicos Operadores de comparación Operadores de acceso a miembro Otros operadores Expresión new Expresión delete Expresión throw	alignof sizeof sizeof... (C++11) typeid noexcept (C++11) Expresiones de pliegue (C++17) Representaciones alternativas de operadores Precedencia y asociatividad Sobrecarga de operadores Comparaciones por defecto (C++20)
Conversiones
Conversiones implícitas Conversiones explícitas Conversiones aritméticas usuales     Conversión definida por el usuario	const_cast static_cast dynamic_cast reinterpret_cast

 

See More

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	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 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)).

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.

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 (en desuso). (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:

<tbody> </tbody>

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

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 (en desuso). (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:

<tbody> </tbody>

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

Ejemplo

Ejecuta este código

#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

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.

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
operator++operator++(int)operator--operator--(int)	aumenta o disminuye el valor atómico en uno (función miembro pública de std::atomic)
operator++operator++(int)operator--operator--(int)	aumenta o disminuye el contador marcas de tiempo (función miembro pública de std::chrono::duration)
sobrecargas para tipos de iterador
operator++operator++(int)	avanza el iterador (función miembro pública de std::raw_storage_iterator)
operator++operator++(int)	avanza el iterador (función miembro pública de std::reverse_iterator)
operator--operator++(int)	Disminuye el iterador (función miembro pública de std::reverse_iterator)
operator++operator++(int)	no-op (función miembro pública de std::back_insert_iterator)
operator++operator++(int)	no-op (función miembro pública de std::front_insert_iterator)
operator++operator++(int)	no-op (función miembro pública de std::insert_iterator)
operator++operator++(int)	avanza el iterador (función miembro pública de std::move_iterator)
operator--operator--(int)	Disminuye el iterador (función miembro pública de std::move_iterator)
operator++operator++(int)	avanza el istream_iterator (función miembro pública de std::istream_iterator)
operator++operator++(int)	no-op (función miembro pública de std::ostream_iterator)
operator++operator++(int)	avanza la istreambuf_iterator (función miembro pública de std::istreambuf_iterator)
operator++operator++(int)	no-op (función miembro pública de std::ostreambuf_iterator)
operator++operator++(int)	avanza la regex_iterator (función miembro pública de std::regex_iterator)
operator++operator++(int)	avanza el regex_token_iterator (función miembro pública de std::regex_token_iterator)

Ver también

Precedencia de operador

Sobrecarga de operador

Operadores comunes
Asignación	Incremento/decremento	Aritméticos	Lógicos	Comparación	Acceso a miembro	Otros
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 de un tipo a otro tipo relacionado dynamic_cast Convierte dentro de jerarquías de herencia const_cast Añade o suprime los calificadores const/volatile reinterpret_cast Convierte un tipo a un tipo no relacionado conversión estilo C Convierte un tipo a otro mediante una mezcla de static_cast, const_cast, y reinterpret_cast new Crea objetos con duración de almacenamiento dinámica delete Destruye objetos previamente creados por la expresión new 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 un tipo noexcept Comprueba si una expresión puede lanzar una excepción (desde C++11) alignof Consulta requisitos de alineación de un tipo (desde C++11)

Documentación de C para Operadores de incremento/decremento