Lesson 04: Operations and Operators

Operations are fundamental actions performed on data in programming languages. Operators are symbols that represent these operations and provide a concise way to express computations. C/C++ offers a rich set of operators for various data types, enabling programmers to perform various calculations and manipulations.

4.1 Expressions, Operands and Operators

Expression, Operands, and Operators

Expressions are used to calculate a result involving a number of operands (either variables or constants). Operators allow us to manipulate the variables and constants in the expressions. Operands are the constants or variables upon which the operators operate.

In programming terms, an expression is something that expresses a value. It is either a simple value — or a single operand to express a single value.

120
"Welcome to EE2450"
score

or a set of operands that are combined together using operators:

5 + 12 + 15
value1 + value2
pow(x, 2) * r + 2

The operands of an expression may be variables, constants, other sub-expressions, or non-void function callings. Figure 1.1 illustrates the difference between operands, operators, and expressions.

F1 1 ExpressionsOperatorsOperandsSnap1
Figure 1.1: Operands, operators, and expressions

Expressions

Expressions

A simple expression is:

top = 10;

Here, the variable top is assigned the constant value 10. In this example, 10 is the expression.

Another example is:

sum = 2 + 6 + 10;

The expression 2 + 6 + 10 consists of two operators and three operands. This expression is simple to work out as variables 2, 6, and 10 are added together and the result of 18 is stored in sum.

Operators

Operands

Practice Exercise 4.1

4.2 Operators

C/C++ has a rich set of operators that can be divided into the following classes:

Binary Operators
Arithmetic, bitwise, shift operators
Non-binary Operators
Assignment, Logical, relational, conditional, and pointer operators

Assignment
Operators

Assignment Operators

The equal sign (=) in C/C++ is an operator called the assignment operator. It operates by setting the operand on its left to a value of the operand on its right. In other words, the equal sign (=) causes the value on its right to be assigned to (placed in) the variable on its left; that is, following the statement:

F2 1 AssignmentOperator

The variable a will have the value '8'.

Arithmetic
Operators

Arithmetic Operators

C/C++ has the following arithmetic operators:

Operator	Meaning	Example (A = 25, B = 7)		Description
+	Addition	A + B	25 + 7 = 32	Add A and B
-	Subtraction	A - B	25 -7 = 18	Subtract B from A
*	Multiplication	A * B	25 * 7 = 175	Multiply A and B
/	Division	A / B	25 / 7 = 3	Divide A by B
%	Modulus (Remainder)	A % B	25 % 7 = 4	The remainder of dividing A by B
+	Unary Positive	+A	+25
-	Unary Negative	-B	-7

Unary Positive

The role of a positive operator is to preserve the sign.

int i = 100;
int j = +i; // j = 100

Although such construction is syntactically correct, using it doesn’t make much sense, and it would be hard to find a good rationale for doing so.

Unary Negative

The negative operator changes the sign of its operand. A positive number becomes negative, and a negative number becomes positive.

int i = -100;
int j = -i; // j = 100
int k = -j; // k = -100

Remainder

The remainder operator (%) is quite peculiar because it has no equivalent amount of traditional arithmetic operators. You can use the % operator to find the remainder of a division, it is a binary operator (it performs the modulo operators), and both operands can not be floats.

int i = 12;
int j = 5;
int k = i % j;

The k variable is set to the value of 2.

Compute Quotient and Remainder

Write a program that asks a user to enter two integers (dividend and divisor), which are stored in variables dividend and divisor, respectively. Then the quotient is evaluated using / (the division operator) and stored in the quotient. Similarly, the remainder is evaluated using % (the modulo operator) and stored in the remainder.

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>

int main() {
    int dividend, divisor, quotient, remainder;

    printf("Enter dividend: ");
    scanf("%d", &dividend);
    printf("Enter divisor: ");
    scanf("%d", &divisor);

    // Computes quotient
    quotient = dividend / divisor;

    // Computes remainder
    remainder = dividend % divisor;

    printf("Quotient = %d\n", quotient);
    printf("Remainder = %d", remainder);
    return 0;
}

Logical
Operators

Logical Operators

It's often convenient to test several expressions' true/false values simultaneously and combine the results into a single true/false value.

True/false values can be operated on with logical operators. There are three logical operators in C/C++ (see below Table). Two of them combine two true/false values, and the third negates a true/false value.

Operator	Meaning	Example	Description
\|\|	Logical OR	(x==3) \|\| (x<1)	It returns true when at least one of the conditions is true
&&	Logical AND	(x>0) && (x<10)	It returns true when both conditions are true
!	Logical NOT	!(x > 10)	It reverses the state of the operand ("(x>10)") If (x>10) is true, the logical NOT operator makes it false.

The logical operator will convert the operands into Boolean values. Any value that is not equal to zero would be considered logic 1 (even negative numbers), and values that equal 0 are considered logic 0.

Example of all the logical operators

Try the following example:

#include <stdio.h>

main() {

    int a = 5;
    int b = 20;
    int c ;

    if ( a && b ) {
        printf("Line 1 - Condition is true.\n" );
    }

    if ( a || b ) {
        printf("Line 2 - Condition is true.\n" );
    }

    /* lets change the value of  a and b */
    a = 0;
    b = 10;

    if ( a && b ) {
        printf("Line 3 - Condition is true.\n" );
    } else {
        printf("Line 3 - Condition is not true.\n" );
    }

    if ( !(a && b) ) {
        printf("Line 4 - Condition is true.\n" );
    }
}

When you compile and execute the above program, it produces the following results −

Line 1 - Condition is true.
Line 2 - Condition is true.
Line 3 - Condition is not true.
Line 4 - Condition is true.

Bitwise
Operators

Bitwise Operators

C/C++ provides operators that act upon the actual bits that comprise a value. The bitwise operators can be used only on integral types. The bitwise operators are as follows:

Operator	Meaning	Example (A = 12, B = 38)	Description
~	Bitwise not	~A = -13	Binary One's Complement Operator is unary and has the effect of 'flipping' bits.
&	Bitwise and	(A & B) = 4	Binary AND Operator copies a bit to the result if it exists in both operands.
\|	Bitwise or	(A \| B) = 46	Binary OR Operator copies a bit if it exists in either operand.
^	Bitwise xor	(A ^ B) = 42	Binary XOR Operator copies the bit if it is set in one operand but not both.

The truth tables for bitwise operators are as follows:

x	y	~x	x & y	x \| y	x ^ y
0	0	1	0	0	0
0	1	1	0	1	1
1	0	0	0	1	1
1	1	0	1	1	0

These rules are applied to each bit in each operand when the bitwise and/or, and xor operations are performed.

A simple bitwise and operation is shown below:

00001100 = 12
& 00100110 = 38
------------------
00000100 = 4

A bitwise or operation looks like this:

00001100 = 12
| 00100110 = 38
------------------
00101110 = 46

A bitwise xor operation is shown here:

00001100 = 12
^ 00100110 = 38
------------------
00101010 = 42

