What's really happening inside getchar() and printf()? Explain whole process - c

Question

I was learning from geeksforgeeks and when i saw this, a thought came in my mind that as getchar() and other similar functions returns an int(whether due to failure of program or EOF) then why format specifier used is %c, why not %d(or %i).
// Example for getchar() in C
#include <stdio.h>
int main()
{
printf("%c", getchar());
return 0;
}
I know that the character we input in is a character and it is taken by the function getchar() and we are displaying it using %c.
But my problem is what's actually happening inside getchar() and printf() during the whole process, where getchar() is returning that integer, where it is getting stored and how the character we inputted is getting displayed by printf() i.e.what's happening inside printf()?
I did some research on printf() implementation and get to know that printf is part of the C standard library (a.k.a. the libc) and is a variadic function(printf) but i didn't came to know that what is really happening inside this function and how it knows by format specifier that it has to print character or int?
Please help me learning the whole detailed process which is going on.

Answer 1

The man page for getchar says the following:
fgetc() reads the next character from stream and returns it as an
unsigned char cast to an int, or EOF on end of file or error.
getc() is equivalent to fgetc() except that it may be implemented as a
macro which evaluates stream more than once.
getchar() is equivalent to getc(stdin).
So let's say you enter the character A. Assuming your system uses ASCII representation of characters, this character has an ASCII value of 65. So in this case getchar returns 65 as an int.
This int value of 65 returned by getchar is then passed to printf as the second argument. The printf function first looks at the format string and sees the %c format specifier. The man page for printf says the following regarding %c:
If no l modifier is present, the int argument is converted to an
unsigned char, and the resulting character is written.
So printf reads the next argument as an int. Since we passed in a int with value 65, that's what it reads. That value is then cast to an unsigned char. Since it is still in the rage of that type, the value is still 65. printf then prints the character for that value. And since 65 is the ASCII value for the character A, the character A is what appears.

Answer 2

To understand you must read default argument promotions.
where getchar() is returning that integer, where it is getting stored
C handle this for you.
how the character we inputted is getting displayed by printf()
%c tell to printf() to print a character.

Answer 3

(I am supposing your computer has an x86-64 processor and runs Linux)
why format specifier used is %c, why not %d(or %i).
Imagine that the corresponding argument (to printf) was 99 (an int). If you use  %c then the letter c (of ASCII code 99) is displayed. If you use %d or %i then 99 is displayed by printf, etc...
printf is, as you noticed, a variadic function. It is implemented using variadic primitives like va_start and va_end which are macros expanded to some builtin known to the compiler. How exactly arguments are passed and results are given (the calling convention) is defined (in some processor & OS specific way) in a document called ABI (application binary interface).
On some C standard library implementations, printf (and related functions, like vfprintf) would ultimately use putc or something related.
Notice that standard I/O functions (those in <stdio.h>) are likely to be provided with the help of some operating system. Read Operating Systems : Three Easy Pieces for more about OSes.
Quite often, the C standard library will use some system calls to interact with the operating system kernel. For Linux these are listed in syscalls(2), but read Advanced Linux Programming. To output some data the write(2) syscall would be used (but the C standard library is generally buffering, see setvbuf(3)).
BTW, for Linux/x86-64 both GNU glibc & musl-libc are free software implementations of the C standard library, and you can study their source code (most of it is coded in C, with a tiny bit of assembly for the system call glue).
But my problem is what's actually happening inside getchar() and printf() during the whole process, where getchar() is returning that integer, where it is getting stored ...?
The ABI defines that the result of an int returning function goes thru register %rax, and getchar (like every other int return function) works that way. See the X86-64 Linux ABI referenced here.
... and how the character we inputted is getting displayed by printf() i.e. what's happening inside printf()?
After many software layers, when the stdout stream gets flushed (e.g. by some call to fflush(3), by a \n newline character, or at exit(3) time, including returning from main into crt0 code), the C standard library will use the write(2) syscall. The kernel will process it to show something (But details are horribly complex, read first the tty demystified). Actually millions of source code lines are involved (including inside the kernel - read about DRM, inside the display server such as X.Org or Wayland - also some code inside the GPU -, inside the terminal emulator). Linux is free software, so in principle you can study all of it (but that needs more than a lifetime, a typical Linux distribution has about twenty billions lines of source code). See also OSDev wiki which gives some practical information, including about native Intel grapĥics (which are the most primitive graphics today).
PS. You need to spend more than ten years understanding all the details (and I don't).