Operators and Expressions

1Lab objectives

• Classifying operators by number of operands and by kind of operation
• Correctly using integer division and the modulo operator
• Telling logical operators apart from bitwise ones
• Applying precedence and associativity rules
• Understanding the difference between pre-increment and post-increment
• Controlling implicit and explicit type conversions

2Classifying operators

Operators can be grouped by number of operands:

Operators specific to C++, which do not exist in C: new, delete, the scope operator ::, the pointer-to-member .*, and its equivalent form ->*.

3Arithmetic operators

4Relational and logical operators

5Bitwise operators

6Bit playground

Toggle the bits directly on the binary representation and watch how the result forms, position by position. Try << and >> in particular, to see the equivalence with multiplying and dividing by powers of 2.

7Precedence and associativity

8Simulator: pre-increment vs. post-increment

The difference between ++i and i++ only shows up when the expression's result is used. Watch step by step what value the variable has and what value the expression has.

9Type conversions

When the operands have different types, the compiler automatically converts toward the "larger" type:

char / short  ->  int  ->  unsigned int  ->  long  ->  float  ->  double

10Source code

#include <stdio.h>

int main(void)
{
    int a = 7, b = 2;

    printf("a / b       = %d\n",   a / b);            // 3  - truncated
    printf("a %% b       = %d\n",   a % b);            // 1  - the remainder
    printf("(float)a/b  = %.3f\n", (float)a / b);     // 3.500 - correct
    printf("(float)(a/b)= %.3f\n", (float)(a / b));   // 3.000 - too late!

    // extracting the digits of a number
    int n = 4739, digit;
    printf("\nDigits of %d, from the right: ", n);
    while (n > 0) {
        digit = n % 10;      // the last digit
        n = n / 10;          // drop the last digit
        printf("%d ", digit);
    }
    printf("\n");
    return 0;
}

#include <stdio.h>

void printBinary(unsigned char v)
{
    for (int i = 7; i >= 0; i--)
        printf("%d", (v >> i) & 1);
    printf("\n");
}

int main(void)
{
    unsigned char reg = 0b00001010;   // 10 decimal

    printf("initial:        "); printBinary(reg);

    reg |=  (1 << 4);                 // SET bit 4
    printf("after set b4:   "); printBinary(reg);

    reg &= ~(1 << 1);                 // CLEAR bit 1
    printf("after clear b1: "); printBinary(reg);

    reg ^=  (1 << 0);                 // TOGGLE bit 0
    printf("after toggle b0:"); printBinary(reg);

    // TEST a bit
    if (reg & (1 << 4))
        printf("bit 4 is set\n");

    // fast multiplication and division
    int x = 12;
    printf("\n%d << 2 = %d  (that is %d * 4)\n", x, x << 2, x);
    printf("%d >> 2 = %d  (that is %d / 4)\n",   x, x >> 2, x);

    return 0;
}

#include <stdio.h>

int main(void)
{
    int a = 17, b = 42;

    int maximum = (a > b) ? a : b;          // equivalent to an if-else
    printf("The maximum is %d\n", maximum);

    // these can be chained, but readability drops quickly
    int n = 0;
    printf("The number is %s\n",
           (n > 0) ? "positive" : (n < 0) ? "negative" : "zero");

    // watch the precedence: the parentheses are NOT optional here
    printf("Sum: %d\n", a + ((a > b) ? a : b));

    return 0;
}

11Code workshop

Operators have precedence rules and side effects that are hard to remember from text alone. Run these and, especially, use Step by step to see exactly when each variable changes.

#include <stdio.h>

int main(void)
{
    int a = 5, b;

    b = a++;                  /* assigns first, then increments */
    printf("after b = a++ :  a = %d, b = %d\n", a, b);

    a = 5;
    b = ++a;                  /* increments first, then assigns */
    printf("after b = ++a :  a = %d, b = %d\n", a, b);

    int x = 10;
    printf("\nx / 3   = %d   (integer division)\n", x / 3);
    printf("x %% 3   = %d   (the remainder)\n", x % 3);
    printf("x / 3.0 = %.4f (one real operand -> real result)\n", x / 3.0);
    return 0;
}

#include <stdio.h>

/* Prints the 8 bits of a value, from bit 7 to bit 0 */
void printBits(unsigned char v)
{
    int i;
    for (i = 7; i >= 0; i--)
        printf("%d", (v >> i) & 1);
    printf("\n");
}

int main(void)
{
    unsigned char a = 0x2C;   /* 0010 1100 */

    printf("a       = "); printBits(a);
    printf("a | 0x03= "); printBits(a | 0x03);
    printf("a & 0x0F= "); printBits(a & 0x0F);

    /* Complete this: set bit 7 of a, then clear bit 2.
       Hints: to set, use   |= (1 << 7)
              to clear, use &= ~(1 << 2)   */

    printf("result  = "); printBits(a);
    return 0;
}

12Work tasks

• Compute the arithmetic mean of three integers, obtaining a correct real result.
• Write a program that extracts and prints the digits of a number, using % and /.
• Implement the function that prints a byte in binary and test it for the values 0, 1, 128, and 255.
• Apply the four classic bit operations (set, clear, toggle, test) to a variable.
• Verify experimentally that x & 1 == 0 gives a different result from (x & 1) == 0.
• Test the difference between ++i and i++ inside a printf.
• Compare a negative int with a positive unsigned and explain the result.
• Rewrite a simple if-else structure using the ternary operator.

13Extended application

14Review questions

15Resources

• This lab's handout (PDF)
• The course page - all materials