The One's Complement Operator

The one's complement operator, ~, will invert all the bits in its operand. For example, if a is an 8-bit integer variable, and its value is a = 12. The binary value of a is 0b00001100.

The one's complement of an operation is shown here:

~ 00001100 = 12
------------------
11110011 = -13

Bit 7 is the sign bit, so 0b11110011 is -13 in decimal.

Masking and Setting Bits

Bit-wise or can be used to set a bit, and and can be used to clear a bit. It can be observed that:

Anything or with a 1, results in a 1; anything or with a 0, results in no change.
Anything and with a 1, results in no change; anything and with a 0, results in a zero.
Anything xor with a 1, results in the complement; anything xor with a 0, results in no change.

Example of all the bitwise operators

#include <stdio.h>

int main() {

    unsigned int a = 60;    // 60 = 0011 1100
    unsigned int b = 13;    // 13 = 0000 1101
    int c = 0;

    c = a & b;              // 12 = 0000 1100
    printf("Line 1 - Value of c is %d\n", c );

    c = a | b;              // 61 = 0011 1101
    printf("Line 2 - Value of c is %d\n", c );

    c = a ^ b;              // 49 = 0011 0001
    printf("Line 3 - Value of c is %d\n", c );

    c = ~a;                 //-61 = 1100 0011
    printf("Line 4 - Value of c is %d\n", c );

    return 0;
}

#include <stdio.h>
#include <iostream>
using namespace std;

int main() {

    unsigned int a = 60;    // 60 = 0011 1100
    unsigned int b = 13;    // 13 = 0000 1101
    int c = 0;

    c = a & b;              // 12 = 0000 1100
    cout << "Line 1 - Value of c is " << c << endl;

    c = a | b;              // 61 = 0011 1101
    cout << "Line 2 - Value of c is " << c << endl;

    c = a ^ b;              // 49 = 0011 0001
    cout << "Line 3 - Value of c is " << c << endl;

    c = ~a;                 //-61 = 1100 0011
    cout << "Line 4 - Value of c is " << c << endl;

    return 0;
}

When you compile and execute the above program, it produces the following results −

Line 1 - Value of c is 12
Line 2 - Value of c is 61
Line 3 - Value of c is 49
Line 4 - Value of c is -61

Relational
Operators

Relational Operators

The relational operators compare two expressions, producing a Boolean (true/false) result. They are most often used in the flow of control statements such as if-else statements, for-loops, while-loops, and do-while loops.

Operator	Meaning	Example A = 5; B = 2;	Description
>	Greater than	A > B	5 > 2, the result is True (1)
>=	Greater than or equal	A >= B	5 >= 2, the result is True (1)
<	Less than	A < B	5 < 2, the result is False (0)
<=	Less than or equal	A <= B	5 <= 2, the result is False (0)
==	Equal	A == B	5 == 2, the result is False (0)
!=	Not equal	A != B	5 != 2, the result is True (1)

Chaining of Comparison Operators in C

In Python, an expression like "c > b > a" is treated as "c > b and b > a", but this type of chaining does not happen in C. For example, consider the following program. The output of the following program is "FALSE".

#include <stdio.h>

int main()
{
    int a = 10, b = 20, c = 30;

    if (c > b > a)
        printf("TRUE");
    else
        printf("FALSE");
    return 0;
}

In line 7, the (c > b > a) is treated as ((c > b) > a), associativity of '>' is left to right. So, the expression becomes ((30 > 20) > 10), while the (30 > 20) is ture (1). The final expression becomes (1 > 20), and the result is false (0).

Inc/Decrement
Operators

Increment and Decrement Operators

Increment operators are used to increase the variable's value by one, and decrement operators are used to decrease the variable's value by one in the C/C++ program.

Operator	Meaning	Example a = 3; b = 7;	Description
++ var var ++	Increment operator	++a; b++;	++a ⇒ a += 1 ⇒ a + 1 = 4 b++ ⇒ b += 1 ⇒ b + 1 = 8
-- var var --	Decrement operator	--a; b--;	--a ⇒ a -= 1 ⇒ a - 1 = 2 b-- ⇒ b -= 1 ⇒ b - 1 = 6

Pre/Post Increment and Decrement Operators

When you use the increment and decrement operators in the expressions, they have different meanings. The below table will explain the difference between pre/post-increment and decrement operators in the C/C++ programming language.

Pre-Increment Operator
A pre-increment operator is used to increment the value of a variable before using it in an expression. In the Pre-Increment, the value is first incremented/decremented and then used inside the expression.
Pre-Decrement Operator
A pre-decrement operator is used to decrement the value of a variable before using it in an expression. In the Pre-Decrement, the value is first decremented and then used inside the expression.
Post-Increment Operator
A post-increment operator is used to increment the variable's value after executing the expression completely in which post-increment is used. In the Post-Decrement, the value is first used in an expression and then incremented.
Post-Decrement operator
A post-decrement operator is used to decrement the variable's value after executing the expression completely in which post-decrement is used. In the Post-Decrement, the value is first used in an expression and then decremented.

Syntax (i = 5, j = 2)	Function	Description
a = ++i;	Pre-increment operator (++i)	++i ⇒ i = 5 + 1 = 6; a = i; ⇒ a = 6
a = --i;	Pre-decrement operator (--i)	--i ⇒ i = 5 - 1 = 4; a = i; ⇒ a = 4
a = i++;	Post-increment operator (i++)	a = i; ⇒ a = 5 i++ ⇒ i = 5 + 1 = 6
a = i--;	Post-decrement operator (i--)	a = i; ⇒ a = 5; i-- ⇒ i = 5- 1 = 4
a = (++i) + (j--);	Pre-increment (++i) and Post-decrement (j--) operators	++i ⇒ i = 6 a = i + j ⇒ 6 + 2 = 8 j-- ⇒ j = 1

Simple post and pre-increment operator

// C program to demonstrate working of unary increment
// and decrement operators
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>

int main()
{
    // Post increment
    int a = 1;
    printf("a value: %d \n", a);
    int b = a++;
    printf("b value after b = a++ : %d \n", b);
    printf("a value after b = a++ : %d \n\n", a);

    // Pre increment
    a = 1;
    printf("a value: %d \n", a);
    b = ++a;
    printf("b value after b = ++a : %d \n", b);
    printf("a value after b = ++a : %d \n\n", a);

    // Post decrement
    a = 5;
    printf("a value before decrement: %d \n", a);
    b = a--;
    printf("b value after b = a-- : %d \n", b);
    printf("a value after b = a-- : %d \n\n", a);

    // Pre decrement
    a = 5;
    printf("a value: %d \n", a);
    b = --a;
    printf("b value after b = --a : %d \n", b);
    printf("a value after b = --a : %d \n", a);

    return 0;
}

Result:

a value: 1
b value after b = a++ : 1
a value after b = a++ : 2

a value: 1
b value after b = ++a : 2
a value after b = ++a : 2

a value before decrement: 5
b value after b = a-- : 5
a value after b = a-- : 4

