Can there be more format specifiers or order can be different than arguments in a C printf statement?

#include <stdio.h>

int main()
{
int a =9;
float b = 1.23;
double c = 6.2396734679;

printf("%d %f %e",b,a);

return 0;
}

How is the output -> 9 1.230000 1.230000e+00 ??

The order of arguments is not correct + Can there be less arguments than format specifiers?

From the C11 standard:

> If there are insufficient arguments for the format, the behavior is
> undefined. If the format is exhausted while arguments remain, the
> excess arguments are evaluated (as always) but are otherwise ignored.
>
>...
>
> If any argument is not the correct type for the corresponding
> conversion specification, the behavior is undefined.

• It is undefined behaviour if the number of format specifiers exceed the number of arguments provided.
• If excess arguments are provided, and the format string is exhausted, the arguments are simply ignored, and there's no undefined behaviour involved.
• The order shall not be different. The first format specifier must match the first argument provided, the second format specifier should match the second argument provided, and so on. If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined.

> Can there be more format specifiers or order can be different than arguments in a C printf statement?

Yes, you can do this, and the C standard does not define the behavior of the program when you do, so it is a bad idea and you should not expect it to work.

In many C implementations, the first few integer arguments are passed in the general processor registers, and the first few floating-point arguments are passed in floating-point registers. So a called routine will look for its integer arguments in the general registers (say numbers r8, r9, and r10) and will look for its floating-point arguments in the floating-point registers (say f4, f5, and f6). Because of this, if you swap integer and floating-point arguments, the routine will still look for and find integer arguments in the general registers and floating-point arguments in the floating-point registers. For example, both foo(1, 2, 3., 4.) and foo(1, 3., 2, 4.) will put the integer values 1 and 2 in the first two general processor registers used for arguments and the floating-point values 3 and 4 in the first two floating-point registers used for arguments.

You should know about this behavior because it is useful for debugging purposes and for understanding how computers work, but you should not rely on it. When optimization is enabled in the compiler, advanced transformations may break this behavior.

Some C implementations do have features for listing the arguments in a format string in a different order than they appear in the function call, using additional characters in each conversion specification (the string with % that tells printf what to do besides echoing literal characters).