Unary Operators In C++
Unary operators in C++ are those operators that work on a single value (operand). They perform operations like changing a value’s sign, incrementing or decrementing it by one, or obtaining its address. Examples include ++ for increment, — for decrement, + for positive values, – for negative values,! for logical negation, and & for retrieving memory addresses. In this article, we will discuss various unary operators available in C++.
Types of Unary Operators in C++
C++ has a total of 8 unary operators which are as follows:
- Increment Operator (++)
- Decrement Operator (–)
- Unary Plus Operator (+)
- Unary Minus Operator (-)
- Logical NOT Operator (!)
- Bitwise NOT Operator (~)
- Addressof Operator (&)
- Indirection Operator (*)
- sizeof Operator
1. Increment Operator (++)
The increment operator is used to increase the value of its operand by 1. It works on the numeric operands and be use used as both prefix and postfix to the operand
Syntax
++ operand
or
operand ++
Example
C++
#include <iostream> using namespace std; int main() { int x = 5; // Increment Operator (++) cout << "Initial value of x: " << x << endl; x++; // Increment x by 1 cout << "After x++, x is now: " << x << endl; // Prefix and Postfix Increment/Decrement int a = 10; int b, c; b = ++a; // Prefix increment: first, increment a, then // assign to b c = a++; // Postfix increment: first, assign a to c, // then increment a cout << "a: " << a << ", b: " << b << ", c: " << c << endl; return 0; } |
Initial value of x: 5 After x++, x is now: 6 a: 12, b: 11, c: 11
2. Decrement Operator (–)
The decrement operator is used to decrement the value by 1. Just like the increment operator, it can be used as pre-decrement and post-decrement. It works on numeric values.
Syntax
operand --
or
-- operand
Example
C++
// C++ program to illustrate the decrement operator #include <iostream> using namespace std; int main() { int var = 10; cout << "Value before decrement: " << var << endl; var--; cout << "Value after decrement: " << var; return 0; } |
Value before decrement: 10 Value after decrement: 9
To know more about increment and decrement operators, refer to the article – C++ Increment and Decrement Operators
3. Unary Plus Operator (+)
The symbol (+) represents the unary plus operator in C++, which explicitly specifies the positive value of its operand. It doesn’t change the sign of a if it’s already positive, but it can be used for clarity in expressions.
– is the unary minus operator, which changes the sign of its operand to negative.
Explanation:
- The unary minus (-) changes the sign of the value. If a is positive, -a makes it negative.
- The unary plus (+) is used to explicitly specify a positive value.
Syntax
+ operand
Example
C++
// C++ program to illustrate the unary plus operator #include <iostream> using namespace std; int main() { int a = 10; int c = +a; // Unary Plus: Explicitly specifies 'a' as // positive cout << "Original value of a: " << a << endl; cout << "After using unary plus (+a): " << c << endl; return 0; } |
Original value of a: 10 After using unary plus (+a): 10
4. Unary Minus (-) Operator
The symbol (+) represents the unary plus operator in C++, which changes the sign of its operand to negative. If the operand is negative, this operator will make it positive and vice versa.
Syntax
- operand
Example
C++
// C++ program to illustrate the unary minus operator #include <iostream> using namespace std; int main() { int var = 20; cout << "Initial Value: " << var << endl; cout << "Value with (-): " << -var; return 0; } |
Initial Value: 20 Value with (-): -20
5. Logical NOT Operator (!)
The logical NOT operator (!) is used for negating the value of a boolean expression. It returns true if the operand is false, and false if the operand is true.
Note: Zero is considered false and any non zero value is considered true in C++.
Syntax
! operand
Example
C++
// C++ program to illustrate the use of logical NOT operator #include <iomanip> #include <iostream> using namespace std; int main() { bool isTrue = true ; // Logical NOT: Negates the value of 'isTrue' bool isFalse = !isTrue; // print string correspoinding to true and false cout << boolalpha; cout << "Value of isTrue: " << isTrue << endl; cout << "Value of isFalse (!isTrue): " << isFalse << endl; return 0; } |
Value of isTrue: true Value of isFalse (!isTrue): false
6. Bitwise NOT Operator (~)
The bitwise NOT operator ~ in C++ performs a bitwise negation operation on integral data types, such as integers. It inverts each bit of the operand, changing every 0 bit to 1 and every 1 bit to 0′.
Syntax
~ operand
Example
C++
// C++ program to illustrate the use of first complement // operator #include <iostream> using namespace std; int main() { // Binary: 0000 0101 unsigned int a = 5; // Bitwise NOT: Inverts each bit of 'a' unsigned int b = ~a; cout << "Original value of a: " << a << " (Binary: 0000 0101)" << endl; cout << "Value of b after ~a: " << b << " (Binary: 1111 1010)" << endl; return 0; } |
Original value of a: 5 (Binary: 0000 0101) Value of b after ~a: 4294967290 (Binary: 1111 1010)
7. Addressof Operator (&)
The addressof operator (&) retrieves the memory address of a variable. It returns the memory location where the variable is stored in the computer’s memory.
Syntax
& operand
Example
C++
// C++ program to illustrate the use of addressof operator #include <iostream> using namespace std; int main() { int number = 42; // Pointer 'ptr' stores the address of 'number' int * ptr = &number; cout << "Value of number: " << number << endl; cout << "Address of number: " << &number << endl; return 0; } |
Value of number: 42 Address of number: 0x7fff5785a304
8. Dereference Operator (*)
The dereference operator (*) is used to access the value at a specific memory address stored in a pointer. It “points to” the value stored at that Sddress.
Syntax
* operand
Example
C++
// C++ program to illustrate the dereferencing operator #include <iostream> using namespace std; int main() { int var = 10; int * ptr = &var; cout << "var = " << var << endl; cout << "*ptr = " << *ptr; return 0; } |
var = 10 *ptr = 10
9. sizeof Operator
The sizeof operator is a special unary operator in C++ that returns the size of its operand it bytes. Its operand can be any data type or a variable.
Syntax
sizeof (operand)
Example
C++
// C++ program to illustrate the use of sizeof operator #include <iostream> using namespace std; int main() { // integer array with 10 elements int arr[10]; // finding size of integer cout << "Integer Size: " << sizeof ( int ) << endl; cout << "Size of Integer Array with Elements: " << sizeof (arr); return 0; } |
Integer Size: 4 Size of Integer Array with Elements: 40
Precedence and Associativity of Unary Operators in C++
Precedence of Unary Operators
Unary operators generally have a higher precedence than most binary operators. They have a fixed order of execution before most binary operations.
Associativity of Unary Operators
Unary operators are right-associative, meaning that if multiple unary operators are applied to the same operand, they are evaluated from right to left.
Example
- int a = 5;: Initializes variable ‘a’ with the value 5.
- int b = -++a;: In this expression:
- ++a is a prefix increment, which increments the value of ‘a’ by 1.
- – is the unary minus operator that changes the sign of the value obtained from ++a.
- Then display the initial value of ‘a’ and the value of ‘b’ after applying the unary operators.
C++
// C++ program to illustrate the precedence and // associativity of the unary operators #include <iostream> using namespace std; int main() { int a = 5; // Demonstration of unary operators' precedence and // associativity int b = -++a; cout << "Initial value of a: " << a << endl; cout << "Value of b (-++a): " << b << endl; return 0; } |
Initial value of a: 6 Value of b (-++a): -6