Operators in C++

Once we know how to understand how to invent and use variables and constants, we can begin to operate with them.

For that purpose, C++ integrates operators. Unlike other languages whose operators are mainly keywords, operators in C++ are mostly made of signs that are not part of the alphabet but are available in all keyboards.

This makes C++ code shorter and more international, since it relies less on English words, but requires a little of learning effort in the beginning.

You do not have to memorize all the content of this page. Most details are only provided to serve as a later reference in case you need it.

Assignment (=)

The assignment operator is used to assigns a value to a variable.

a = 5;

This statement assigns the integer value 5 to the variable a.

The above code snippet contains two, the part at the left of the assignment operator (=) is known as the lvalue (left value) and the right one as the rvalue (right value).

The lvalue has to be a variable whereas the rvalue can be either a constant, or a variable, or the result of an operation or any combination of these.

The most important rule when assigning is the right-to-left rule.

The assignment operation always takes place from right to left, and never the other way.

a = b;

This statement assigns to variable a(the lvalue) the value contained in variable a (the rvalue).

The value that was stored until this moment in ais not considered at all in this operation, and in fact that value is lost. Means we no longer have access to it.

If you take good look you will see that we are only assigning the value of b to a at the moment of the assignment operation.

Therefore a later change of b will not affect the new value of a.

For example, let us have a look at the following code - I have included the evolution of the content stored in the variables as comments:

// assignment operator
#include <iostream>
using namespace std;

int main(){
  int a, b;     // a:?, b:?
  a = 10;       // a:10, b:?
  b = 4;        // a:10, b:4
  a = b;        // a:4, b:4
  b = 7;        // a:4, b:7
 
  cout<< "a:";
  cout<< a;
  cout<< "b:";
  cout<< b;

  return 0;
}

This code will give us as result that the value contained in a is 4 and the one contained in b is 7

Notice how a was not affected by the final modification of b, even though we declared a = b earlier (that is because of the right-to-leftrule).

The reason why C++ sopass other programming languages is that the assignment operation can be used as the rvalue (or part of an rvalue) for another assignment operation. For example:

a = 2 + (b = 5);

the above code snippet is equivalent to the below one:

b = 5; 
a = 2 + b;

that means: first assign 5 to variable b and then assign to a the value 2 plus the result of the previous assignment of b (i.e. 5), leaving a with a final value of 7.

The following expression is also valid in C++:

a = b = c = 5;

It assigns 5 5 to all the three variables: a , b and c.

Arithmetic operators

The five arithmetical operations supported by the C++ language are:

All the above are working normally the way they do in mathematics.

The only one that you might not be so used to see is modulo; whose operator is the percentage sign %.

Modulo is the operation that gives the remainder of a division of two values. For example, if we write:

a = 11 % 3;

The above statement which variable a will contain the value 2 since 11 divided by 3 gives a remainder of 2

Compound assignment operators

The compound assignment operators are used to perform an operation on the variable and then assign the result to the same variable. For example:

a += 5;

is equivalent to the following code snippet:

a = a + 5;

Here are the list of compound assignment operators are:

When we want to modify the value of a variable by performing an operation on the value currently stored in that variable we can use compound assignment operators:

and the same for all other operators. For example:

// compound assignment operators

#include <iostream>
using namespace std;

int main(){
  int a, b=3; 
  a = b; 
  a+=2;     // equivalent to a=a+2

  cout<< a;

  return 0;
}

Increase and decrease

The increment and decrement operators are used to increase or decrease the value of a variable by one.

Shortening even more some expressions, the increase operator (++) and the decrease operator (--) increase or reduce by one the value stored in a variable. They are equivalent to +=1 and to -=1, respectively. Thus:

c++; 
c+=1; 
c=c+1;

All are equivalent in its functionality: the three of them increase the value of c by one.

A characteristic of this operator is that it can be used both as a prefix and as a suffix.

That means that it can be written either before the variable identifier (++a) or after it (a++).

In the case that the increase operator is used as a prefix (++a) the value is increased before the result of the expression is evaluated and therefore the increased value is considered in the outer expression.

While if it is used as a suffix (a++) the value is increased after the result of the expression is evaluated and therefore the original value is considered in the outer expression.

          B = 3;
          A = ++B;
                  

          B = 3;
          A = B++;
                  

