C++ admite varios operadores unarios, cada uno de los cuales tiene un propósito único al manipular las variables. Comencemos con los operadores de incremento y decremento que se usan comúnmente en bucles y varios algoritmos.
Ejemplo 1: operadores de incremento (++) y decremento (–)
Los operadores unarios de incremento (++) y decremento (–) son herramientas fundamentales en C++ para modificar el valor de una variable incrementándolo o disminuyéndolo en 1, respectivamente. El operador de incremento (++) suma 1 al valor de la variable, mientras que el operador de decremento (–) resta 1. Estos operadores se pueden aplicar a variables enteras, de punto flotante y de puntero, lo que proporciona flexibilidad en su uso.
Exploremos estos operadores a través de un ejemplo práctico:
#incluir
usando espacio de nombres enfermedad de transmisión sexual ;
En t principal ( )
{
En t encimera = 0 ;
// operador de incremento
corte << 'Valor inicial: ' << encimera << fin ;
encimera ++ ;
corte << 'Valor después del incremento: ' << encimera << fin ;
// Operador de decremento
encimera -- ;
corte << 'Valor después de la disminución: ' << encimera << fin ;
devolver 0 ;
}
Este sencillo programa C++ incluye la biblioteca de flujo de entrada/salida necesaria con “#include
Después de esta operación, el valor actualizado de 'counter' se muestra utilizando otra declaración 'cout'. Posteriormente, utilizamos el operador de decremento (contador—) para disminuir el valor de “contador” en 1. El resultado se muestra posteriormente en la consola. En última instancia, el programa concluye con el 'retorno 0'; declaración que indica una ejecución exitosa.
La imagen de salida muestra el valor inicial, el valor después del incremento y el valor decrementado.
Ejemplo 2: operadores positivos (+) y negativos (-)
Si bien el operador unario positivo rara vez se utiliza, el operador negativo es fundamental para cambiar el signo de una variable.
#incluirUsando espacio de nombres enfermedad de transmisión sexual ;
En t principal ( ) {
En t valor positivo = 10 ;
En t valor negativo = - valor positivo ;
corte << 'Valor positivo: ' << valor positivo << fin ;
corte << 'Valor negativo: ' << valor negativo << fin ;
devolver 0 ;
}
Inicializamos dos variables enteras para este código de ejemplo que son 'positiveValue' y 'negativeValue'. Al “valorpositivo” se le asigna el valor de 10. Posteriormente, declaramos el “valornegativo” y le asignamos la negación de “valorpositivo” utilizando el operador menos unario. Este operador cambia efectivamente el signo del valor original. Luego utilizamos la declaración 'cout' para mostrar tanto el resultado positivo como el negativo en la consola. Finalmente, el programa devuelve 0, lo que indica la finalización exitosa de la función principal.
Cuando se ejecuta, este programa genera los valores positivos y negativos.
Ejemplo 3: Operador lógico NOT (!)
El operador unario en C++, indicado por '!' símbolo, se conoce como operador lógico NOT. Está diseñado para invertir el valor de verdad de una expresión determinada. Opera con un único operando que suele ser una expresión lógica o una condición. La operación lógica NOT produce un resultado 'verdadero' cuando el operando es 'falso' y produce un resultado 'falso' cuando el operando es 'verdadero'.
Aquí hay un ejemplo simple que demuestra el uso del operador lógico NOT:
#incluirusando espacio de nombres enfermedad de transmisión sexual ;
En t principal ( ) {
booleano es verdad = verdadero ;
booleano Es falso = FALSO ;
booleano resultadoNo es cierto = ! es verdad ;
booleano resultadoNoFalso = ! Es falso ;
corte << 'Valor original: ' << es verdad << ', Después de NO: ' << resultadoNo es cierto << fin ;
corte << 'Valor original: ' << Es falso << ', Después de NO: ' << resultadoNoFalso << fin ;
devolver 0 ;
}
En este ejemplo, declaramos dos variables booleanas, 'isTrue' y 'isFalse'. Luego aplicamos el operador lógico NOT a cada variable, almacenando los resultados en 'resultNotTrue' y 'resultNotFalse', respectivamente. Posteriormente, el programa imprime los valores originales y los resultados de la operación lógica NOT para ambas variables.
Al ejecutar este programa, notaremos que el operador lógico NOT invierte el valor de verdad de 'isTrue' (inicialmente establecido en verdadero), volviéndolo falso. De manera similar, invierte el valor de verdad de 'isFalse' (originalmente falso), dando como resultado verdadero.
El resultado ilustra claramente la inversión de los valores de verdad que logra el operador lógico NOT.
Ejemplo 4: Operador bit a bit NO (~)
El operador NOT bit a bit (~) en C++ es un operador unario que realiza la negación bit a bit de cada bit de su operando. Funciona con tipos de datos fundamentales, específicamente los integrales, como los números enteros. El resultado se logra invirtiendo cada bit individual en el operando, convirtiendo 0 en 1 y 1 en 0.
Para ilustrar su uso, considere el siguiente fragmento de código:
#incluirusando espacio de nombres enfermedad de transmisión sexual ;
En t principal ( ) {
En t Valor original = 5 ;
En t resultadoBitwiseNot = ~ valor original ;
corte << 'Valor original: ' << Valor original << ', Después de Bit a bit NO: ' << resultadoBitwiseNot << fin ;
devolver 0 ;
}
En este ejemplo, declaramos una variable entera 'originalValue' con el valor '5'. A continuación, utilizamos el operador NOT bit a bit (~) en esta variable. El resultado de esta variable se almacena en 'resultBitwiseNot'. Luego, el programa imprime el valor original y el resultado después de la operación NOT bit a bit utilizando la instrucción 'cout'.
Cuando ejecutamos este programa, veremos que el operador NOT bit a bit invierte cada bit de la representación binaria de 'valor original', lo que da como resultado un nuevo valor.
Ejemplo 5: Operadores de dirección e indirección
El operador de dirección de, indicado por el símbolo '&', sirve para recuperar la ubicación de memoria de una variable. Devuelve un puntero a la variable que permite un acceso indirecto a su valor. El operador de indirección o desreferencia (*) obtiene el valor que se almacena en la ubicación de memoria especificada por un puntero. Proporciona una forma de trabajar indirectamente con los datos reales a través de un puntero.
Entendamos el concepto con un ejemplo:
#incluirusando espacio de nombres enfermedad de transmisión sexual ;
En t principal ( ) {
En t valor = 99 ;
corte << 'Valor original: ' << valor << fin ;
En t * ptr = & valor ;
corte << 'Dirección de memoria: ' << ptr << fin ;
En t valor recuperado = * ptr ;
corte << 'Valor recuperado: ' << valor recuperado << fin ;
devolver 0 ;
}
Este código ejemplifica la utilización de operadores de dirección e indirección. Primero, se inicializa una variable entera llamada 'valor' con el valor de 99. Luego, el valor original de 'valor' se envía a la consola. Posteriormente, se declara una variable puntero 'ptr' y se emplea el operador de dirección de (&) para asignar la dirección de memoria del 'valor' a 'ptr'. Luego, el programa genera esta dirección de memoria, mostrando la operación básica del operador de 'dirección'.
Después de eso, se declara una nueva variable entera que es 'retriedValue', y se emplea el operador de indirección (*) para recuperar el valor que está almacenado en la dirección de memoria señalada por 'ptr'. Luego, el valor recuperado se envía a la consola.
Conclusión
Este artículo proporcionó una exploración exhaustiva de los operadores unarios en C++. Comenzamos categorizando los operadores unarios en varios tipos, incluidos los aritméticos, lógicos, bit a bit y los relacionados con la dirección y la dirección indirecta. Se ejemplificaron situaciones del mundo real para demostrar la aplicación útil de estos operadores. Estos operadores desempeñan papeles fundamentales en la programación de C++, lo que permite a los desarrolladores trabajar con punteros de manera eficiente y administrar la memoria.