What You Will Learn

Prerequisites

You should know what a C program looks like (a main function and printf) and have gcc installed. On Ubuntu or Debian run sudo apt install build-essential. A basic idea of binary numbers helps, but we rebuild it here from scratch.

Constants in C: The Big Picture

A constant is a value written directly in the source whose meaning is fixed before the program runs. The C standard recognises four families of such tokens: integer constants, floating constants, character constants and enumeration constants. String literals sit beside them as a fifth kind of fixed value. In this chapter we cover them one by one, and the diagram shows where integer constants fit.

Numeric constants split into integer and real; integer constants come in three bases. Character, string and real constants get their own lectures.

Rules for Writing Integer Constants in C

An integer constant is a whole number with no decimal point and no exponent. The compiler’s scanner (the lexer) accepts it only if all of these hold:

1. It has at least one digit. A bare 0x with nothing after it is an error.
2. It contains no spaces, commas or underscores. 98 5 is two tokens and 8,354 is the number 8, the comma operator, then 354.
3. It uses only digits that belong to its base (table below).
4. It has no sign of its own. In -25 the minus is the unary negation operator applied to the constant 25.

Decimal Integer Constants

These are the everyday numbers: 0, 123, 23759. A decimal constant never starts with 0 unless it is the number zero itself, because a leading zero is the signal that you want octal. That single rule is the source of the most famous beginner bug in C, which we will trigger on purpose in Example 3.

Octal Integer Constants

An octal constant starts with 0 and uses only the digits 0 to 7, so 077 is 7×8 + 7 = 63. Octal survives in modern code for one very practical reason: Unix permissions. Each permission group (owner, group, others) is three bits, and three bits map exactly to one octal digit. That is why you write chmod 0644 or pass 0644 as the mode argument of open() on Linux.

Writing a digit 8 or 9 after a leading zero is rejected outright. Compile int a = 09; and GCC says:

error: invalid digit "9" in octal constant

Hexadecimal Integer Constants

A hexadecimal constant starts with 0x or 0X followed by digits 0-9 and letters a-f in either case, so 0xFFF, 0xac and 0XA15B are all fine. Hardware people love hex because one hex digit is exactly four bits, so a 32-bit register is eight digits and you can read individual nibbles by eye. Datasheets, linker scripts and kernel headers are written in hex for this reason.

Hex reads the bits four at a time and octal reads them three at a time, which is why both are shorthand for binary.

Integer Constant Types and Suffixes

Writing 7 does not just give you the value seven. The compiler also attaches a type. Without a suffix, it walks down a list of candidate types and picks the first one that can hold the value. Suffixes let you steer that choice yourself.

Notice the asymmetry. A decimal constant never silently becomes unsigned, but an octal or hex constant can. That is the trick behind the interview favourite in Example 2. Suffix letters are case-insensitive and the order UL or LU does not matter, but write the L in upper case: 10l looks far too much like 101.

The consequence is portability: the literal 40000 is an int on a 32-bit chip but a long on a 16-bit one. All examples below were run on 64-bit Linux (LP64) with GCC 13.

Hands-On: Four Programs on Integer Constants in C

Example 1: Same value, three bases

Save this as int_bases.c:

#include <stdio.h>

int main(void)
{
    int dec = 100;
    int oct = 0144;
    int hex = 0x64;

    printf("dec=%d oct=%d hex=%d\n", dec, oct, hex);
    printf("100 printed in octal : %o\n", dec);
    printf("100 printed in hex   : %x\n", dec);
    printf("all three equal? %s\n", (dec == oct && oct == hex) ? "yes" : "no");
    return 0;
}

Build and run:

$ gcc -Wall -Wextra -std=c11 -o int_bases int_bases.c
$ ./int_bases

dec=100 oct=100 hex=100
100 printed in octal : 144
100 printed in hex   : 64
all three equal? yes

• %d prints decimal, %o prints octal (without the leading zero) and %x prints lower-case hex (without 0x).
• The comparison is true because the base only changes how you write the number, never the stored bits.
• Use %#o and %#x if you want the prefixes printed too.

Example 2: Which type did I get?

Save this as int_types.c:

#include <stdio.h>

int main(void)
{
    printf("sizeof(7)          = %zu\n", sizeof(7));
    printf("sizeof(7U)         = %zu\n", sizeof(7U));
    printf("sizeof(7L)         = %zu\n", sizeof(7L));
    printf("sizeof(7UL)        = %zu\n", sizeof(7UL));
    printf("sizeof(7LL)        = %zu\n", sizeof(7LL));
    printf("sizeof(2147483648) = %zu\n", sizeof(2147483648));
    printf("sizeof(0x80000000) = %zu\n", sizeof(0x80000000));
    return 0;
}

Build and run:

$ gcc -Wall -Wextra -std=c11 -o int_types int_types.c
$ ./int_types

