Data types, operators and expressions

Why it exists

Mathematics has integers of any size. A C int has exactly 32 bits (on the machines GATE assumes), so there are only $2^{32}$ values. Unsigned arithmetic quietly wraps around at the ends, and signed arithmetic that leaves the range is undefined. On top of that, every operation in C happens at a particular type, and C silently converts operands to a common type before computing. Most "what does this program print" questions about expressions are really testing these two facts: the width of the values, and the conversions the compiler inserts.

If you can answer three questions about any expression, you can evaluate it: what is the type of each operand after conversion, what does the operator do at that type, and what happens when the result is stored into a variable of another type.

Prerequisites

None. This is a starting point.

You should be comfortable writing numbers in binary and in two's complement, and you should know what an expression and a statement are. Nothing else from C is assumed.

Precise definitions

Integer types. char, short, int, long, long long, each signed or unsigned (plain char is a separate type from both signed char and unsigned char). The standard fixes only minimum ranges and nests them: the range of each type is contained in the range of the next one. In practice that gives:

• sizeof(char) is 1 by definition. A short and an int have at least 16 bits, a long at least 32, a long long at least 64.
• $\text{sizeof(short)} \le \text{sizeof(int)} \le \text{sizeof(long)} \le \text{sizeof(long long)}$.
• The usual GATE assumption is char 1 byte, short 2, int 4, float 4, double 8. A question that depends on long or pointer size states it (it is 8 bytes on 64-bit Linux and 4 on 32-bit systems).
• Plain char may be signed or unsigned: this is implementation-defined (signed on x86, unsigned on many ARM compilers). Write signed char or unsigned char when it matters.

Value ranges. An $n$-bit unsigned type holds $0$ to $2^n - 1$. An $n$-bit signed type in two's complement holds $-2^{n-1}$ to $2^{n-1} - 1$. For 8 bits that is 0 to 255 and -128 to 127. For 32 bits, INT_MAX is $2^{31}-1 = 2147483647$.

Integer promotion. An operand whose type ranks no higher than int (char, short, _Bool, bit-fields, enumerations, signed or unsigned) is converted to int if int can represent all its values, and otherwise to unsigned int. With a 32-bit int that means every char and short becomes int. Promotion is applied to the operands of arithmetic, bitwise and shift operators and of unary +, - and ~, before the operator runs. That is why c + 1 for a char c is an int.

Usual arithmetic conversions (C11 6.3.1.8). For a binary arithmetic operator, after promotion the two operands are brought to a common type. The decision uses the conversion rank of the integer types: char < short < int < long < long long, and a signed type and its unsigned partner have the same rank. In order:

1. If either operand is long double, the other becomes long double. Otherwise if either is double, the other becomes double. Otherwise if either is float, the other becomes float.
2. Otherwise both are integers. If they already have the same type, nothing changes.
3. If both are signed, or both are unsigned, the one with the lower rank is converted to the type of the higher rank.
4. If the unsigned operand has rank greater than or equal to the signed operand's rank, the signed operand is converted to the unsigned type. This is the common GATE case: int against unsigned int gives unsigned int, and int against unsigned long gives unsigned long.
5. Otherwise (the signed type has the higher rank), if the signed type can represent every value of the unsigned type, the unsigned operand is converted to the signed type (for example long against unsigned int on a 64-bit machine).
6. Otherwise both operands are converted to the unsigned type that corresponds to the signed type.

Overflow and conversion.

• Unsigned arithmetic wraps: the result is taken modulo $2^n$. This is fully defined.
• Signed arithmetic overflow (for example INT_MAX + 1) is undefined behaviour.
• Converting an out-of-range value to a signed type is implementation-defined (the standard also allows the implementation to raise a signal); gcc keeps the low bits, a two's complement wrap.
• Converting a negative value to an unsigned type is defined: the result is the value plus $2^n$ ("keep the bits").

Division and remainder. Integer division truncates toward zero. The remainder takes the sign of the dividend, and $(a/b)\cdot b + a\%b = a$ holds whenever $b \ne 0$ and $a/b$ is representable. Division by zero is undefined, and so is INT_MIN / -1 (the quotient does not fit).

Shifts. x << n and x >> n are undefined if $n$ is negative or at least the width of the promoted left operand. For a signed x, x << n is defined only if x is non-negative and $x \cdot 2^n$ fits in the result type; otherwise it is undefined (so shifting a negative value left, or shifting into the sign bit, is undefined). For an unsigned x, the result is taken modulo $2^{\text{width}}$. Right-shifting a negative signed value is implementation-defined (gcc shifts arithmetically, copying the sign bit); right-shifting an unsigned value always fills with zeros.

Logical operators &&, || and ! yield int 0 or 1, and treat any non-zero operand as true. && and || evaluate left to right and short-circuit: the right operand is evaluated only if needed. There is a sequence point after the left operand.

Operator precedence (high to low, all binary levels group left to right):

1. postfix () [] . -> ++ --
2. prefix ++ -- + - ! ~ * & sizeof and casts (right to left)
3. * / %
4. + -
5. << >>
6. < <= > >=
7. == !=
8. &
9. ^
10. |
11. &&
12. ||
13. ?: then = += ... (right to left) then ,

How it works

Step through the animation. Each step is one real evaluation: the numbers, the C type the compiler gave each sub-expression (read from the compiler with _Generic), and the actual bit pattern at that width. The sign bit is ringed. Bits that differ from the row above are shown in amber.

unsigned char c = 255;
c = c + 1;

Three habits make these questions routine:

