Literals in C: Integer, Float, Character & String

Literals in C: A Comprehensive Tutorial for Programmers

Literals are fixed values that appear directly in C source code. They represent constants of various types—integers, floating-point numbers, characters, and strings—that cannot be modified during program execution. Understanding literals is essential for writing correct expressions, avoiding type mismatches, and controlling how values are interpreted by the compiler.

This tutorial provides an in-depth exploration of C literals: their types, syntax, prefixes and suffixes, escape sequences, memory considerations, and common pitfalls.

---

Conceptual Introduction & Fundamentals

What are Literals?

A literal is a notation for representing a fixed value in source code. Unlike variables, literals do not have a name or a memory address that can be referenced; they are the values themselves. For example, in:

c

int x = 5;

5 is an integer literal, while x is a variable that stores the value 5.

Literals vs. Constants

The terms “literal” and “constant” are often used interchangeably, but they have distinct meanings:

Aspect	Literal	Constant
Definition	A fixed value written directly in code	A named value that cannot be modified
Example	42, 3.14, 'A', "hello"	const int x = 42; or #define MAX 100
Has address?	No (except string literals)	Yes (for const variables)
Lvalue/Rvalue	Rvalue (appears on right of assignment)	Lvalue (can appear on left, but assignment prohibited)
Memory	Stored in read-only data segment (strings) or encoded in instructions	Allocated on stack or data segment

Why Literals Matter

• Expressing values: Without literals, you couldn’t write numbers, characters, or strings.
• Type inference: The compiler infers a type from the literal’s form (e.g., 10 is int, 10.0 is double).
• Base control: Prefixes specify numeric base (decimal, octal, hexadecimal, binary).
• Type control: Suffixes specify the exact type (e.g., 10L for long, 10U for unsigned int).
• Readability: Proper literals make code self-documenting.

---

Syntax & Core Mechanics

C provides four main types of literals:

1. Integer literals
2. Floating-point literals
3. Character literals
4. String literals

Integer Literals

Integer literals represent whole numbers. They can be expressed in different bases using prefixes:

Base	Prefix	Valid Digits	Example
Decimal	none	0-9	56, 78, 0
Octal	0	0-7	045, 076
Hexadecimal	0x or 0X	0-9, a-f, A-F	0x23A, 0Xb4C
Binary (C23/GCC extension)	0b or 0B	0-1	0b101, 0B111

Suffixes specify the type of the integer literal:

Suffix	Type
none	int (or larger if value doesn’t fit)
u or U	unsigned int
l or L	long int
ul or UL	unsigned long int
ll or LL	long long int
ull or ULL	unsigned long long int

Example:

c

#include <stdio.h> int main(void) { int decimal = 12; /* decimal literal */ int octal = 012; /* octal literal: 1*8 + 2 = 10 decimal */ int hex = 0x10; /* hexadecimal: 16 decimal */ int binary = 0b1010; /* binary: 10 decimal (C23/GCC) */ long int big = 12345678901234LL; /* long long literal */ unsigned int u = 42U; /* unsigned literal */ unsigned long ul = 42UL; /* unsigned long literal */ printf("decimal = %d\n", decimal); printf("octal = %d\n", octal); printf("hex = %d\n", hex); printf("binary = %d\n", binary); printf("big = %lld\n", big); printf("u = %u\n", u); printf("ul = %lu\n", ul); return 0; }

Expected output:

text

decimal = 12 octal = 10 hex = 16 binary = 10 big = 12345678901234 u = 42 ul = 42

Important: A leading 0 indicates octal, not decimal. 012 is 10 decimal, not 12.

Floating-Point Literals

Floating-point literals represent real numbers. They can be written in:

• Decimal form: 12.34, 0.56, 100.0, .5, 5.
• Exponential form: 1.2e3 (= 1200.0), 10.5E-3 (= 0.0105)

Rules:

• In decimal form, at least the integer part or fractional part must be present.
• In exponential form, both the significand (mantissa) and exponent must be included.

Suffixes specify the type:

Suffix	Type
none	double
f or F	float
l or L	long double

Valid examples:

c

10.125 /* double */ 1.215e-10L /* long double */ 10.5E-3 /* double */ 0.5 /* double */ 5. /* double (5.0) */ .5 /* double (0.5) */ 3.14f /* float */ 2.71828F /* float */

Invalid examples:

c

