C plus plus operators
From DmWiki
| Table of contents |
Operators - Definition
C++ can store data and most programs need a way of modifying this information and extract results. C++ does this with variables, constants and operators. An operator is a symbol or a set of symbols that define how to treat data in relation to other data stored in the program. Operators in C++ are mostly made of characters that are not part of the alphabet, but are part of the standard ASCII set and available on all keyboards. This makes C++ code shorter and more international, since it relies less on English words, but requires a little learning effort in the beginning.
Operators - Types
- Assignment (=)
- Compound Assignment (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=)
- Increment and decrement (++, --)
- Arithmetic Operators (+, -, *, /, %)
- Comparison Operations (==, !=, >, <, >=, <=)
- Logical Operations (!, &&, ||)
- Conditional Operator (?)
- Comma Operator (,)
- Bitwise Operators (&, |, ^, ~, <<, >>)
Operators - Symbols
Assignment (=)
The assignment operator simply assigns a value to a variable. The value you can assign is dependent on the variable type you have used.
a = 5;
This statement assigns the integer value 5 to the variable a. 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, a variable, the result of an operation, or any combination of these. The most important rule of assignment 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 b (the rvalue). The value that was stored until this moment in a is not considered at all in this operation, and in fact that value is lost.
Consider also that we are only assigning the value of b to a at the moment of the assignment. Therefore a later change of b will not affect the new value of a.
In C++, the assignment operation can be used as the rvalue (or part of an rvalue) for another expression. For example:
a = 2 + (b = 5);
is equivalent to:
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 to the all the three variables: a, b and c.
Compound Assignment
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:
| Compound Assignment | |
| Expression | is Equivalent to |
| value += increase | value = value + increase |
| a -= 5 | a = a - 5 |
| a /= b | a = a / b |
| price *= units + 1 | price = price * (units + 1) |
The same goes for the other operators.
Increment and decrement
Shortening even more some expressions, the increment operator (++) and the decrement 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;
are all equivalent in its functionality: the three of them increase by one the value of c.
In the early C compilers, the three previous expressions probably produced different executable code depending on which one was used. Nowadays, this type of code optimization is generally done automatically by the compiler, thus the three expressions should produce exactly the same executable code.
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++). Although in simple expressions like a++ or ++a both have exactly the same meaning, in other expressions in which the result of the increase or decrease operation is evaluated as a value in an outer expression they may have an important difference in their meaning: 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; in case that it is used as a suffix (a++) the value stored in a is increased after being evaluated and therefore the value stored before the increase operation is evaluated in the outer expression. Notice the difference:
| Example 1 | Example 2 |
| B=3; A=++B; | B=3; A=B++; |
| A contains 4 B contains 4 | A contains 3 B contains 4 |
In Example 1, B is increased before its value is copied to A. While in Example 2, the value of B is copied to A and then B is increased.
Arithmetic Operations
The five arithmetical operations supported by the C++ language are:
| Symbols | Explanations |
| + | addition |
| - | subtraction |
| * | multiplication |
| / | division |
| % | mondulo |
Operations of addition, subtraction, multiplication and division literally correspond with their respective mathematical operators. The only one that you might not be so used to see may be 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 variable a will contain the value 2, since 2 is the remainder from dividing 11 between 3.
Comparison Operations
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++:
| Symbols | Explanations |
| == | Equal to |
| != | Not Equal to |
| < | Less Than |
| <= | Less than or Equal to |
| > | Greater Than |
| >= | Greater Than or Equal to |
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 = 3 and c = 6,
(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 Operations
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 its two operands are true, and false otherwise. The following panel shows the result of operator && evaluating the expression a && b:
| The AND operator (&&) | |||
| Expression 1 | And | Expression 2 | Statment |
| True | && | True | True |
| True | && | False | False |
| False | && | True | False |
| False | && | False | False |
The operator || corresponds with Boolean logical operation OR. This operation results false if any of its two operands is true, thus being false only when both operands are indeed false. Here are the possible results of a || b:
| The OR operator (||) | |||
| Expression 1 | And | Expression 2 | Statment |
| True | || | True | True |
| True | || | False | True |
| False | || | True | True |
| False | || | False | False |
For example:
( (5 == 5) && (3 > 6) ) // evaluates to false ( true && false ). ( (5 == 5) || (3 > 6) ) // evaluates to true ( true || false ).
The NOT operator takes the result of any other operator and returns the opposite state. So all true results return false and all false results show as true.
| The NOT operator (!) | ||
| Symbols | Expression | Explanations |
| ! | True | False |
| ! | False | True |
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.
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
| Operator | asm Equivalent | Description |
| & | AND | Bitwise AND |
| | | OR | Bitwise Inclusive OR |
| ^ | XOR | Bitwise Exclusive OR |
| ~ | NOT | Unary complement (bit verson) |
| << | SHL | Shift Left |
| >> | SHR | Shift Right |
AWAITING MORE EDITS
