XQA
Back to C Programming
2026-07-127 min read

C - Literals

Learn C - Literals step by step with clear examples and exercises.

Why This Matters

Understanding literals is crucial for writing efficient and error-free C code. They help you initialize variables with specific values, which is essential when working on real-world projects or preparing for coding interviews. Moreover, knowing the different types of literals can help you avoid common programming mistakes and write cleaner, more readable code.

Why Understanding Literals Matters

  1. Initializing Variables: Literals allow you to assign initial values to variables during program execution. This is essential for setting up data structures in your programs.
  2. Avoiding Common Mistakes: Familiarity with literals can help you avoid common programming errors, such as using the wrong data type for a given literal or mixing up integer and floating-point literals when initializing variables.
  3. Readability and Maintainability: Using appropriate literals can make your code more readable and easier to maintain, as it helps convey the intended meaning of the data being used.
  4. Preparing for Coding Interviews: Understanding literals is an important part of being well-versed in C programming, making you better prepared for coding interviews and real-world development tasks.

Prerequisites

Before diving into C literals, it's important to have a solid understanding of the following topics:

  1. Basic C syntax (variables, operators, expressions)
  2. Data types in C (int, char, float, etc.)
  3. Operators and their precedence
  4. Control structures (if-else, switch, loops)
  5. Understanding pointers and memory management in C
  6. File I/O operations in C

Core Concept

Types of Literals

In C, there are several types of literals, each representing a specific data type:

  1. Integer literals (e.g., 5, 100)
  2. Floating-point literals (e.g., 3.14, 0.007)
  3. Character literals (enclosed in single quotes, e.g., 'A', '!')
  4. String literals (enclosed in double quotes, e.g., "Hello, World!", "C Programming")
  5. Escape sequences (used within string literals to represent special characters, e.g., \n for newline, \\ for backslash)
  6. Imaginary literals (enclosed in parentheses and followed by the letter 'i', e.g., (3+4i))
  7. Compound literals (a structure created on-the-fly using a type name and curly braces, e.g., (struct myStruct){ .field1 = value1, .field2 = value2 })

Integer Literals

Integer literals can be in decimal, octal, or hexadecimal format. By default, a literal without a suffix is considered a decimal number. To specify an octal number, prefix the literal with zero (0), and for a hexadecimal number, use the prefix 0x or 0X.

int decimal = 42;
int octal = 052;
int hex = 0x2A;

Floating-Point Literals

Floating-point literals represent real numbers and can be in either decimal or scientific notation. To denote a floating-point literal, use a decimal point (.) for decimal notation or an E (uppercase) or e (lowercase) followed by the exponent for scientific notation.

float pi = 3.14159265;
float e = 2.71828e+001; // shorthand for 2.71828 * 10^1

Character Literals

