Confusing behavior of sizeof with chars

Question

#include <stdio.h>
#include <string.h>

int main(void)
{
    char ch='a';

    printf("sizeof(ch)          = %d\n", sizeof(ch));
    printf("sizeof('a')         = %d\n", sizeof('a'));
    printf("sizeof('a'+'b'+'C') = %d\n", sizeof('a'+'b'+'C'));
    printf("sizeof(\"a\")       = %d\n", sizeof("a"));
}

This program uses sizeof to calculate sizes. Why is the size of 'a' different from the size of ch (where ch='a')?

sizeof(ch)          = 1
sizeof('a')         = 4
sizeof('a'+'b'+'C') = 4
sizeof("a")         = 2

Answer 1

TL;DR - sizeof works on the type of the operand.

• sizeof(ch) == sizeof (char)-------------------(1)
• sizeof('a') == sizeof(int) --------------------(2)
• sizeof ('a'+ 'b' + 'c') == sizeof(int) ---(3)
• sizeof ("a") == sizeof (char [2]) ----------(4)

Let's see each case now.

1. ch is defined to be of char type, so , pretty straightforward.

2. In C, sizeof('a') is the same as sizeof (int), as a character constant has type integer.

   Quoting C11,

   An integer character constant has type int. [...]

   In C++, a character literal has type char.

3. sizeof is a compile-time operator (except when the operand is a VLA), so the type of the expression is used. As earlier , all the integer character constants are of type int, so int + int + int produces int. So the type of the operand is taken as int.

4. "a" is an array of two chars, 'a' and 0 (null-terminator) (no, it does not decay to pointer to the first element of the array type), hence the size is the same as of an array with two char elements.

---

That said, finally, sizeof produces a result of type size_t, so you must use %zu format specifier to print the result.

Answer 2

In C, 'a' is constant of type int. It is not a char. So sizeof('a') will be the same as sizeof(int).

sizeof(ch) is the same as sizeof(char). (The C standard guarantees that all alphanumeric constants - and some others - of the form 'a' can fit into a char, so char ch='a'; is always well-defined.)

Note that in C++, 'a' is a literal of type char; yet another difference between C and C++.

In C, sizeof("a") is sizeof(char[2]) which is 2. sizeof does not instigate the decay of an array type to a pointer.

In C++, sizeof("a") is sizeof(const char[2]) which is 2. sizeof does not instigate the decay of an array type to a pointer.

In both languages, 'a'+'b'+'C' is an int type due, in C++, to implicit promotion of integral types.

Answer 3

First of all, the result of sizeof is type size_t, which should be printed with the %zu format specifier. Ignoring that part and assuming int is 4 bytes, then

• printf("sizeof(ch) %d\n",sizeof(ch)); will print 1 in C and 1 in C++.

  This is because a char is per definition guaranteed to be 1 byte in both languages.

• printf("sizeof('a') %d\n",sizeof('a')); will print 4 in C and 1 in C++.

  This is because character literals are of type int in C, for historical reasons¹⁾, but they are of type char in C++, because that's what common sense (and ISO 14882) dictates.

• printf("sizeof('a'+'b'+'C) %d\n",sizeof('a'+'b'+'C')); will print 4 in both languages.

  In C, the resulting type of int + int + int is naturally int. In C++, we have char + char + char. But the + invokes implicit type promotion rules so we end up with int in the end no matter.

• printf("sizeof(\"a\") %d\n",sizeof("a")); will print 2 in both languages.

  The string literal "a" is of type char[] in C and const char[] in C++. In either case we have an array consisting of an a and a null terminator: two characters.

  As a side note, this happens because the array "a" does not decay into a pointer to the first element when operand to sizeof. Should we provoke an array decay by for example writing sizeof("a"+0), then we would get the size of a pointer instead (likely 4 or 8).

---

¹⁾ Somewhere in the dark ages there were no types and everything you wrote would boil down to int no matter. Then when Dennis Ritchie started to cook together some manner of de facto standard for C, he apparently decided that character literals should always be promoted to int. And then later when C was standardized, they said that character literals are simply int.

Upon creating C++, Bjarne Stroustrup recognize that all of this didn't make much sense and made character literals type char as they ought to be. But the C committee stubbornly refuses to fix this language flaw.

Answer 4

As others have mentioned, the C language standard defines the type of a character constant to be int. The historical reason for this is that C, and its predecessor B, were originally developed on DEC PDP minicomputers with various word sizes, which supported 8-bit ASCII but could only perform arithmetic on registers. Early versions of C defined int to be the native word size of the machine, and any value smaller than an int needed to be widened to int in order to be passed to or from a function, or used in a bitwise, logical or arithmetic expression, because that was how the underlying hardware worked.

That is also why the integer promotion rules still say that any data type smaller than an int is promoted to int. C implementations are also allowed to use one’s-complement math instead of two’s-complement for similar historical reasons, and the fact that character escapes default to octal and octal constants start with just 0 and hex needs \x or 0x is that those early DEC minicomputers had word sizes divisible into three-byte chunks but not four-byte nibbles.

Automatic promotion to int causes nothing but trouble today. (How many programmers are aware that multiplying two uint32_t expressions together is undefined behavior, because some implementations define int as 64 bits wide, the language requires that any type of lower rank than int must be promoted to a signed int, the result of multiplying two int multiplicands has type int, the multiplication can overflow a signed 64-bit product, and this is undefined behavior?) But that’s the reason C and C++ are stuck with it.

Answer 5

I'm assuming the code was compiled in C.
In C, 'a' is treated as an int type and int has a size of 4. In C++, 'a' is treated as a char type, and if you try compiling your code in cpp.sh, it should return 1.