a value: 5
b value after b = --a : 4
a value after b = --a : 4

Evaluating post and pre-increment together

#include <iostream>
using namespace std;

int main()
{
    int A = 10, B = 20, C = 0;

    C = A++ + ++B * 10 + B++;       // 1. ++B => B= B + 1 = 21
                                    // 2. C = A + B * 10 + B = 10 + 21 * 10 + 21 = 241
                                    // 3. A++ => A = A + 1 = 11
                                    //    B++ => B = B + 1 = 22

    cout << "A = " << A << ","
         << "B = " << B << ","
         << "C = " << C << endl;

    return 0;
}

Output:

A = 11,B = 22,C = 241

Post and Pre-increment Operators on Same Variable

#include <stdio.h>
#include <iostream>
using namespace std;

int main()
{
    int x;
    int y = 10;

    x = (++y)++;
    cout << "x = " << x << endl;
    cout << "y = " << y << endl;
    return 0;
}

The output:

x = 11
y = 12

Shift
Operators

Shift Operators

There are two bit-wise shift operators in C:

Shift Left (<< data <<) number of bit-positions to be shifted left.
Shift Right (>> data >>) number of bit-positions to be shifted right.

Operator	Meaning	Example (A = 0b0011 1100 = 60)	Description
X << n	Binary Left Shift Operator. The shift left operand value is moved left by the number of bits specified by the right operand.	A << 2 => 0b1111 0000 = 240	Shift the value 60 to the left 2 bits
X >> n	Binary Right Shift Operator. The shift left operand value is moved right by the number of bits specified by the right operand.	A >> 2 => 0b0000 1111 = 15	Shift the value 60 to the right 2 bits

X must be an integer (signed or unsigned)
n must be an unsigned integer and the value is from 0 to less than the number of bits of X value.

Logical Shift (for unsigned integers)

In a logical shift, zeros are shifted in to replace the discarded bits. Therefore, the logical and arithmetic left-shifts are exactly the same.

However, as the logical right-shift inserts value 0 bits into the most significant bit, instead of copying the sign bit, it is ideal for unsigned binary numbers, while the arithmetic right-shift is ideal for signed two's complement binary numbers.

Left Right Operation
Left Logical Shift

The left-shift operator causes the bits in X to be shifted to the left by the number of positions specified by n. The bit positions that have been vacated by the shift operation are zero-filled. A left shift is a logical shift (the bits that are shifted off the end are discarded, including the sign bit).

Shift Right Operation
Right Logical Shift

The right-shift operator causes the bit pattern in X to be shifted to the right by the number of positions specified by n. For unsigned numbers, the bit positions that have been vacated by the shift operation are zero-filled.

Arithmetic shift (for signed integers)