sizeof(7)          = 4
sizeof(7U)         = 4
sizeof(7L)         = 8
sizeof(7UL)        = 8
sizeof(7LL)        = 8
sizeof(2147483648) = 8
sizeof(0x80000000) = 4

Read the last two lines slowly. 2147483648 is one more than the largest 32-bit int. As a decimal constant it may not become unsigned, so it skips to long (8 bytes). 0x80000000 is the same value, but as a hex constant it is allowed to try unsigned int first, and it fits there, so you get 4 bytes. Same number, two different types. This is exactly why mixed signed/unsigned expressions with hex literals behave differently from decimal ones.

Example 3: The leading-zero trap

Save this as octal_trap.c:

#include <stdio.h>

int main(void)
{
    int slot_a = 007;
    int slot_b = 010;
    int slot_c = 012;

    printf("007 -> %d\n", slot_a);
    printf("010 -> %d\n", slot_b);
    printf("012 -> %d\n", slot_c);
    printf("sum of the three = %d\n", slot_a + slot_b + slot_c);
    return 0;
}

Build and run:

$ gcc -Wall -Wextra -std=c11 -o octal_trap octal_trap.c
$ ./octal_trap

007 -> 7
010 -> 8
012 -> 10
sum of the three = 25

Anyone padding numbers for neat alignment (007, 010, 012) accidentally writes octal. 010 is 8 and 012 is 10, so the sum is 7 + 8 + 10 = 25 and not what a column of “neat” decimals would suggest. Worse, 09 or 08 will not even compile, so the bug only hides when every digit happens to be below 8. Never pad decimal numbers with leading zeros in C source.

Example 4: Hex flags for LEDs

Save this as led_flags.c:

#include <stdio.h>

int main(void)
{
    unsigned int leds = 0x00;

    leds |= 0x01;               /* red on   */
    leds |= 0x04;               /* blue on  */
    printf("after set       : 0x%02X\n", leds);

    leds &= ~0x01u;             /* red off  */
    printf("after clear red : 0x%02X\n", leds);

    printf("green on? %s\n", (leds & 0x02) ? "yes" : "no");
    printf("blue  on? %s\n", (leds & 0x04) ? "yes" : "no");
    return 0;
}

Build and run:

$ gcc -Wall -Wextra -std=c11 -o led_flags led_flags.c
$ ./led_flags

after set       : 0x05
after clear red : 0x04
green on? no
blue  on? yes

• |= sets a bit, &= ~mask clears it, and & tests it.
• Each constant has exactly one bit set (0x01, 0x02, 0x04), so flags never interfere with each other.
• The u in ~0x01u keeps the whole expression unsigned, avoiding sign surprises when masks get wider.
• On a real board the variable would be a memory-mapped register, and the same operations would switch real LEDs.

Common Mistakes and Troubleshooting

Best Practices, Performance and Security

• Hex for bit patterns, decimal for counts, octal only for Unix modes. Matching the base to the meaning makes code self-explanatory.
• Name your constants. 0x40021000 in ten places is a bug waiting to happen; Lecture 4 shows how symbolic constants fix that.
• Suffix on purpose. Use U on masks and UL or ULL when the value must be wide.
• Performance: expressions made only of constants, like 60 * 60 * 24, are folded by the compiler at build time and cost nothing at run time, so favour readable arithmetic over pre-computed magic numbers.
• Security: signed integer overflow is undefined behaviour, and size calculations such as count * 4 that wrap around are a classic source of buffer overflows. Do size maths in size_t with an unsigned or wide constant.

Quiz: Integer Constants in C

Try each question on paper first. Click a question to reveal the answer.

Interview Questions: Integer Constants in C

These come up in embedded and product-company interviews. Answer out loud, then click.

Summary and Key Takeaways

• An integer constant is a whole number with at least one digit, no spaces or commas, and no sign of its own.
• Decimal never starts with 0, octal starts with 0 and uses 0-7, hexadecimal starts with 0x and uses 0-9 and a-f.
• Without a suffix the compiler picks the first fitting type from a list, and octal or hex lists include unsigned types.
• Use U, L, UL, LL and ULL deliberately; write the L in upper case.
• Hex is for bit masks, octal is for Unix permissions, decimal is for everything else.
• Sizes of int and long depend on the platform, so never assume them in portable code.

Conclusion

Integer constants in C are small, but they sit at the exact point where text becomes machine values, so every misunderstanding here turns into a hard-to-find bug later: a wrong permission, a masked-off flag, an overflowing timer. You now know how to read any literal, which base it uses, and which type the compiler gives it, and you have verified the surprising cases yourself by running code.

Next we move from whole numbers to real numbers, where exponent notation and precision introduce a different set of traps. Keep practising by changing the examples: add a 0b constant, try %lu with 7UL, or write your own mask table for a GPIO port.

Frequently Asked Questions