Operadores de incremento/decremento
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); |
| ||||
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
|
|||||||||
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:
| A& operator++(A&) |
||
| bool& operator++(bool&) |
(en desuso)(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 --
|
|||||||||
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:
| 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) |
||
[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ública de std::atomic)
| |
| aumenta o disminuye el contador marcas de tiempo (función miembro pública de std::chrono::duration)
| |
sobrecargas para tipos de iterador | |
| avanza el iterador (función miembro pública de std::raw_storage_iterator)
| |
| avanza el iterador (función miembro pública de std::reverse_iterator)
| |
| Disminuye el iterador (función miembro pública de std::reverse_iterator)
| |
| no-op (función miembro pública de std::back_insert_iterator)
| |
| no-op (función miembro pública de std::front_insert_iterator)
| |
| no-op (función miembro pública de std::insert_iterator)
| |
| avanza el iterador (función miembro pública de std::move_iterator)
| |
| Disminuye el iterador (función miembro pública de std::move_iterator)
| |
| avanza el istream_iterator (función miembro pública de std::istream_iterator)
| |
| no-op (función miembro pública de std::ostream_iterator)
| |
| avanza la istreambuf_iterator (función miembro pública de std::istreambuf_iterator)
| |
| no-op (función miembro pública de std::ostreambuf_iterator)
| |
| avanza la regex_iterator (función miembro pública de std::regex_iterator)
| |
| avanza el regex_token_iterator (función miembro pública de std::regex_token_iterator)
| |
[editar] Ver también
| Operadores comunes | ||||||
|---|---|---|---|---|---|---|
| Asignación | Incremento/decremento | Aritméticos | Lógicos | Comparación | Acceso a miembro | Otros |
|
a = b |
++a |
+a |
!a |
a == b |
a[b] |
a(...) |
| Operadores especiales | ||||||
|
static_cast Convierte de un tipo a otro tipo relacionado | ||||||
| Documentación de C para Operadores de incremento/decremento
|
