在没有适当原型的情况下调用 printf 是否会调用未定义的行为？

Question

Does this innocent looking program invoke undefined behavior:

int main(void) {
    printf("%d\n", 1);
    return 0;
}

Answer 1

Yes invoking printf() without a proper prototype (from the standard header <stdio.h> or from a properly written declaration) invokes undefined behavior.

As documented in C11 Annex J (informative only)

J2 Undefined Behavior

• For call to a function without a function prototype in scope where the function is defined with a function prototype, either the prototype ends with an ellipsis or the types of the arguments after promotion are not compatible with the types of the parameters (6.5.2.2).

This annex is not normative, but clearly documents the above code as an example of undefined behavior.

In more pragmatic words, in the absence of a prototype for printf , the compiler generates the calling sequence as if printf was defined as int printf(const char*, int) which may be quite different and incompatible with the actual implementation of printf in the standard library, defined as int printf(const char restrict *format, ...) .

Ancient ABIs were regular enough that this would not cause a problem, but modern (eg 64-bit) ABIs use more efficient calling sequences that make the above code definitely incorrect.

As a consequence, this famous classic C program would fail too, without the #include <stdio.h> or at least a proper prototype for printf :

int main(void) {
    printf("Hello world\n");  // undefined behavior
    return 0;
}

Answer 2

C was originally implemented on platforms where passing a variable number of arguments to a function call wouldn't pose any difficulty, and where a function call like foo("Hey", "there", 123); would be processed the same way if the function signature were any of the following:

• int foo(char const *p, char const *q, int x);
• int foo(char const *p, char const *q, ...);
• int foo(char const *p, ...);

On some platforms, however, the number and format of passed arguments must be known in advance; C implementations for such platforms may accommodate this by treating ... as a void* , and having calling code construct and pass the argument of a structure containing the passed arguments. On such platforms, the function call may need to pass p , q , and x as three arguments, pass p , q , and the address of x as three arguments, or build a structure holding q and x , and pass p along with the address of that structure as two arguments.

If a compiler doesn't know where ... belongs in an argument list, it would have no way of knowing how to format the arguments.