In an arithmetic shift, the bits that are shifted out of either end are discarded. In a left arithmetic shift, zeros are shifted in on the right; in a right arithmetic shift, the sign bit (the MSB in two's complement) is shifted in on the left, thus preserving the sign of the operand.

LeftArithmeticShift
Left Arithmetic Shift

A left arithmetic shift of a number X by n is equivalent to multiplying X by 2ⁿ and is thus equivalent to a logical left shift; a logical shift would also give the same result since MSB anyway falls off the end and there's nothing to preserve. The left-shift operations can be used on unsigned and signed numbers.

RightArithmeticShift
Right Arithmetic Shift

A right arithmetic shift of a number X by n is equivalent to an integer division of X by 2ⁿ ONLY if X is non-negative! Integer division is nothing but mathematical division and rounds towards 0. For signed numbers, the sign bit is used to fill the vacated bit positions. In other words, if the number is positive, 0 is used, and if the number is negative, 1 is used.

Logical and Arithmetic Shifts

When shifting left (<<), there is no difference between arithmetic and logical shift.

When shifting an unsigned value, the >> operator in C is a logical shift. When shifting a signed value, the >> operator is an arithmetic shift.

#include <stdio.h>
#include <stdint.h>
void bin8ToStr(uint8_t num, char* bitStr);


int main()
{
    int8_t      i8 = 0b11101010;
    uint8_t     u8 = 0b11101010;
    int8_t      iResult;
    uint8_t     uResult;

    char    bitStr[17] = {0};

    bin8ToStr(i8, bitStr);
    printf("Original signed Value:    %s (0x%02X, %03d) \n",   bitStr, i8 & 0xFF, i8);
    iResult = i8 >> 2;
    bin8ToStr(iResult, bitStr);
    printf("Shifted 2 right:          %s (0x%02X, %03d) \n",   bitStr, iResult & 0xFF, iResult);
    iResult = i8 << 2;
    bin8ToStr(iResult, bitStr);
    printf("Shifted 2 left:           %s (0x%02X, %03d) \n\n", bitStr, iResult & 0xFF, iResult);

    i8 = 22;
    bin8ToStr(i8, bitStr);
    printf("Original signed Value:    %s (0x%02X, %03d) \n",   bitStr, i8, i8);
    iResult = i8 >> 2;
    bin8ToStr(iResult, bitStr);
    printf("Shifted 2 right:          %s (0x%02X, %03d) \n",   bitStr, iResult & 0xFF, iResult);
    iResult = i8 << 2;
    bin8ToStr(iResult, bitStr);
    printf("Shifted 2 left:           %s (0x%02X, %03d) \n\n", bitStr, iResult & 0xFF, iResult);

    bin8ToStr(u8, bitStr);
    printf("Original unsigned Value : %s (0x%02X, %03d) \n",   bitStr, u8, u8);
    uResult = u8 >> 2;
    bin8ToStr(uResult, bitStr);
    printf("Shifted 2 right:          %s (0x%02X, %03d) \n",   bitStr, uResult & 0xFF, uResult);
    uResult = u8 << 2;
    bin8ToStr(iResult, bitStr);
    printf("Shifted 2 left:           %s (0x%02X, %03d) \n\n", bitStr, uResult & 0xFF, uResult);

    return 0;
}

void bin8ToStr(uint8_t num, char* bitStr)
{
    int i;

    for (i = 0; i < 8; i++)
        bitStr[i] = (char)((num >> (7-i)) & 0x01) + '0';
}

Output

Original signed Value: 11101010 (0xEA, -22)
Shifted 2 right: 11111010 (0xFA, -06)
Shifted 2 left: 10101000 (0xA8, -88)

Original signed Value: 00010110 (0x16, 022)
Shifted 2 right: 00000101 (0x05, 005)
Shifted 2 left: 01011000 (0x58, 088)

Original unsigned Value : 11101010 (0xEA, 234)
Shifted 2 right: 00111010 (0x3A, 058)
Shifted 2 left: 01011000 (0xA8, 168)

Rotate (Circular Shifts)

In this operation, sometimes called rotate no carry, the bits are "rotated" as if the left and right ends of the register were joined. The value that is shifted into the right during a left shift is whatever value was shifted out on the left, and vice versa for a right shift operation. This is useful if it is necessary to retain all the existing bits, and is frequently used in digital cryptography.

LeftCircularRotate
Left Circular Shift or Rotate

RightCircularRotate
Right Circular Shift or Rotate

Circular Shifts (Rotate) in C

C++ 20 already provides std::rotl and std::rotr rotate functions, but C does not have operators or standard functions for rotating, even though most processors have bitwise operation instructions for rotating (e.g., Intel x86 has ROL and ROR instructions).

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>     // for uint8_t, to get 8-bit-wide rotates
#include <stdbool.h>

void bin8ToStr(uint8_t num, char* bitStr);
uint8_t rotl8(uint8_t num, uint8_t count);
uint8_t rotr8(uint8_t num, uint8_t count);

int main()
{
    uint8_t     u8 = 0b10010110;
    uint8_t     uResult;

    char    bitStr[9] = {0};

    bin8ToStr(u8, bitStr);
    printf("Original Value:             %s (0x%02X, %03d) \n",   bitStr, u8 & 0xFF, u8);
    uResult = rotl8(u8, 1);
    bin8ToStr(uResult, bitStr);
    printf("Left circular Shift by 1 :  %s (0x%02X, %03d) \n",   bitStr, uResult & 0xFF, uResult);
    uResult = rotl8(u8, 2);
    bin8ToStr(uResult, bitStr);
    printf("Left circular Shift by 2 :  %s (0x%02X, %03d) \n",   bitStr, uResult & 0xFF, uResult);
    uResult = rotl8(u8, 3);
    bin8ToStr(uResult, bitStr);
    printf("Left circular Shift by 3 :  %s (0x%02X, %03d) \n",   bitStr, uResult & 0xFF, uResult);
    uResult = rotl8(u8, 4);
    bin8ToStr(uResult, bitStr);
    printf("Left circular Shift by 4 :  %s (0x%02X, %03d) \n",   bitStr, uResult & 0xFF, uResult);
    uResult = rotl8(u8, 5);
    bin8ToStr(uResult, bitStr);
    printf("Left circular Shift by 5 :  %s (0x%02X, %03d) \n",   bitStr, uResult & 0xFF, uResult);
    uResult = rotl8(u8, 6);
    bin8ToStr(uResult, bitStr);
    printf("Left circular Shift by 6 :  %s (0x%02X, %03d) \n",   bitStr, uResult & 0xFF, uResult);
    uResult = rotl8(u8, 7);
    bin8ToStr(uResult, bitStr);
    printf("Left circular Shift by 7 :  %s (0x%02X, %03d) \n",   bitStr, uResult & 0xFF, uResult);
    uResult = rotl8(u8, 8);
    bin8ToStr(uResult, bitStr);
    printf("Left circular Shift by 8 :  %s (0x%02X, %03d) \n\n", bitStr, uResult & 0xFF, uResult);



    uResult = rotr8(u8, 1);
    bin8ToStr(uResult, bitStr);
    printf("Right circular Shift by 1 : %s (0x%02X, %03d) \n",   bitStr, uResult & 0xFF, uResult);
    uResult = rotr8(u8, 2);
    bin8ToStr(uResult, bitStr);
    printf("Right circular Shift by 2 : %s (0x%02X, %03d) \n",   bitStr, uResult & 0xFF, uResult);
    uResult = rotr8(u8, 3);
    bin8ToStr(uResult, bitStr);
    printf("Right circular Shift by 3 : %s (0x%02X, %03d) \n",   bitStr, uResult & 0xFF, uResult);
    uResult = rotr8(u8, 4);
    bin8ToStr(uResult, bitStr);
    printf("Right circular Shift by 4 : %s (0x%02X, %03d) \n",   bitStr, uResult & 0xFF, uResult);
    uResult = rotr8(u8, 5);
    bin8ToStr(uResult, bitStr);
    printf("Right circular Shift by 5 : %s (0x%02X, %03d) \n",   bitStr, uResult & 0xFF, uResult);
    uResult = rotr8(u8, 6);
    bin8ToStr(uResult, bitStr);
    printf("Right circular Shift by 6 : %s (0x%02X, %03d) \n",   bitStr, uResult & 0xFF, uResult);
    uResult = rotr8(u8, 7);
    bin8ToStr(uResult, bitStr);
    printf("Right circular Shift by 7 : %s (0x%02X, %03d) \n",   bitStr, uResult & 0xFF, uResult);
    uResult = rotr8(u8, 8);
    bin8ToStr(uResult, bitStr);
    printf("Right circular Shift by 8 : %s (0x%02X, %03d) \n",   bitStr, uResult & 0xFF, uResult);
    return 0;
}
//------------------------------------------------------------------------------
void bin8ToStr(uint8_t num, char* bitStr)
{
    int i;

    for (i = 0; i < 8; i++)
        bitStr[i] = (char)((num >> (7-i)) & 0x01) + '0';
}
//------------------------------------------------------------------------------
uint8_t rotl8(uint8_t num, uint8_t count)
{
    uint8_t    result;

    result = (count % 8) ? (num << count) | (num >> (8 - count)) : num;
    return result;
}
//------------------------------------------------------------------------------
uint8_t rotr8(uint8_t num, uint8_t count)
{
    uint8_t    result;

    result = (count % 8) ? (num >> count) | (num << (8 - count)) : num;
    return result;
}
//------------------------------------------------------------------------------

Output

Original Value: 10010110 (0x96, 150)
Left circular Shift by 1 : 00101101 (0x2D, 045)
Left circular Shift by 2 : 01011010 (0x5A, 090)
Left circular Shift by 3 : 10110100 (0xB4, 180)
Left circular Shift by 4 : 01101001 (0x69, 105)
Left circular Shift by 5 : 11010010 (0xD2, 210)
Left circular Shift by 6 : 10100101 (0xA5, 165)
Left circular Shift by 7 : 01001011 (0x4B, 075)
Left circular Shift by 8 : 10010110 (0x96, 150)

Right circular Shift by 1 : 01001011 (0x4B, 075)
Right circular Shift by 2 : 10100101 (0xA5, 165)
Right circular Shift by 3 : 11010010 (0xD2, 210)
Right circular Shift by 4 : 01101001 (0x69, 105)
Right circular Shift by 5 : 10110100 (0xB4, 180)
Right circular Shift by 6 : 01011010 (0x5A, 090)
Right circular Shift by 7 : 00101101 (0x2D, 045)
Right circular Shift by 8 : 10010110 (0x96, 150)

Rotate through Carry

Rotate through carry is a variant of the rotate operation, where the bit that is shifted in (on either end) is the old value of the carry flag, and the bit that is shifted out (on the other end) becomes the new value of the carry flag.

A single rotate-through carry can simulate a logical or arithmetic shift of one position by setting up the carry flag beforehand. For example, if the carry flag contains 0, then x RIGHT-ROTATE-THROUGH-CARRY-BY-ONE is a logical right-shift, and if the carry flag contains a copy of the sign bit, then x RIGHT-ROTATE-THROUGH-CARRY-BY-ONE is an arithmetic right-shift. For this reason, some microcontrollers such as low-end PICs just have to rotate and rotate through carry and don't bother with arithmetic or logical shift instructions.

Rotate-through carry is especially useful when performing shifts on numbers larger than the processor's native word size because if a large number is stored in two registers, the bit that is shifted off one end of the first register must come in at the other end of the second. With rotate-through-carry, that bit is "saved" in the carry flag during the first shift, ready to shift in during the second shift without any extra preparation.

LeftCircularRotate
Left Rotate Through Carry

RightCircularRotate

Right Rotate Through Carry

Conditional
Operators

Conditional Operator

The conditional operator is the only C/C++ operator that operates on three operands. It consists of two symbols: a question mark (?) and a colon (:).

Operator	Meaning	Example	Description
( )? :	Conditional Operator	nabs = (n > 0)? n : -n;	Find the absolute value of variable n

The syntax of the conditional operator is:

(condition) ? (expr_true) : (expr_false) ;

The conditional operator was invented because a particular construction occurs often in C/C++ programs and it is nice to shorten it.

Pointer
Operators

Comma
Operators

The comma in C/C++

In C/C++, comma (,) can be used in two contexts:

Comma as an operator

Comma as an operator

The comma operator (,) is a binary operator that evaluates its first operand and discards the result, it then evaluates the second operand and returns this value (and type). The use of the comma token as an operator is distinct from its use in function calls and definitions, variable declarations, enum declarations, and similar constructs, where it acts as a separator.

The comma operator has the lowest precedence of any C operator and acts as a sequence point.

// comma as an operator
int i = (5, 10); // 10 is assigned to i
int j = (f1(), f2()); // f1() is called (evaluated) first followed by f2().
// The returned value of f2() is assigned to j

The primary use of the comma operator is to produce side effects in the following situations:

Calling a function
Entering or repeating an iteration loop
Testing a condition
Other situations where a side effect is required but the result of the expression is not immediately needed

The following table gives some examples of the uses of the comma operator.

Statement	Description
f (a, (t = 3, t + 2), c);	The function f() has only three arguments: the value of a, the value 5, and the value of c.
for ( i=0; i < 2; ++i, f() );	A for statement in which i is incremented and f() is called at each iteration.
if ( f(), ++i, i > 1 ) { / ... / }	An if statement in which function f() is called, variable i is incremented, and variable i is tested against a value. The first two expressions within this comma expression are evaluated before the expression i > 1. Regardless of the results of the first two expressions, the third is evaluated, and its result determines whether the if statement is processed.
func( ( ++a, f(a) ) );	A function call to func() in which a is incremented, the resulting value is passed to a function f(), and the return value of f() is passed to func(). The function func() is passed only a single argument because the comma expression is enclosed in parentheses within the function argument list.

Comma Operator in for-Loops

The most common use is to allow multiple assignment statements without using a block statement, primarily in the initialization and the increment expressions of a for-loop. This is the only idiomatic use in elementary C programming. In the following example, the order of the loop's initializers is significant:


void rev(char *s, size_t len)
{
    char *first;

    for (first = s, s += len; s >= first; --s) {
        putchar(*s);
    }
}

Comma Operator in Condition

Use Comma Operator to avoid a Block

For brevity, the comma can be used to avoid a block and associated braces, as in:


if (x == 1) y = 2, z = 3;
if (x == 1)
    y = 2, z = 3;

instead of


if (x == 1) {y = 2; z = 3;}
if (x == 1) {
    y = 2; z = 3;
}

Comma Operator in Place of a Semicolon

Comma operator in place of a semicolon.

We know that in C and C++, every statement is terminated with a semicolon, but the comma operator is also used to terminate the statement after satisfying the following rules.

The variable declaration statements must be terminated with a semicolon.
The comma operator can terminate the statements after the declaration statement.
A semicolon must terminate the last statement of the program.

Example:


#include <iostream>
using namespace std;
int main()
{
    cout << "First Line\n",
    cout << "Second Line\n",
    cout << "Third Line\n",
    cout << "Last line";

    return 0;
}

Output

First Line
Second Line
Third Line
Last line

Comma as a Separator

Commas as a Separator

Comma acts as a separator when used with function calls and definitions, function-like macros, variable declarations, enum declarations, and similar constructs.


// comma as a separator
int a = 1, b = 2;
void fun(x, y);

The use of the comma as a separator should not be confused with the use of an operator. For example, in the below statement, f1() and f2() can be called in any order.


// Comma acts as a separator here and doesn't enforce any sequence.
//    Therefore, either f1() or f2() can be called first
void fun(f1(), f2());

See this for C vs C++ differences of using the comma operator. You can try the below programs to check your understanding of commas in C.

// PROGRAM 1
#include <stdio.h>
int main()
{
    int x = 10;
    int y = 15;

    printf("%d", (x, y));
    getchar();
    return 0;
}

// PROGRAM 2: Thanks to Shekhu for suggesting this program
#include <stdio.h>
int main()
{
    int x = 10;
    int y = (x++, ++x);
    printf("%d", y);
    getchar();
    return 0;
}

// PROGRAM 3: Thanks to Venki for suggesting this program
#include <stdio.h>
int main()
{
    int x = 10, y;

    // The following is equivalent
    // to y = x + 2 and x += 3,
    // with two printings
    y = (x++,
         printf("x = %d\n", x),
         ++x,
         printf("x = %d\n", x),
         x++);

    // Note that last expression is evaluated
    // but side effect is not updated to y
    printf("y = %d\n", y);
    printf("x = %d\n", x);

    return 0;
}

More Examples for Comma

In this example, the different behavior between the second and third lines is due to the comma operator having lower precedence than the assignment. The last example also differs since the return expression must be fully evaluated before the function can return.

/**
 *  Commas act as separators in this line, not as an operator.
 *  Results: a=1, b=2, c=3, i=0
 */
int a=1, b=2, c=3, i=0;

/**
 *  Assigns value of b into i.
 *  Results: a=1, b=2, c=3, i=2
 */
int a=1, b=2, c=3;
int i = (a, b);

/**
 *  Assigns value of a into i. Equivalent to (i = a), b;
 *  Results: a=1, b=2, c=3, i=1
 *  (The braces on the second line are needed to
 *   avoid a compiler error.  The second 'b' declared
 *   is given no initial value.)
 */
int a=1, b=2, c=3;
{ int i = a, b; }

/**
 *  Increases value of a by 2, then assigns value of resulting operation a+b into i .
 *  Results: a=3, b=2, c=3, i=5
 */
int a=1, b=2, c=3;
int i = (a += 2, a + b);

/**
 *  Increases value of a by 2, then stores value of a to i, and discards unused
 *  values of resulting operation a + b . Equivalent to (i = (a += 2)), a + b;
 *  Results: a=3, b=2, c=3, i=3
 */
int a=1, b=2, c=3;
int i;
i = a += 2, a + b;

/**
 *  Assigns value of a into i;  the following 'b' and 'c'
 *  are not part of the initializer but declarators for
 *  second instances of those variables.
 *  Results: a=1, b=2, c=3, i=1
 *  (The braces on the second line are needed to
 *   avoid a compiler error.  The second 'b' and second
 *   'c' declared are given no initial value.)
 */
int a=1, b=2, c=3;
{ int i = a, b, c; }

/**
 *  Assigns value of c into i, discarding the unused a and b values.
 *  Results: a=1, b=2, c=3, i=3
 */
int a=1, b=2, c=3;
int i = (a, b, c);

/**
 *  Returns 6, not 4, since comma operator sequence points following the keyword
 *  'return' are considered a single expression evaluating to rvalue of final
 *  subexpression c=6 .
 */
return a=4, b=5, c=6;

/**
 *  Returns 3, not 1, for same reason as previous example.
 */
return 1, 2, 3;

/**
 *  Returns 3, not 1, still for same reason as above. This example works as it does
 *  because return is a keyword, not a function call. Even though compilers will
 *  allow for the construct return(value), the parentheses are only relative to "value"
 *  and have no special effect on the return keyword.
 *  Return simply gets an expression and here the expression is "(1), 2, 3".
 */
return (1), 2, 3;

Miscellaneous
Operators

Miscellaneous Operators

Member Operators

The dot (.) operator and the arrow (->) operator can be used to reference individual members of classes, structures, and unions. The dot operator is applied to the actual object. The arrow operator is used with a pointer to an object.

Operator	Description	Example	Description
.	member access	a.b	access member b of struct, union, or class a.
->	member access through a pointer	a->b	access member b of struct, union, or class pointed to by a.

Scope Resolution
Operator (C++)

Scope Resolution Operator

The scope resolution operator :: is used to identify and disambiguate identifiers used in different scopes.

Syntax	Description
::identifier
className::identifier
namespace::identifier
enum class::identifier
enum struct::identifier

The identifier can be a variable, a function, or an enumeration value.

With Classes and Namespace

The following example shows how the scope resolution operator is used with namespaces and classes:

namespace NamespaceA{
    int x;
    class ClassA {
    public:
        int x;
    };
}

int main() {

    // A namespace name used to disambiguate
    NamespaceA::x = 1;

    // A class name used to disambiguate
    NamespaceA::ClassA a1;
    a1.x = 2;
}

A scope resolution operator without a scope qualifier refers to the global namespace.

namespace NamespaceA{
    int x;
}

int x;

int main() {
    int x;

    // the x in main()
    x = 0;
    // The x in the global namespace
    ::x = 1;

    // The x in the A namespace
    NamespaceA::x = 2;
}

You can use the scope resolution operator to identify a member of a namespace, or to identify a namespace that nominates the member's namespace in a using-directive. In the example below, you can use NamespaceC to qualify ClassB, even though ClassB was declared in namespace NamespaceB, because NamespaceB was nominated in NamespaceC by a using directive.

namespace NamespaceB {
    class ClassB {
    public:
        int x;
    };
}

namespace NamespaceC{
    using namespace B;
}
int main() {
    NamespaceB::ClassB c_b;
    NamespaceC::ClassB c_c;

    c_b.x = 3;
    c_c.x = 4;
}

You can use chains of scope resolution operators. In the following example, NamespaceD::NamespaceD1 identifies the nested namespace NamespaceD1, and NamespaceE::ClassE::ClassE1 identifies the nested class ClassE1.

namespace NamespaceD{
    namespace NamespaceD1{
        int x;
    }
}

namespace NamespaceE{
    class ClassE{
    public:
        class ClassE1{
        public:
            int x;
        };
    };
}

int main() {
    NamespaceD:: NamespaceD1::x = 6;
    NamespaceE::ClassE::ClassE1 e1;
    e1.x = 7  ;
}

With Static Members

You must use the scope resolution operator to call static members of classes.

class ClassG {
public:
    static int get_x() { return x;}
    static int x;
};

int ClassG::x = 6;

int main() {

    int gx1 = ClassG::x;
    int gx2 = ClassG::get_x();
}

With Scoped Enumerations

The scoped resolution operator is also used with the values of a scoped enumeration Enumeration Declarations, as in the following example:

enum class EnumA{
    First,
    Second,
    Third
};

int main() {
    EnumA enum_value = EnumA::First;
}

Pointer-to-Member Operators (C++)

I/O Operators (C++)

4.3 Compound Assignment Operators

The compound assignment operators consist of a binary operator and a simple assignment operator. They perform the operation of the binary operator on both operands and store the result of that operation in the left operand, which must be a modifiable lvalue.

The following table lists the compound assignment operators and shows an expression using each operator:

Operator	Meaning	Example	Description
+=	Add AND assignment operator. It adds the right operand to the left operand and assigns the result to the left operand.	a += exp;	a = a + (exp);
-=	Subtract AND assignment operator. It subtracts the right operand from the left operand and assigns the result to the left operand.	a -= exp;	a = a - (exp);
*=	Multiply AND assignment operator. It multiplies the right operand with the left operand and assigns the result to the left operand.	a *= exp;	a = a * (exp);
/=	Divide AND assignment operator. It divides the left operand with the right operand and assigns the result to the left operand.	a /= exp;	a = a / (exp);
%=	Modulus AND assignment operator. It takes modulus using two operands and assigns the result to the left operand.	a %= exp;	a = a % (exp);
<<=	Left shift AND assignment operator.	a <<= exp;	a = a << (exp);
>>=	Right shift AND assignment operator.	a >>= exp;	a = a >> (exp);
&=	Bitwise and assignment operator.	a &= exp;	a = a & (ex);
\|=	Bitwise or and assignment operator	a \|= exp;	a = a \| (exp);
^=	Bitwise xor and assignment operator.	a ^= exp;	a = a ^ (exp);

Note: the expression

a *= b + c;

is equivalent to

a = a * (b + c);

and not

a = a * b + c;

Example of compound operators

Let's have a look at an example using some of these operators:


#include <iostream>
using namespace std;

int main() {
   int a = 3, b = 2;

   a += b;
   cout << a << endl;

   a -= b;
   cout << a << endl;

   a *= b;
   cout << a << endl;

   a /= b;
   cout << a << endl;

   return 0;
}

This will give the output:

5
3
6
3

4.4 Order of Operations

In mathematics and computer programming, the order of operations (or operator precedence) is a collection of rules that reflect conventions about which procedures to perform first in order to evaluate a given mathematical expression.

The following table is the operator precedence in C/C++

Precedence ¹	Operator ²	Description	Example	Associativity ³
1	::	Scope resolution	class::mdata class::mfunction()	Left-to-right
1	::	Global scope	::variable	Right-to-left
2	++ --	Post increment and post decrement	v++ v--	Left-to-right
	( )	Grouping (parentheses)	(expr)	Left-to-right
	( )	Function call	function(args)	Left-to-right
	[ ]	Array indexing or subscripting	array[index]	Left-to-right
	.	Member selection by reference	obj.field obj.mfunc()	Left-to-right
	->	Member selection by pointer	obj->field obj->mfunc()	Left-to-right
3	++ --	Pre increment and pre decrement	++v --v	Right-to-left
	+ -	Unary positive and negative	-N -(a+b)	Right-to-left
	! ~	Logical NOT and bitwise not	!a, !(a&&b) ~k	Right-to-left
	(dataType)	Type cast (convert value to temporary value of type)	(int) var	Right-to-left
	*	indirection (dereference)	*p	Right-to-left
	&	address-of	&var	Right-to-left
	sizeof	Size-of (Determine size in bytes)	sizeof(int), sizeof(var)	Right-to-left
	new new[]	Dynamic memory allocation	Person p = new Person; int scores = new int[100];	Right-to-left
	delete delete[]	Dynamic memory deallocation	delete p; delete [] score;	Right-to-left
4	.* ->*	Pointer to member		Left-to-right
5	* / %	Multiplication Division Remainder	3 * x y / z a % 2	Left-to-right
6	+ -	Addition Subtraction	a + b a - b	Left-to-right
7	<< >>	Bitwise shift left Bitwise shift right	x << 2 y >> 2	Left-to-right
7	<< >>	Overloaded stream I/O	cout << x cin >> y	Left-to-right
8	< <= > >=	For relational operators < and ≦ respectively For relational operators > and ≧ respectively	x < 10, x <= 10 x > 10, x >= 10	Left-to-right
9	== !=	For relational = and ≠ respectively	x == y, x != y	Left-to-right
10	&	Bitwise and	x & 0x00008000	Left-to-right
11	^	Bitwise xor	x ^ 0xFFFF0000	Left-to-right
12	\|	bitwise or	x \| 0x00000004	Left-to-right
13	&&	Logical AND	x && y	Left-to-right
14	\|\|	Logical OR	x \|\| y	Left-to-right
15	? :	Conditional operator	(x < y)? x : y;	Right-to-left
	=	Direct assignment (provided by default for C++ classes)	x = y + b * sqrt(c)	Right-to-left
	+= -=	Assignment by sum and difference	x += 2, x -= 2	Right-to-left
	*= /= %=	Assignment by product, quotient, and remainder	x *= 2, x /= 2, x %= 2	Right-to-left
	<<= >>=	Assignment by bitwise left shift and right shift	x <<= 2, x >>= 2	Right-to-left
	&= ^= !=	Assignment by bitwise and, xor, and or	a &= b, a \|= b, a ^= b	Right-to-left
16	throw	Throw operator (for exceptions)	throw over_flow	Left-to-right
17	,	The comma (separate expressions)	i = 0, j = 0, i++, j++	Left-to-right

Highest operator precedence to lowest. Operators in the same group (horizontal lines separate groups) have the same precedence.
Unary operators are in blue, binary operators are in yellow, and the single ternary operator is in green
Associativity is only used when two or more operators of the same precedence exist.
- Left-to-right: evaluates left to right. e.g. in a + b + c, a + b is evaluated first.
- Right-to-left: evaluates right to left. eg. in a = b = c, b = c is evaluated first.

Precedence of Function Calls

Consider the following program: associativity of the + operator is left-to-right, but it does not mean f1() is always called before f2(). The output of the following program is in fact compiler-dependent.

#include <stdio.h>

int x = 0;
int f1()
{
    x = 5;
    return x;
}
int f2()
{
    x = 10;
    return x;
}
int main()
{
    int p = f1() + f2();
    printf("p = %d, x = %d \n\n", p, x);
    return 0;
}

Carefully to Use Comma

Comma has the least precedence among all operators and should be used carefully.

For example, consider the following program: the output is 1. See this and this for more details.

#include <stdio.h>
int main() 
{ 
    int a; 
    a = 1, 2, 3; // Evaluated as (a = 1), 2, 3 
    printf("%d", a); 
    return 0; 
}

Precedence of Logical and Increment Operators

x && y++

The second operand, y++, is evaluated only if x is true (non-zero).
Thus, y is not incremented if x is false (zero).

#include <stdio.h>
#include <iostream>
using namespace std;

int main()
{
    int x = 0;
    int y = 10;

    if (x && y++) {
        cout << "Condition result is true." << endl;
    } else {
        cout << "Condition result is false." << endl;
    }

    cout << "y = " << y << endl;

    return 0;
}

4.5 Multiple Unsequenced Modifications to the Same Variable

The modification of a variable is unsequenced relative to another operation on the same variable. This may lead to undefined behavior.

The analyzer detected an expression leading to undefined behavior. A variable is used several times between two sequence points while its value is changing. We cannot predict the result of such an expression. Let's consider the notions of "undefined behavior" and "sequence point" in detail.

Undefined behavior is a feature of some programming languages — most famously C/C++. In these languages, to simplify the specification and allow some flexibility in implementation, the specification leaves the results of certain operations specifically undefined.

For example, in C, the use of any automatic variable before it has been initialized yields undefined behavior, as do division by zero and indexing an array outside of its defined bounds. This specifically frees the compiler to do whatever is easiest or most efficient should such a program be submitted. In general, any behavior afterward is also undefined. In particular, it is never required that the compiler diagnose undefined behavior — therefore, programs invoking undefined behavior may appear to compile and even run without errors at first, only to fail on another system, or even on another date. When an instance of undefined behavior occurs, so far as the language specification is concerned anything could happen, maybe nothing at all.

A sequence point in imperative programming defines any point in a computer program's execution at which it is guaranteed that all side effects of previous evaluations will have been performed, and no side effects from subsequent evaluations have yet been performed. They are often mentioned in reference to C and C++ because the result of some expressions can depend on the order of evaluation of their subexpressions. Adding one or more sequence points is one method of ensuring a consistent result because this restricts the possible orders of evaluation.

It is worth noting that in C++11, the terms sequenced before/after, sequenced, and unsequenced were introduced instead of sequence points. Many expressions, resulting in undefined behavior in C++03, became defined (for instance, i = ++i). These rules were also supplemented in C++14 and C++17. The analyzer issues a false positive regardless of the used standard. The certainty of the expressions of i = ++i type is not an excuse to use them. It is better to rewrite such expressions to make them more understandable. Also, if you need to support an earlier standard, you can get a bug that is hardly debugged.

i = ++i + 2; // undefined behavior until C++11
i = i++ + 2; // undefined behavior until C++17
f(i = -2, i = -2); // undefined behavior until C++17
f(++i, ++i); // undefined behavior until C++17,
// unspecified after C++17
i = ++i + i++; // undefined behavior
cout << i << i++; // undefined behavior until C++17
a[i] = i++; // undefined behavior until C++17
n = ++i + i; // undefined behavior

Sequence points come into play when the same variable is modified more than once within a single expression. An often-cited example is an expression i = i++, which both assigns i to itself and increments i. The final value of i is ambiguous, because, depending on the language semantics, the increment may occur before, after, or interleaved with the assignment. The definition of a particular language might specify one of the possible behaviors or simply say the behavior is undefined. In C and C++, evaluating such an expression yields undefined behavior.

C and C++ define the following sequence points:

Between evaluation of the left and right operands of the && (logical AND), || (logical OR), and comma operators (,). For example, in the expression *p++ != 0 && *q++ != 0;, all side effects of the sub-expression *p++ != 0 are completed before any attempt to access q.
Between the evaluation of the first operand of the ternary "question-mark" operator and the second or third operand. For example, in the expression a = (*p++) ? (*p++) : 0; there is a sequence point after the first *p++, meaning it has already been incremented by the time the second instance is executed.
At the end of a full expression. This category includes expression statements (such as the assignment a = b;), return statements, the controlling expressions of if, switch, while, or do-while statements, and all three expressions in a for statement.
Before a function is entered in a function call. The order in which the arguments are evaluated is not specified, but this sequence point means that all of their side effects are complete before the function is entered. In the expression f(i++) + g(j++) + h(k++), f is called with a parameter of the original value of i, but i is incremented before entering the body of f. Similarly, j and k are updated before entering g and h respectively. However, it is not specified in which order f(), g(), h() are executed, nor in which order i, j, k are incremented. The values of j and k in the body of f are therefore undefined. Note that a function call f(a,b,c) is not a use of the comma operator and the order of evaluation for a, b, and c is unspecified.
At a function return, after the return value is copied into the calling context. (This sequence point is only specified in the C++ standard; it is present only implicitly in C[4].)
At the end of an initializer; for example, after the evaluation of 5 in the declaration int a = 5;.
In C++, overloaded operators act as functions, so a call of an overloaded operator is a sequence point.

Now let's consider several samples causing undefined behavior:

int i, j;
...
X[i] = ++i;
X[i++] = i;
j = i + X[++i];
i = 6 + i++ + 2000;
j = i++ + ++i;
i = ++i + ++i;

We cannot predict the calculation results in all these cases. Of course, these samples are artificial and we can notice the danger right away. So let's examine a code sample taken from a real application:


while (!(m_pBitArray[m_nCurrentBitIndex >> 5] &
        Powers_of_Two_Reversed[m_nCurrentBitIndex++ & 31])) {
}
return (m_nCurrentBitIndex - BitInitial - 1);

The compiler can calculate either of the left or right arguments of the '&' operator first. It means that the m_nCurrentBitIndex variable might be already incremented by one when calculating "m_pBitArray[m_nCurrentBitIndex >> 5]". Or it might still be not incremented.

This code may work well for a long time. However, you should keep in mind that it will behave correctly only when it is built in some particular compiler version with a fixed set of compilation options. This is the correct code:


while (!(m_pBitArray[m_nCurrentBitIndex >> 5] &
        Powers_of_Two_Reversed[m_nCurrentBitIndex & 31])) { ++m_nCurrentBitIndex; }
return (m_nCurrentBitIndex - BitInitial);

This code does not contain ambiguities anymore. We also got rid of the magic constant "-1".

Programmers often think that undefined behavior may occur only when using post-increment, while pre-increment is safe. It's not so. Further is an example from a discussion on this subject.

[Warning] multiple unsequenced modifications

References:

PVS-Studio Documentation. V567.
Wikipedia. Undefined behavior.
Wikipedia. Sequence point.
Klaus Kreft & Angelika Langer. Sequence Points and Expression Evaluation in C++.
Discussion at Bytes.com. Sequence points.
Discussion at StackOverflow.com. Why is a = (a+b) - (b=a) a bad choice for swapping two integers?
cppreference.com. Order of evaluation.

4.6 Bitmask

In computer science, a mask or bitmask is data that is used for bitwise operations, particularly in a bit field. Using a mask, multiple bits in a byte, nibble, word, etc., can be set either on, off, or inverted from on to off (or vice versa) in a single bitwise operation.

Masking bit to 1

The bitwise-or (|) operation can be used to turn certain bits on, following the principle that n or 1 = 1 and n or 0 = n. Therefore, bitwise-or can be used with a 1 to ensure a bit is on. To leave a bit unchanged, bitwise-or is used with a 0.

Example: Masking the higher nibble (bits 4, 5, 6, 7) to 1, and the lower nibble (bits 0, 1, 2, 3) unchanged.

1001 0101 = 0x95
or 1111 0000 = 0xF0 (mask 1 value)
––-––––––––––
1111 0101 = 0xF5

1010 0011 = 0xA3
or 1111 0000 = 0xF0 (mask 1 value)
––-––––––––––
1111 0011 = 0xF3

0001 0001 = 0x11
or 1111 0000 = 0xF0 (mask 1 value)
–––-–––––––––
1111 0001 = 0xF1

Masking bit to 0

Toggling bit values

Querying the status of bits values

Questions

Write a console application for each question.

Calculate the Area of a Triangle: Input the width of the base and the height, then display the area on the screen.
Mileage to Kilometers: Input a value in miles and convert it to kilometers. (1 mile is equal to 1.60934 kilometers)

*a	Pointer to an address
&a	The address of a variable

Lesson 04: Operations and Operators

4.1 Expressions, Operands and Operators

Expressions

Operators

Operands

Practice Exercise 4.1

Practice Exercise 4.1 - Answer

4.2 Operators

AssignmentOperators

ArithmeticOperators

Compute Quotient and Remainder

LogicalOperators

Example of all the logical operators

BitwiseOperators

Example of all the bitwise operators

RelationalOperators

Chaining of Comparison Operators in C

Inc/DecrementOperators

Simple post and pre-increment operator

Evaluating post and pre-increment together

Post and Pre-increment Operators on Same Variable

ShiftOperators

Logical and Arithmetic Shifts

Circular Shifts (Rotate) in C

ConditionalOperators

PointerOperators

CommaOperators

Comma as an operator

Comma Operator in for-Loops

Comma Operator in Condition

Use Comma Operator to avoid a Block

Comma Operator in Place of a Semicolon

Comma as a Separator

More Examples for Comma

MiscellaneousOperators

Scope Resolution Operator (C++)

With Classes and Namespace

With Static Members

With Scoped Enumerations

Pointer-to-Member Operators (C++)

I/O Operators (C++)

4.3 Compound Assignment Operators

Example of compound operators

4.4 Order of Operations

Precedence of Function Calls

Carefully to Use Comma

Precedence of Logical and Increment Operators

4.5 Multiple Unsequenced Modifications to the Same Variable

[Warning] multiple unsequenced modifications

4.6 Bitmask

Masking bit to 1

Masking bit to 0

Toggling bit values

Querying the status of bits values

Questions

Assignment
Operators

Arithmetic
Operators

Logical
Operators

Bitwise
Operators

Relational
Operators

Inc/Decrement
Operators

Shift
Operators

Conditional
Operators

Pointer
Operators

Comma
Operators

Miscellaneous
Operators

Scope Resolution
Operator (C++)