123E /* missing exponent */ 1250f /* valid float actually! (correcting: 1250f is valid) */ 0.e879 /* missing fractional part? Actually 0.e879 is invalid because significand missing */

Example:

c

#include <stdio.h> int main(void) { float floatVal = 4.14f; /* float literal */ double doubleVal = 4.14; /* double literal */ long double ldVal = 4.14L; /* long double literal */ double expVal = 1.2e3; /* 1200.0 */ printf("floatVal = %.2f\n", floatVal); printf("doubleVal = %.2f\n", doubleVal); printf("ldVal = %.2Lf\n", ldVal); printf("expVal = %.2f\n", expVal); return 0; }

Expected output:

text

floatVal = 4.14 doubleVal = 4.14 ldVal = 4.14 expVal = 1200.00

Character Literals

Character literals represent a single character enclosed in single quotes. They have type int in C (unlike C++ where they are char), but they are typically stored in char variables.

Examples:

c

'A', 'a', '5', '#', ' ', '\n', '\t', '\\', '\''

Escape sequences represent special characters:

Escape	Meaning
\n	Newline
\t	Horizontal tab
\r	Carriage return
\b	Backspace
\f	Form feed
\v	Vertical tab
\\	Backslash
\'	Single quote
\"	Double quote
\?	Question mark
\0	Null character
\xhh	Hexadecimal character code (e.g., \x41 = ‘A’)
\ooo	Octal character code (e.g., \101 = ‘A’)

Example:

c

#include <stdio.h> int main(void) { char letter = 'A'; char digit = '5'; char newline = '\n'; char tab = '\t'; char backslash = '\\'; printf("letter = %c\n", letter); printf("digit = %c\n", digit); printf("newline = %c", newline); /* prints newline */ printf("tab = %c\n", tab); /* prints tab */ printf("backslash = %c\n", backslash); return 0; }

Expected output:

text

letter = A digit = 5 newline = tab = backslash = \

String Literals

String literals are sequences of characters enclosed in double quotes. They are automatically null-terminated (\0). String literals have type char[] in C (array of characters) and are stored in read-only memory.

Examples:

c

"Hello, World!" "C Programming" "" /* empty string */ "Line1\nLine2" /* string with escape sequence */

Example:

c

#include <stdio.h> int main(void) { const char str[] = "Welcome\nTo\nGeeks\tFor\tGeeks"; printf("%s\n", str); /* String literal directly in printf */ printf("Direct: %s\n", "Hello"); /* Adjacent string literals are concatenated */ const char *combined = "Hello " "World"; printf("Combined: %s\n", combined); return 0; }

Expected output:

text

Welcome To Geeks For Geeks Direct: Hello Combined: Hello World

Important: String literals are stored in read-only memory. Attempting to modify them is undefined behavior:

c

char *s = "hello"; /* s points to read-only memory */ s[0] = 'H'; /* Undefined behavior */

Use a character array if you need to modify the string:

c

char s[] = "hello"; /* modifiable array */ s[0] = 'H'; /* OK */

---

Full Practical Code Example with Explanation

This program demonstrates all types of literals in a realistic scenario: a temperature conversion utility that uses integer, floating-point, character, and string literals with proper formatting.

Program: Temperature Converter

c

