Relational and Logical Operators, and Short Circuit

Zara wants to know whether a mark sits between 1 and 10. She writes 1 < mark < 10, the way the range is written on paper.

It compiles. The Playground says nothing at all. And it answers 1 for a mark of 42, for a mark of 900, and for every other number she tries.

The line is not broken. It is a perfectly ordinary expression that means something other than what she read.

A comparison is an int, worth 1 or 0

Module 2 lesson 4 said this once. This lesson depends on it, so here it is again with the six operators.

a <  b     is a less than b
a <= b     is a less than or equal to b
a >  b     is a greater than b
a >= b     is a greater than or equal to b
a == b     is a equal to b            two equals signs, always
a != b     is a not equal to b

#include <stdio.h>

int main(void)
{
    int mark = 42;

    printf("mark < 50   %d\n", mark < 50);
    printf("mark >= 40  %d\n", mark >= 40);
    printf("mark == 42  %d\n", mark == 42);
    printf("mark != 42  %d\n", mark != 42);
    return 0;
}

mark < 50   1
mark >= 40  1
mark == 42  1
mark != 42  0

Nothing here decides anything. Four questions were asked and four numbers came back.

Why 1 < mark < 10 compiles and lies

Relational operators group from the left. So C reads Zara's line as (1 < mark) < 10.

The bracketed part is a comparison, so its value is 1 or 0. Then C asks whether that 1 or 0 is less than 10. It always is.

#include <stdio.h>

int main(void)
{
    int mark = 900;

    printf("1 < mark        %d\n", 1 < mark);
    printf("that, < 10      %d\n", (1 < mark) < 10);
    printf("written chained %d\n", 1 < mark < 10);
    return 0;
}

1 < mark        1
that, < 10      1
written chained 1

The last two lines are the same expression written twice. The brackets only make the reading visible.

On the Playground's command line this is completely silent, because the check lives behind -Wall. A local gcc -Wall gives two warnings: comparisons like 'X<=Y<=Z' do not have their mathematical meaning and comparison of constant '10' with boolean expression is always true.

So a range needs two separate comparisons, joined by the operator in the next section.

&& and ||, and the truth table a program can print

&& is "and": 1 when both sides are true. || is "or": 1 when at least one side is true.

"True" here means "not zero", the Module 2 rule. The result is again a plain int worth 1 or 0.

#include <stdio.h>

int main(void)
{
    printf("p q   p&&q  p||q  !p\n");
    printf("0 0    %d     %d    %d\n", 0 && 0, 0 || 0, !0);
    printf("0 1    %d     %d    %d\n", 0 && 1, 0 || 1, !0);
    printf("1 0    %d     %d    %d\n", 1 && 0, 1 || 0, !1);
    printf("1 1    %d     %d    %d\n", 1 && 1, 1 || 1, !1);
    return 0;
}

p q   p&&q  p||q  !p
0 0    0     0    1
0 1    0     1    1
1 0    0     1    0
1 1    1     1    0

Zara's range check now writes itself: mark > 1 && mark < 10. Two questions, one joining word.

So the truth table is not something to memorise. It is four lines a program will print for you in ten seconds.

Short circuit: the right side may never run

C promises more than the table. It promises an order, and a chance to stop early.

For a && b, C evaluates a first. If a is 0 the answer is already 0, so b is never evaluated at all.

For a || b, C evaluates a first. If a is not zero the answer is already 1, so b is skipped.

You can watch it happen. printf returns the number of characters it printed, so a printf works as the right operand.

#include <stdio.h>

int main(void)
{
    int stock = 0;

    printf("start\n");
    int a = stock && printf("  the right side of && ran\n");
    int b = 1 || printf("  the right side of || ran\n");
    printf("a %d, b %d\n", a, b);
    return 0;
}

start
a 0, b 1

Neither message appeared. stock was 0, so the && stopped; the 1 was already true, so the || stopped.

So short circuit is how you guard a dangerous operation. Put the check on the left of &&, and the dangerous part runs only when the check passed.

! turns a number into an answer, and !! flattens one

! is "not". It gives 0 for any nonzero value, and 1 for zero.

Apply it twice and you get a value that is 1 or 0 and nothing else. !!7 is 1, !!0 is 0.

#include <stdio.h>

int main(void)
{
    int credits = 7;

    printf("credits      %d\n", credits);
    printf("!credits     %d\n", !credits);
    printf("!!credits    %d\n", !!credits);
    return 0;
}

credits      7
!credits     0
!!credits    1

The !! pair is a known idiom for "reduce this to exactly 1 or 0". It is not a special operator; it is ! used twice.

So "has credits" and "how many credits" become two different values, and only one of them is safe to compare against 1.

The ternary: one expression, two possible values

Every operator so far took two operands. This one takes three, and it is the only such operator in C.

condition ? value_if_true : value_if_false

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;
    scanf("%d %d", &a, &b);

    int larger = (a > b) ? a : b;

    printf("%d\n", larger);
    return 0;
}

91

That output is for the input 91 47. Module 5 will write the same thing with if over four lines; here it is one.

The track's advice is one line long. Use the ternary when both results are values of the same kind. Reach for if the moment a branch does work instead of producing a value.

#include <stdio.h>

int main(void)
{
    int age = 0;
    scanf("%d", &age);

    int adult = age >= 18;

    printf("%d\n", adult);
    return 0;
}

1

#include <stdio.h>

int main(void)
{
    int mark = 0;
    scanf("%d", &mark);

    int in_range = mark >= 1 && mark <= 10;

    printf("%d\n", in_range);
    return 0;
}

0

#include <stdio.h>

int main(void)
{
    int n = 0;
    int d = 0;
    scanf("%d %d", &n, &d);

    int big = (d != 0) && (n / d > 10);

    printf("%d\n", big);
    return 0;
}

0

int ok = 1 < mark < 10;
printf("%d\n", ok);

int matched = code = 5;
printf("matched %d\n", matched);

int big = (d != 0) & (n / d > 10);

printf("%d\n", 0.1 + 0.2 == 0.3);

#include <stdio.h>

int main(void)
{
    int x = 5;
    int y = 3;

    int t = (x == 5) + (y == 5);

    printf("%d\n", t);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int low = 0;
    int high = 0;
    int x = 0;
    scanf("%d %d %d", &low, &high, &x);

    /* Two comparisons and one &&. Both ends are included. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    int y = 0;
    scanf("%d", &y);

    /* Three remainders, two comparisons joined by &&, then one ||. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;
    scanf("%d %d", &a, &b);

    /* One ternary. Equal values make both branches correct. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    int p = 0;
    int q = 0;
    scanf("%d %d", &p, &q);

    /* Four printf lines, each one expression. No loop, no condition. */

    return 0;
}

Next you stop writing total = total + x and meet the shorter forms, one of which hides undefined behaviour.