Character literals represent individual characters and are enclosed in single quotes ('). ASCII values can be represented using character literals, as well.

char letter = 'A'; // ASCII value 65
char space = ' '; // ASCII value 32

String Literals

String literals represent sequences of characters and are enclosed in double quotes ("). Escape sequences can be used within string literals to represent special characters.

char* greeting = "Hello, World!\n"; // newline character (\n)

Imaginary Literals

Imaginary literals are used to represent complex numbers and consist of a real part followed by 'i'.

float complex z = 3 + 4 * I;

Compound Literals

Compound literals allow you to create structures on-the-fly using a type name and curly braces.

struct myStruct {
int field1;
char field2[256];
};

struct myStruct myVar = (struct myStruct){ .field1 = 42, .field2 = "Hello" };

Worked Example

Let's create a simple C program that demonstrates the use of various literals:

#include <stdio.h>

int main() {
int decimal = 42;
int octal = 052;
int hex = 0x2A;
float pi = 3.14159265;
float e = 2.71828e+001;
char letter = 'A';
char space = ' ';
char* greeting = "Hello, World!\n";
float complex z = 3 + 4 * I;

struct myStruct myVar = (struct myStruct){ .field1 = 42, .field2 = "Hello" };

printf("Integer literals:\n");
printf("Decimal: %d\n", decimal);
printf("Octal: %o\n", octal);
printf("Hexadecimal: %x\n", hex);

printf("\nFloating-point literals:\n");
printf("Pi: %.6f\n", pi);
printf("e: %.2f\n", e);
printf("Imaginary literal: %.2f + %.2fi\n", creal(z), cimag(z));

printf("\nCharacter literals:\n");
printf("Letter: %c\n", letter);
printf("Space: %c\n", space);

printf("\nString literals:\n");
printf("%s", greeting);

printf("\nCompound literal:\n");
printf("Field1: %d\n", myVar.field1);
printf("Field2: %s\n", myVar.field2);

return 0;
}

Compile and run the program to see the output:

gcc literals.c -o literals
./literals
Integer literals:
Decimal: 42
Octal: 52
Hexadecimal: 2a

Floating-point literals:
Pi: 3.141593
e: 2.72
Imaginary literal: 3.00 + 4.00i

Character literals:
Letter: A
Space:

String literals:
Hello, World!

Compound literal:
Field1: 42
Field2: Hello

Common Mistakes

  1. Forgetting to include the necessary header files (e.g., #include )
  2. Incorrectly using escape sequences within string literals (e.g., using single quotes instead of double quotes for strings)
  3. Mixing up integer and floating-point literals when initializing variables (e.g., assigning a floating-point literal to an integer variable)
  4. Failing to use the correct data type for a given literal (e.g., using a character literal for a string variable)
  5. Not properly formatting floating-point literals with decimal points or scientific notation
  6. Incorrectly defining compound literals (forgetting the struct keyword, missing curly braces, etc.)
  7. Using uninitialized variables in your code
  8. Forgetting to include complex.h header file when using complex numbers

Common Mistakes - Examples

  1. Incorrect use of escape sequences:
char* greeting = "Hello,\"World!"; // incorrect backslash
  1. Mixing up integer and floating-point literals:
int myInt = 3.14; // this will truncate the decimal part, resulting in 3
  1. Failing to use the correct data type for a given literal:
char* myString = 'A'; // incorrect data type for string

Practice Questions

  1. Write a C program that takes an integer and prints its octal, hexadecimal, binary, and decimal representations.
  2. Write a C program that calculates the area of a circle given its radius (use 3.14 as the value for pi).
  3. Write a C program that concatenates two strings using string literals and stores the result in another string variable.
  4. What is the output of the following code?
#include <stdio.h>

int main() {
char* greeting = "Hello, World!\n";
printf("%s", greeting);
return 0;
}
  1. Write a C program that defines and initializes a compound literal of a custom struct type, then prints the values of its fields.
  2. What is the difference between integer literals with and without suffixes (e.g., 42 vs 42U)?
  3. How can you represent a negative octal number in C?
  4. Write a C program that uses complex numbers to perform addition, subtraction, multiplication, and division operations on two complex numbers.

FAQ

  1. Why can't I use a decimal point in an integer literal?

In C, you cannot use a decimal point in an integer literal. If you need to represent a number with decimal points, you should use a floating-point literal instead.

  1. What happens if I mix up the data types for literals and variables?

Mixing up the data types for literals and variables can lead to unexpected behavior or compile errors. For example, assigning a floating-point literal to an integer variable will result in a truncation of the decimal part.

  1. Can I use escape sequences within character literals?

No, escape sequences are only valid within string literals (enclosed in double quotes).

  1. What is the difference between octal and hexadecimal literals?

Octal literals are base-8 numbers, while hexadecimal literals are base-16 numbers. Octal literals are prefixed with zero (0), and hexadecimal literals can be prefixed with 0x or 0X.

  1. Can I use a literal for an array initialization?

Yes, you can initialize arrays using literals by enclosing the list of values in curly braces. For example:

int myArray[] = {1, 2, 3}; // initializes an array with three integers
  1. What is the maximum number of significant digits in a floating-point literal?

The maximum number of significant digits in a floating-point literal depends on your C compiler's settings. However, it's generally recommended to use at least 6 or more significant digits for pi and e to ensure accuracy.

  1. What is the difference between complex literals and compound literals?

Complex literals are used to represent complex numbers in C, while compound literals allow you to create structures on-the-fly using a type name and curly braces. Complex literals consist of a real part followed by 'i', whereas compound literals do not have this structure but instead use the syntax (struct myStruct){ .field1 = value1, .field2 = value2 }.