1. Write the type next to every operand. c + 1 with a char c is int + int. -1 < 1u is unsigned + unsigned after conversion.
2. Compute at that width. For unsigned int use arithmetic modulo $2^{32}$. For int, a result outside $-2^{31}$ to $2^{31}-1$ is undefined, so a well-posed question will not ask for it.
3. Convert on assignment. Storing into a narrower unsigned type keeps the value modulo $2^n$. Storing into a narrower signed type is implementation-defined (gcc keeps the low bits). Storing a double into an int truncates toward zero, and is undefined if the truncated value does not fit.

Worked examples

#include <stdio.h>
 
int main(void) {
    signed char s = (signed char)200;
    unsigned char u = (unsigned char)-1;
    printf("%d %d\n", s, u);
    return 0;
}

-56 255

#include <stdio.h>
 
int main(void) {
    unsigned char a = 200, b = 100;
    printf("%d\n", a + b);
    printf("%d\n", (unsigned char)(a + b));
    return 0;
}

300
44

#include <stdio.h>
 
int main(void) {
    int x = -5;
    unsigned int y = 3;
    printf("%d\n", x < y);
    printf("%u\n", x + y);
    printf("%d\n", (int)(x + y));
    return 0;
}

0
4294967294
-2

#include <stdio.h>
 
int main(void) {
    int x = 4;
    printf("%d %d\n", x & 1 == 0, (x & 1) == 0);
    printf("%d %d\n", 1 + 2 << 3, 1 << 2 + 3);
    return 0;
}

0 1
24 32

#include <stdio.h>
 
int main(void) {
    printf("%d %d %d\n", 7 / 2, -7 / 2, -7 % 3);
    double r1 = 7 / 2;
    double r2 = 7 / 2.0;
    printf("%.1f %.1f\n", r1, r2);
    return 0;
}

3 -3 -1
3.0 3.5

#include <stdio.h>
 
int main(void) {
    int i = 0, j = 5;
    if (i++ && j++) {
    }
    printf("%d %d\n", i, j);
 
    int k = 1, m = 5;
    if (k++ || m++) {
    }
    printf("%d %d\n", k, m);
    return 0;
}

1 5
2 5

Cheat box

Traps and GATE patterns

Other things examiners twist:

• char c = 'A' + 2; stores the character code 67, which prints as C with %c and as 67 with %d.
• A negative number printed with %u shows its unsigned reinterpretation; an unsigned value printed with %d can appear negative. A mismatched format is itself undefined behaviour in the standard, but GATE usually just wants the reinterpretation.
• sizeof is an operator, not a function, and is evaluated at compile time (its operand is not executed, unless it is a variable-length array).

Connections

The bit-level view of numbers is covered in signed number representation and IEEE 754. The bitwise operators here are the software version of the Boolean algebra of logic gates, and the "anything can happen" rules continue on the page about undefined behaviour.

PYQs

What is printed by the following ANSI C program?
#include<stdio.h>
int main (int argc, char *argv[])
{
char a= 'P';
char b= ' x ';
char c= (a & b)+' *';
char d= (b) -   ' -';
char e= (a∧b) + ' + ';
printf("%c %c %c \n", c, d, e);
return 0;
}
ASCII encoding for relevant characters is given
below.

A
B
C
.....
Z
65
66
67
.....
90

*
+
-
42
43
45

Consider the following C program

#include<stdio.h>
int main ( ) {
int m= 10
int n, nl;
n=++m;

nl=m++;
n--;
--n1;
n-= nl;
printf("%d", n);
return 0;
}
The output of the program is ____.

Suppose n and p are unsigned int variables in a C
program. We wish to set p to nC3. If n is large, which
one of the following statements is most likely to set p
correctly?

Which combination of the integer variables x, y,and z
makes the variable a get the value 4 in the following
expression?
a= (x> y)? ((x> z)? x: z): ((y> z)? y: z)

Consider the following C program:
#include <stdio.h>
 int main ()  {
     float sum = 0.0, j = 1.0, i = 2.0;
     while (i/j > 0.0625) {
           j = j + j;
          sum = sum + i/j;
          printf ("%f \n", sum);
       }
       return 0;
}

The number of times the variable sum will be printed,
when the above program is executed, is ______.

Consider the following C program.

#include <stdio.h>
#include <string.h>
void printlength (char*s, char*t)
{
   unsigned int c = 0;
  int len = ((strlen(s) - strlen(t)) > c)?strlen(s):strlen(t);
  printf("%d\n", len);
}
void main ()  {
     char*x = "abc";
     char*y = "defgh";
     printlength(x,y);
}

Recall that strlen is defined in string.h as returning a
value of type size_t, which is an unsigned int. The
output of the program is _________.

    int pp(int a, int b) {
        int arr[20];
        int i, tot = 1, ex, len;
        ex= a;
        len = tob(b, arr);
    for (i=0; i < len; i++ ) {
            if (arr[i] == 1
                tot = tot * ex;
              ex= ex * ex;
        }
    } return (tot);

Consider the following C program.

void f(int, short);
void main ()
{
int i = 100;
short s = 12;
short *p = &s;
 __________ ;         // call to f()
}

Which one of the following expressions, when placed
in the blank above, will NOT result in a type checking
error?

Consider the function shown below :
int func(int num) {
int count = 0;
    while (num) {
          count ++;
        num>> = 1;

}
return (count);
}
The value returned by func (435) is _____.

Self-check

#include <stdio.h>
 
int main(void) {
    printf("%d\n", (unsigned char)(255 + 1));
    return 0;
}

0

#include <stdio.h>
 
int main(void) {
    int a = -1;
    unsigned int b = 0;
    printf("%d\n", a > b);
    return 0;
}

1

#include <stdio.h>
 
int main(void) {
    printf("%d\n", 5 & 6 == 6);
    return 0;
}

1

#include <stdio.h>
 
int main(void) {
    char c = 'A' + 2;
    printf("%d %c\n", c, c);
    return 0;
}

67 C

Revision card

References