C vs C++ Character Literals: Why sizeof('a') Differs

The difference is not about the size of the char type. It is about the type of the character literal 'a'. In C, an ordinary character literal has type int; in C++, it has type char. Therefore, sizeof('a') is usually sizeof(int) in C and exactly sizeof(char) in C++.

A character literal is a value written between single quotes, such as 'a', '?', or '\n'.

It is important not to confuse these two expressions:

char letter = 'a';  // `char` is a type used for the variable
sizeof('a');       // `'a'` is a character literal with language-specific type

In C, an ordinary character literal such as 'a' has type int.

/* C */
sizeof('a') == sizeof(int)

In C++, an ordinary character literal such as 'a' has type char.

// C++
sizeof('a') == sizeof(char)

That is why the same source text can produce different results when compiled as C and as C++.

Think of 'a' as a label on a package, not as the package itself.

• In C, the label 'a' is placed in an int-sized package.
• In C++, the label 'a' is placed in a char-sized package.

The written text is identical, but each language assigns it a different type. sizeof measures the package type chosen by the language, not the visual number of characters between the quotes.

Use sizeof to inspect the size of a type or expression.

sizeof(char)   /* size of the char type */
sizeof(int)    /* size of the int type */
sizeof('a')    /* size of the type of the literal 'a' */

C example

#include <stdio.h>

int main(void)
{
    printf("char: %zu\n", sizeof(char));
    printf("int:  %zu\n", sizeof(int));
    printf("'a':  %zu\n", sizeof('a'));
}

In C, 'a' has type int, so the final two sizes match:

char: 1
int:  4
'a':  4

C++ example

Trace this C program:

#include <stdio.h>

int main(void)
{
    int code = 'A';
    printf("%d\n", code);
    printf("%zu\n", sizeof('A'));
}

1. The compiler reads 'A'.
2. In C, the literal 'A' has type int.
3. Its numeric value corresponds to the execution character set's code for A (commonly 65, but do not assume ASCII in fully portable C).
4. The assignment to int code needs no conversion because the literal is already an int.
5. sizeof('A') measures the literal's type, so it produces sizeof(int).

Now consider the C++ version:

#include <cstdio>

 
{
     code = ;
    std::(, code);
    std::(, ());
}

This difference matters when code is shared between C and C++ or when code relies on exact types.

• Cross-language libraries: A header or macro used by both C and C++ should not assume that 'x' has the same type in both languages.
• Generic macros: In C, macros using _Generic can select different behavior for 'a' and a char variable because the literal is an int.
• Overloaded C++ functions: In C++, overload resolution can choose a char overload for 'a'.
• Binary and text protocols: Developers often store byte values in unsigned char buffers. They should explicitly convert when a specific byte type is required.
• Portability checks: sizeof(char) and CHAR_BIT are the correct tools for learning about the platform's byte representation; sizeof('a') is not a measurement of character storage.

Developers usually treat character literals as values, then choose an explicit type when storage or API contracts matter.

Store a byte explicitly

unsigned char marker = (unsigned char)'M';

This is useful for byte buffers, file formats, and network data. The cast makes the intended destination type clear.

Validate a character range

int is_ascii_digit(char ch)
{
    return ch >= '0' && ch <= '9';
}

The literals may have different types in C and C++, but the comparisons work because the operands are converted as required by each language.

Use int for character input results in C

int ch = getchar();

if (ch == EOF) {
    /* No more input or an input error. */
} else if (ch == 'q') {
    /* Handle q. */
}

getchar() returns int, not char, so it can represent every value plus the special value. This is one historical reason is common in C character-processing APIs.

Mistake: assuming 'a' is always a char

/* Incorrect assumption in C */
sizeof('a') == sizeof(char)

In C, 'a' is an int. Use a char variable when you need the size of the char type:

char ch = 'a';
printf("%zu\n", sizeof(ch));

Mistake: treating a byte as always 8 bits

/* Not fully portable */
if (sizeof(char) == 1) {
    /* Assume char has 8 bits */
}

sizeof(char) is always 1, so this check says nothing about its bit width. Use CHAR_BIT:

• sizeof(char) is always 1 in both C and C++.

• A C/C++ byte has CHAR_BIT bits, where CHAR_BIT >= 8.

• In C, an ordinary literal such as 'a' has type int.

• In C++, an ordinary literal such as 'a' has type char.

• Therefore:

  /* C */
  sizeof('a') == sizeof(int)
  

  // C++
  sizeof('a') == sizeof(char)
  

• sizeof('a') is not guaranteed to be 4 in C; it depends on sizeof(int).

• 'a' is a character literal; is a string literal.

Why is sizeof(char) always 1?

The languages define a byte as the amount of storage occupied by a char. Therefore, sizeof(char) must be 1 by definition.

Does sizeof(char) == 1 mean a char has 8 bits?

No. It means char occupies one language byte. Use CHAR_BIT to get the number of bits in that byte. It is at least 8.

Why are C character literals int values?

This is a historical C language design choice. It also fits C character APIs such as getchar(), which use int so they can represent both character values and EOF.

Is sizeof('a') always 4 in C?

No. In C it equals sizeof(int). Four is common, but the C standard does not require that size.

Is sizeof('a') always 1 in C++?

For an ordinary character literal such as 'a', yes: its type is char, and is always 1.

• sizeof operator — Learn how sizeof measures types and expressions at compile time in most cases.
• Fundamental C and C++ types — Understand char, short, int, and their implementation-dependent sizes.
• Character literals and string literals — Distinguish 'x' from "x" and understand their types.
• Integer promotions — See why small integer types are frequently converted to int in expressions.
• CHAR_BIT and <limits.h> — Find the number of bits in a byte portably.
• getchar() and EOF — Learn why character input functions return int.
• Execution character set — Understand why character codes should not always be assumed to be ASCII.
• C and C++ compatibility — Recognize language rules that differ when the same-looking source is compiled as C or C++.