/** * temperature_converter.c * Demonstrates various literal types: integer, float, char, string. * Converts Celsius to Fahrenheit and vice versa. */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #define MAX_LINE_LEN 100 /* Function prototypes */ int readDouble(const char *prompt, double *outValue); int readInteger(const char *prompt, int *outValue); int main(void) { /* Integer literals used throughout */ const int freezingC = 0; /* decimal */ const int boilingC = 100; /* decimal */ const int hexValue = 0x20; /* hexadecimal literal (32) */ const int octalValue = 040; /* octal literal (32) */ /* Floating-point literals */ const double absoluteZeroF = -459.67; /* double literal */ const float conversionFactor = 1.8f; /* float literal */ const long double precisePi = 3.14159265358979323846L; /* long double */ /* Character literals */ const char degreeSymbol = '\xF8'; /* hex escape for degree symbol (not portable) */ const char newline = '\n'; const char tab = '\t'; /* String literals */ const char welcomeMessage[] = "Temperature Converter\n"; const char menuText[] = "1. Celsius to Fahrenheit\n" "2. Fahrenheit to Celsius\n" "3. Exit\n" "Enter choice: "; int choice; double temperature, converted; /* Print welcome using string literal */ printf("%s", welcomeMessage); while (1) { printf("%s", menuText); fflush(stdout); if (readInteger("", &choice) != 0) { fprintf(stderr, "Failed to read choice.\n"); return EXIT_FAILURE; } switch (choice) { case 1: if (readDouble("Enter temperature in Celsius: ", &temperature) != 0) { fprintf(stderr, "Invalid temperature.\n"); break; } converted = (temperature * conversionFactor) + 32.0; /* F = C*1.8+32 */ printf("%.2f Celsius = %.2f Fahrenheit\n", temperature, converted); break; case 2: if (readDouble("Enter temperature in Fahrenheit: ", &temperature) != 0) { fprintf(stderr, "Invalid temperature.\n"); break; } if (temperature < absoluteZeroF) { printf("Temperature below absolute zero!%c", newline); break; } converted = (temperature - 32.0) / conversionFactor; /* C = (F-32)/1.8 */ printf("%.2f Fahrenheit = %.2f Celsius\n", temperature, converted); break; case 3: printf("Exiting. Goodbye!%c", newline); return EXIT_SUCCESS; default: printf("Invalid choice. Please try again.%c", newline); break; } } return EXIT_SUCCESS; } /* Reads an integer safely using fgets and strtol */ int readInteger(const char *prompt, int *outValue) { char buffer[MAX_LINE_LEN]; char *endPtr; long val; while (1) { if (prompt[0] != '\0') { printf("%s", prompt); fflush(stdout); } if (fgets(buffer, sizeof(buffer), stdin) == NULL) { return -1; } if (strchr(buffer, '\n') == NULL && !feof(stdin)) { int ch; while ((ch = getchar()) != '\n' && ch != EOF); printf("Input too long, please try again.\n"); continue; } errno = 0; val = strtol(buffer, &endPtr, 10); if (endPtr == buffer || (*endPtr != '\n' && *endPtr != '\0')) { printf("Invalid integer. Please try again.\n"); continue; } if (errno == ERANGE || val < -2147483647 - 1 || val > 2147483647) { printf("Number out of range. Please try again.\n"); continue; } *outValue = (int)val; return 0; } } /* Reads a double safely using fgets and strtod */ int readDouble(const char *prompt, double *outValue) { char buffer[MAX_LINE_LEN]; char *endPtr; double val; while (1) { if (prompt[0] != '\0') { printf("%s", prompt); fflush(stdout); } if (fgets(buffer, sizeof(buffer), stdin) == NULL) { return -1; } if (strchr(buffer, '\n') == NULL && !feof(stdin)) { int ch; while ((ch = getchar()) != '\n' && ch != EOF); printf("Input too long, please try again.\n"); continue; } errno = 0; val = strtod(buffer, &endPtr); if (endPtr == buffer || (*endPtr != '\n' && *endPtr != '\0')) { printf("Invalid number. Please try again.\n"); continue; } if (errno == ERANGE) { printf("Number out of range. Please try again.\n"); continue; } *outValue = val; return 0; } }

Explanation of Literal Usage

• Integer literals: 0, 100, 0x20 (hex), 040 (octal) demonstrate different bases.
• Floating-point literals: -459.67 (double), 1.8f (float suffix), 3.14159265358979323846L (long double).
• Character literals: '\xF8' (hex escape), '\n' (newline), '\t' (tab).
• String literals: "Temperature Converter\n", menu text with adjacent string concatenation.
• Format specifiers in printf match the literal types.

Expected Output

Sample interaction:

text

Temperature Converter 1. Celsius to Fahrenheit 2. Fahrenheit to Celsius 3. Exit Enter choice: 1 Enter temperature in Celsius: 25 25.00 Celsius = 77.00 Fahrenheit 1. Celsius to Fahrenheit 2. Fahrenheit to Celsius 3. Exit Enter choice: 2 Enter temperature in Fahrenheit: 212 212.00 Fahrenheit = 100.00 Celsius 1. Celsius to Fahrenheit 2. Fahrenheit to Celsius 3. Exit Enter choice: 3 Exiting. Goodbye!

---

Common Pitfalls, Edge Cases & Memory Considerations

1. Leading Zero Means Octal

A leading 0 before an integer literal makes it octal (base 8), not decimal. This is a common source of bugs.

c

int x = 010; /* Octal: 8 decimal, not 10! */ printf("%d\n", x); /* prints 8 */

