Home / Questions / 471388
Accepted
PaperBirdMaster
Asked: 2022-07-28 04:40:17 +0800 CST 2022-07-28 04:40:17 +0800 CST

I pass a different number of parameters than defined, but it compiles and works

  • 772

In C, declaring a function with an empty parameter list tells the compiler that the parameters will be defined later:

#include <stdio.h>

void f(); // DECLARAMOS una función con un número aún indeterminado de parámetros.

int main(void)
{
    f(1, 2, 3); // Llamamos a la función, aún sin definir, con tres parámetros.
    return 0;
}

void f(int x, int y, int z) // DEFINIMOS la función para recibir tres parámetros.
{
    printf("{%d, %d, %d}", x, y, z);
}

Or so I thought, it actually seems that the compiler doesn't do any parameter checking after the function is declared, since this works too:

#include <stdio.h>

void f(); // DECLARAMOS una función con un número aún indeterminado de parámetros.

int main(void)
{
    f(1, 2, 3); // Llamamos a la función, aún sin definir, con tres parámetros.
    f(1, 2);    // Llamamos a la función, aún sin definir, con dos parámetros.
    f(1);       // Llamamos a la función, aún sin definir, con un parámetro.
    f();        // Llamamos a la función, aún sin definir, sin parámetros.
    f(1, 2, 3, 4, 5, 6, 7, 8, 9, 0); // Llamamos a la función con diez parámetros!!
    return 0;
}

void f(int x, int y, int z) // DEFINIMOS la función para recibir tres parámetros.
{
    printf("{%d, %d, %d}", x, y, z);
}

Not only does it not give any compilation errors, but it compiles without alarms and executes by assigning indeterminate values ​​to unprovided variables and ignoring extra passed variables. What is happening? Shouldn't the compiler compare the function call to the function definition and cause a compile error?

c

1 Answers

  1. Best Answer

    TLDR: That's undefined behavior.

    You can go to wg14.link and check it against the other standards, I'll use C99.

    First of all, let's define what a function prototype is:

    6.2.1 at the end of paragraph 2

    A function prototype is a declaration of a function that declares the types of its parameters.

    Now let's go to Exhibit J, and let's see what it has to say about what you're doing:

    The behavior is undefined in the following circumstances:

    • [...]

    • For a call to a function without a function prototype in scope, the number of arguments does not equal the number of parameters (6.5.2.2).

    In this case:

    void f();

    It is not a function prototype, since according to the standard:

    6.7.5.3 at the end of paragraph 14

    The empty list in a function declarator that is not part of a definition of that function specifies that no information about the number or types of the parameters is supplied.

    You are not declaring the types of the parameters (in fact you are not giving any information about them). So this doesn't count as a function prototype.

    So the following calls:

        f(1, 2);    // Llamamos a la función, aún sin definir, con dos parámetros.
    f(1);       // Llamamos a la función, aún sin definir, con un parámetro.
    f();        // Llamamos a la función, aún sin definir, sin parámetros.
    f(1, 2, 3, 4, 5, 6, 7, 8, 9, 0); // Llamamos a la función con diez parámetros!!

    It's undefined behavior, since it fdoesn't have a prototype, and the number of arguments you call it with doesn't match the number of parameters you define it with.

    Remember that by falling into undefined behavior anything goes, your program may work and run fine, your program may crash, it may work sometimes and sometimes not, it may not compile, or whatever.


    What is happening? Shouldn't the compiler compare the function call to the function definition and cause a compile error?

    Being undefined behavior, anything can happen. In this case it seems that the compilers prefer to give you something to run, instead of telling you what you're doing wrong.

    In this case, so that the compiler gives you a warning about the errors you are making, you can enable: -Wstrict-prototypes -Wmissing-prototypes. These don't tell you that you're engaging in undefined behavior, but it's the closest I could find.

    And regarding this:

    [...] Shouldn't the compiler compare the function call with the function definition [...]?

    It seems that clangit does. You see the assembler generated for the call with extra parameters:

    ; Elimina los parametros que no se usaran
mov     edi, 1
mov     esi, 2
mov     edx, 3
call    f

    Compared to gcc, that when you had too many parameters I filled it as if the function accepted all of them:

    mov     r9d, 6
mov     r8d, 5
mov     ecx, 4
mov     edx, 3
mov     esi, 2
mov     edi, 1
mov     eax, 0
call    f

    Link to godbolt .

    But don't worry, because according to the standard:

    6.11.6

    The use of function declarators with empty parentheses (not prototype-format parameter type declarators) is an obsolescent feature.

    Since it is becoming obsolete, I suppose that in the future it will be removed.

    • 4