How does the computer make the difference between types?

I am wondering how my computer can make the difference between the exact same set of 0s and 1s. I don't really know what should be the question but I want to know for instance when I have in C :

int main(){
   __uint8_t a = 97;
   printf(" Here is a char : %c\n Here is a number : %d\n", a, a);
   return 0;
}

How does it know when he rather should print 'a' or 97. I know it is due to the %c and %d, but what is going on really ?

Thank you all !

That %c or %d you mentioned are called conversion specifier, each one of them have specific meaning. They are pre-decided that how the corresponding argument will be treated, formatted and printed.

Quoting from C11, chapter §7.21.6.1, some examples:

> 8. The conversion specifiers and their meanings are:
>
> > d,i The int argument is converted to signed decimal in the style [−]dddd.
>
> and
>
> > c If no l length modifier is present, the int argument is converted to an
unsigned char, and the resulting character is written.

Like that, each conversion specifier has associated rules on how they interpret and print the supplied arguments or ignore them (ex: %%).

When you ask to print with %c the computer will look toward the ASCII table. Computer can only understand numbers (binary) and this table is a reference of how to change a number to a character (see below) as you can see a = 97 in decimal equal 0110 0001 in binary. In code, you can ask to display a value in different formats (%d for decimal, %f for float, %c for char ...) but it is always a binary word in the computer

Ask me if you want more information about low hardware layers

> I am wondering how my computer can make the difference between the exact same set of 0s and 1s.

In the general case, different instructions interpret the same sequence of bits differently. For example, the x86 ADDL instruction interprets its operands as 32-bit integer values, while ADDSD interprets its operands as scalar double-precision floating point values.

The type information you specify in your source code (int, double, char, etc.) determines what machine instructions the compiler generates. For example, if you have the code

double a = 1.0, b = 2.0;
double c = a + b;

the compiler will translate that to

movsd	-8(%rbp), %xmm0     // move value of a (1.0) to xmm0 register
addsd	-16(%rbp), %xmm0    // add value of b (2.0) to value in xmm0, store result in xmm0
movsd	%xmm0, -24(%rbp)    // copy value in xmm0 (3.0) to c

If you change double to int:

int a = 1, b = 2;
int c = a + b;

then the compiler generates the code:

movl	-4(%rbp), %edx   // move value of a (1) to edx register
movl	-8(%rbp), %eax   // move value of b (2) to eax register
addl	%edx, %eax       // add value in edx to eax, store result in eax
movl	%eax, -12(%rbp)  // copy value in eax to c

For your specific question, though:

> I know it is due to the %c and %d, but what is going on really ?

The integer value 97 is stored as a sequence of bits - assuming an 8-bit type, that bit sequence is 01100001, or 0x61.

The %c basically says "present this value as the corresponding symbol in the basic character set" - IOW, the symbol 'a'. Somewhere there's a mapping between integer values and corresponding symbols.

The %d conversion specifier basically says "create a decimal string representation of this value" - that is, emit the sequence of characters {'9', '7'}.

Exactly how values are mapped to characters and displayed is a function of the implementation and the terminal driver, and that will vary from system to system.

Computer does not know. You tell him by %c and %din the printf format string.

And it is an conension used bt this particular architecture to use ASCII codes, where 97 is a

You can write your own output function using any coding you like.