Solution: Never write leading zeros for decimal numbers. If you need octal, use the 0 prefix intentionally.

2. Integer Literal Type

By default, an integer literal has type int. If the value doesn’t fit in int, the compiler tries long, then long long. Suffixes override this.

c

printf("%zu\n", sizeof(10)); /* int: 4 bytes */ printf("%zu\n", sizeof(10L)); /* long: 8 bytes */ printf("%zu\n", sizeof(10LL)); /* long long: 8 bytes */ printf("%zu\n", sizeof(10U)); /* unsigned int: 4 bytes */

Using the wrong suffix can cause type mismatches in expressions.

3. Floating-Point Literal Type

Floating-point literals without a suffix are double by default. Assigning them to float variables may cause precision loss or warnings.

c

float f = 3.14; /* 3.14 is double, converted to float (may warn) */ float f2 = 3.14f; /* Correct: float literal */

4. Character Literals are int in C

In C, character literals have type int, not char. This can cause surprises with sizeof.

c

printf("%zu\n", sizeof('A')); /* Prints 4 (int), not 1 (char) */

Solution: Be aware of this when using character literals in expressions.

5. String Literals are Read-Only

String literals are stored in read-only memory. Modifying them causes undefined behavior (often a segmentation fault).

c

char *s = "hello"; s[0] = 'H'; /* Undefined behavior */

Solution: Use const char * for string literals, or declare a modifiable array:

c

const char *s = "hello"; /* safe: read-only */ char arr[] = "hello"; /* modifiable */ arr[0] = 'H'; /* OK */

6. Adjacent String Literal Concatenation

Adjacent string literals are concatenated at compile time. This is useful for splitting long strings but can cause unintended results if commas are forgotten.

c

const char *s = "Hello " "World"; /* "Hello World" */ const char *t = "Hello ", "World"; /* Error: expected ';' */

7. Escape Sequence Errors

Invalid escape sequences produce warnings or unexpected behavior.

c

char c = '\q'; /* Warning: unknown escape sequence */

Solution: Use only valid escape sequences: \n, \t, \\, \', \", \0, \xhh, \ooo.

8. Hexadecimal and Octal Character Codes

Using \xhh or \ooo can be confusing because the escape continues until a non-hex/octal digit is found.

c

char c = '\x41'; /* 'A' */ char d = '\101'; /* 'A' */ char e = '\x41B'; /* This is 0x41B, not 'A' followed by 'B' */

Solution: Use separate literals or break the escape: "\x41" "B".

9. Memory Considerations

• Integer literals: No runtime memory; they are encoded in instructions.
• Floating-point literals: Stored in read-only data segment.
• Character literals: Encoded in instructions or data.
• String literals: Stored in read-only data segment (.rodata). Each distinct string literal occupies memory for its length plus null terminator.

Large numbers of string literals can increase binary size. Use const char * to reference them without duplication.

10. Binary Literals (Non-Standard)

Binary literals (0b1010) are not part of standard C99/C11. They are a GCC extension and part of C23. Using them reduces portability.

Solution: Use hexadecimal or decimal literals for maximum portability, or enable C23 features if supported.

---

Summary & Best Practices

Literals are the building blocks of C expressions. Understanding their types, bases, and memory behavior is essential for writing correct and portable code.

Key Takeaways

• Integer literals can be decimal, octal (0 prefix), hexadecimal (0x prefix), or binary (0b prefix, C23/GCC).
• Integer suffixes specify type: U, L, LL, and combinations.
• Floating-point literals are double by default; use f for float, L for long double.
• Character literals have type int in C; escape sequences represent special characters.
• String literals are null-terminated arrays stored in read-only memory.
• Adjacent string literals are concatenated.

Best Practices

1. Use suffixes to make types explicit (e.g., 10U, 3.14f, 100LL).
2. Avoid leading zeros unless you intend octal.
3. Use const char * for string literals to prevent modification attempts.
4. Use character arrays if you need to modify strings.
5. Match format specifiers to literal types in printf/scanf.
6. Be careful with escape sequences; use only valid ones.
7. Prefer decimal or hexadecimal over binary for portability.
8. Use sizeof to check literal sizes when writing portable code.
9. Document the intended base when using non-decimal literals.
10. Compile with warnings (-Wall -Wextra) to catch type mismatches and invalid literals.

By mastering literals, you’ll write clearer, more efficient, and more portable C code.