Operadores unarios en C++

En C++, un operador unario es un operador que opera sólo en un único operando. Los operadores unarios desempeñan un papel vital en C++ y operan con valores asociados con una única variable o expresión. Estos operadores versátiles se pueden utilizar en una variedad de contextos, como incrementar o disminuir una variable, cambiar el signo de un valor o realizar un NOT lógico. Este artículo explora los operadores unarios en C++, presenta sus tipos y aplicaciones y proporciona varios ejemplos para una mejor comprensión.

C++ admite varios operadores unarios, cada uno de los cuales tiene un propósito único al manipular variables. Comencemos con los bucles y los operadores de incremento y decremento comúnmente utilizados en varios algoritmos.

Ejemplo 1: operadores de incremento (++) y decremento (–)

Los operadores unarios de incremento (++) y decremento (–) son herramientas básicas en C++ y se utilizan 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.

Exploremos estos operadores a través de un ejemplo práctico:

Este sencillo programa C++ contiene las bibliotecas de flujo de entrada/salida necesarias con «#include ”. En la función «main()», creamos una instancia de una variable entera llamada «contador» y le asignamos un valor inicial de 0. Proporciona una línea de base para nuestra demostración. A continuación, utilice el operador de incremento (counter++) para incrementar el valor de la variable «counter» en 1.

Después de hacer esto, use otra declaración «cout» para mostrar el valor actualizado de «counter». Luego, usamos el operador de decremento (contador) para disminuir el valor de «contador» en 1. Finalmente, el programa termina con «return 0;». Declaración que indica ejecución exitosa.

La imagen de salida muestra el valor inicial, el valor aumentado y el valor disminuido.

Ejemplo 2: operadores positivos (+) y negativos (-)

Aunque el operador unario positivo rara vez se utiliza, el operador negativo es crucial para cambiar el signo de una variable.

Inicializamos dos variables enteras para este código de muestra: «positiveValue» y «negativeValue». A «positiveValue» se le asigna un valor de 10. Este operador cambia efectivamente el signo del valor original. Luego usamos la declaración «cout» para mostrar resultados positivos y negativos en la consola. Finalmente, el programa devuelve 0, lo que indica que la función principal se completó correctamente.

Cuando se ejecuta, este programa genera valores positivos y negativos.

Ejemplo 3: operador lógico NOT (!)

El operador unario en C++ está representado por «!» y se denomina operador NOT lógico. Su objetivo es invertir el valor de verdad de una expresión determinada. Opera con un único operando, que suele ser una expresión o condición lógica. Cuando el operando es «falso», la operación lógica NOT produce un resultado «verdadero», y cuando el operando es «verdadero», la operación lógica NOT produce un resultado «falso».

A continuación se muestra un ejemplo sencillo que demuestra el uso del operador lógico NOT:

En este ejemplo, declaramos dos variables booleanas «isTrue» e «isFalse». Luego aplicamos el operador lógico NOT a cada variable y almacenamos los resultados en «resultNotTrue» y «resultNotFalse» respectivamente. Luego, el programa imprime los valores originales de las dos variables y el resultado de la operación lógica NOT.

Cuando ejecutamos el programa, notaremos que el operador lógico NOT invierte el valor de verdad de «isTrue» (originalmente establecido en verdadero), haciéndolo falso. De manera similar, invierte el valor de verdad de «isFalse» (inicialmente falso), dando como resultado verdadero.

El resultado ilustra claramente la inversión de la verdad implementada por el operador lógico NOT.

Ejemplo 4: operador bit a bit NOT (~)

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. Se aplica a tipos de datos básicos, especialmente tipos de datos enteros, 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:

En este ejemplo, declaramos una variable entera «originalValue» con un valor de «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 utiliza la instrucción «cout» para imprimir el valor original y el resultado de la operación NOT bit a bit.

Cuando ejecutamos este programa, veremos que el operador NOT bit a bit invierte cada bit de la representación binaria de «originalValue», produciendo así un nuevo valor.

Ejemplo 5: Dirección y operadores indirectos

El operador de dirección está representado por el símbolo «&» y se utiliza para recuperar la ubicación de memoria de una variable. Devuelve un puntero a la variable, permitiendo el acceso indirecto a su valor. operador de indirección o desreferencia

Obtiene el valor almacenado en la ubicación de memoria especificada por el indicador. Proporciona una forma de abordar los datos reales de forma indirecta a través de indicadores.

}

Este código ilustra el uso de operadores de dirección e indirección. Primero, inicialice una variable entera llamada «valor» con el valor 99. Luego, declare una variable de puntero «ptr» y use el operador de dirección (&) para asignar la dirección de memoria de «valor» a «ptr». Luego, el programa genera la dirección de memoria, mostrando la operación básica del operador de «dirección».

Después de eso, declare una nueva variable entera «retriedValue» y use el operador de direccionamiento indirecto.

Se utiliza para recuperar el valor almacenado en la dirección de memoria señalada por «ptr». Luego, el valor recuperado se envía a la consola.