In Example 1, B is increased before its value is copied to A. While in Example 2, the value of B is copied to Aand then B is increased.

The same applies to the decrease operator (--).

          B = 3;
          A = --B;
                  

 
          B = 3;  
          A = B--;
                  

In Example 1, B is decreased before its value is copied to A. While in Example 2, the value of B is copied to Aand then B is decreased.

Relational and equality operators

In order to evaluate a comparison between two expressions we can use the relational and equality operators.

The result of a relational operation is a Boolean value that can only be true or false, according to its Boolean result.

We may want to compare two expressions, for example, to know if they are equal or if one is greater than the other is.

Here is a list of the relational and equality operators that can be used in C++:

Here there are some examples:

(7 == 5) // evaluates to false.
(5 > 4) // evaluates to true.
(3 != 2) // evaluates to true.
(6 >= 6) // evaluates to true.
(5 < 5) // evaluates to false. 

Of course, instead of using only numeric constants, we can use any valid expression, including variables. Suppose that a=2, b=2 and c=2 then the following expressions are valid:

(a == 5) // evaluates to false since a is not equal to 5.
(a*b >= c) // evaluates to true since (2*3 >= 6) is true. 
(b+4 > a*c) // evaluates to false since (3+4 > 2*6) is false. 
((b=2) == a) // evaluates to true. 

Be careful! The operator (=) (one equal sign) is not the same as the operator (==) (two equal signs), the first one is an assignment operator (assigns the value at its right to the variable at its left) and the other one (==) is the equality operator that compares whether both expressions in the two sides of it are equal to each other.

Thus, in the last expression ((b=2) == a), we first assigned the value 2 to b and then we compared it to a, that also stores the value 2, so the result of the operation is true.

Logical operators

The Operator ! is the C++ operator to perform the Boolean operation NOT, it has only one operand, located at its right, and the only thing that it does is to inverse the value of it, producing false if its operand is true and true if its operand is false. Basically, it returns the opposite Boolean value of evaluating its operand. For example:

!(5 == 5) // evaluates to false because the expression at its right (5 == 5) is true. 
!(6 <= 4) // evaluates to true because (6 <= 4) would be false. 
!true // evaluates to false
!false // evaluates to true. 

The logical operators && and || are used when evaluating two expressions to obtain a single relational result.

The operator && corresponds with Boolean logical operation AND.

This operation results true if both its two operands are true, and false otherwise. The following panel shows the result of operator && evaluating the expression a && b :

The operator || corresponds with Boolean logical operation OR.

This operation results true if either one of its two operands is true, thus being false only when both operands are false themselves. Here are the possible results of a || b :

For example, the following expressions are valid:

( (5 == 5) && (3 > 6) ) // evaluates to false ( true && false ).
( (5 == 5) || (3 > 6) ) // evaluates to true ( true || false ).  

Conditional operator

The conditional operator evaluates an expression returning a value if that expression is true and a different one if the expression is evaluated as false. Its format is:

condition ? result1 : result2

If condition is true the expression will return result1 , if it is not it will return result2.

7==5 ? 4 : 3 // returns 3, since 7 is not equal to 5.
7==5+2 ? 4 : 3 // returns 4, since 7 is equal to 5+2.
5>3 ? a : b // returns the value of a, since 5 is greater than 3.
a>b ? a : b // returns whichever is greater, a or b. 

// conditional operator
#include <iostream>
using namespace std;

int main(){
  int a,b,c; 
  a=2; 
  b=7; 
  c = (a>b) ? a : b; 
 
  cout<< c;

  return 0;
}

In this example a was 2 and b was 7, so the expression being evaluated (a>b) was not true, thus the first value specified after the question mark was discarded in favor of the second value (the one after the colon) which was b, with a value of 7.

Comma operator ( , )

The comma operator (,) is used to separate two or more expressions that are included where only one expression is expected. When the set of expressions has to be evaluated for a value, only the rightmost expression is considered.

For example, the following code:

a = (b=3, b+2);

Would first assign the value 3 to b, and then assign b+2 to variable a. So, at the end, variable a would contain the value 5 while variable b would contain value 3.

Bitwise Operators

Bitwise operators modify variables considering the bit patterns that represent the values they store.

Now that you have learned about how to work with Operators C++ programming. Lets learn something about Type Casting in C++ in the next section.