Operador Unário em C++

C++ oferece suporte a vários operadores unários, cada um servindo a um propósito único na manipulação de variáveis. Vamos começar com os operadores de incremento e decremento que são comumente usados ​​em loops e vários algoritmos.

Exemplo 1: Operadores de incremento (++) e decremento (–)

Os operadores unários de incremento (++) e decremento (–) são ferramentas fundamentais em C++ para modificar o valor de uma variável aumentando ou diminuindo-a em 1, respectivamente. O operador de incremento (++) adiciona 1 ao valor da variável, enquanto o operador de decremento (–) subtrai 1. Esses operadores podem ser aplicados a variáveis ​​inteiras, de ponto flutuante e de ponteiro, proporcionando flexibilidade em seu uso.

Vamos explorar esses operadores através de um exemplo prático:

Este programa C++ simples inclui a biblioteca de fluxo de entrada/saída necessária com “#include ”. Dentro da função “main()”, instanciamos uma variável inteira chamada “counter” e atribuímos a ela um valor inicial de 0. Usando a instrução “cout”, imprimimos o valor inicial do “counter” no console, fornecendo uma linha de base para nossa demonstração. Seguindo em frente, o operador de incremento (counter++) é utilizado para aumentar o valor da variável “contador” em 1.

Após esta operação, o valor atualizado de “counter” é exibido usando outra instrução “cout”. Posteriormente, utilizamos o operador de decremento (counter—) para diminuir o valor de “counter” em 1. O resultado é posteriormente exibido no console. Por fim, o programa termina com o “retorno 0”; instrução que indica uma execução bem-sucedida.

A imagem de saída mostra o valor inicial, o valor após o incremento e o valor decrementado.

Exemplo 2: Operadores Positivo (+) e Negativo (-)

Embora o operador unário positivo raramente seja usado, o operador negativo é fundamental para alterar o sinal de uma variável.

Inicializamos duas variáveis ​​​​inteiras para este código de exemplo que são “positivoValue” e “negativoValue”. O “positivoValue” é atribuído com o valor 10. Posteriormente, declaramos o “negativeValue” e atribuímos a ele a negação de “positivoValue” usando o operador unário menos. Este operador altera efetivamente o sinal do valor original. Em seguida, utilizamos a instrução “cout” para exibir tanto a saída positiva quanto a negativa no console. Finalmente, o programa retorna 0, o que indica a conclusão bem-sucedida da função principal.

Quando executado, este programa gera os valores positivos e negativos.

Exemplo 3: Operador Lógico NOT (!)

O operador unário em C++, denotado pelo “!” símbolo, é conhecido como operador lógico NOT. Ele foi projetado para inverter o valor de verdade de uma determinada expressão. Ele opera em um único operando que normalmente é uma expressão lógica ou condição. A operação lógica NOT produz um resultado “verdadeiro” quando o operando é “falso” e produz um resultado “falso” quando o operando é “verdadeiro”.

Aqui está um exemplo simples que demonstra o uso do operador lógico NOT:

Neste exemplo, declaramos duas variáveis ​​booleanas, “isTrue” e “isFalse”. Em seguida, aplicamos o operador lógico NOT a cada variável, armazenando os resultados em “resultNotTrue” e “resultNotFalse”, respectivamente. O programa posteriormente imprime os valores originais e os resultados da operação lógica NOT para ambas as variáveis.

Ao executar este programa, notaremos que o operador lógico NOT inverte o valor verdade de “isTrue” (inicialmente definido como verdadeiro), tornando-o falso. Da mesma forma, inverte o valor verdade de “isFalse” (originalmente falso), resultando em verdadeiro.

A saída ilustra claramente a inversão dos valores verdade que são alcançados pelo operador lógico NOT.

Exemplo 4: Operador NOT (~) bit a bit

O operador NOT bit a bit (~) em C++ é um operador unário que realiza a negação bit a bit de cada bit de seu operando. Funciona com tipos de dados fundamentais, especificamente integrais, como inteiros. O resultado é alcançado invertendo cada bit individual no operando, convertendo 0s em 1s e 1s em 0s.

Para ilustrar seu uso, considere o seguinte trecho de código:

Neste exemplo, declaramos uma variável inteira “originalValue” com o valor “5”. A seguir, utilizamos o operador NOT bit a bit (~) nesta variável. O resultado desta variável é armazenado em “resultBitwiseNot”. O programa então imprime o valor original e o resultado após a operação NOT bit a bit utilizando a instrução “cout”.

Ao executarmos este programa, veremos que o operador NOT bit a bit inverte cada bit da representação binária de “originalValue”, resultando em um novo valor.

Exemplo 5: Operadores de Endereço e Indireção

O operador endereço de, denotado pelo símbolo “&”, serve ao propósito de recuperar a localização de memória de uma variável. Retorna um ponteiro para a variável que permite um acesso indireto ao seu valor. O operador de indireção ou desreferência (*) obtém o valor armazenado no local da memória especificado por um ponteiro. Ele fornece uma maneira de trabalhar indiretamente com os dados reais por meio de um ponteiro.

Vamos compreender o conceito com um exemplo:

Este código exemplifica a utilização de operadores de endereço e indireção. Primeiro, uma variável inteira chamada “valor” é inicializada com o valor 99. O valor original de “valor” é então enviado para o console. Posteriormente, uma variável ponteiro “ptr” é declarada, e o operador endereço de (&) é empregado para atribuir o endereço de memória de “valor” a “ptr”. O programa então gera este endereço de memória, mostrando a operação básica do operador “endereço”.

Depois disso, uma nova variável inteira que é “retrievedValue” é declarada, e o operador indireto (*) é empregado para recuperar o valor que está armazenado no endereço de memória apontado por “ptr”. O valor recuperado é então enviado para o console.

Conclusão

Este artigo forneceu uma exploração abrangente de operadores unários em C++. Começamos categorizando os operadores unários em vários tipos, incluindo aritméticos, lógicos, bit a bit e aqueles relacionados a endereço e indireção. Situações do mundo real foram exemplificadas para demonstrar a aplicação útil destes operadores. Esses operadores desempenham papéis essenciais na programação C++, o que permite aos desenvolvedores trabalhar com ponteiros de forma eficiente e gerenciar a memória.