将数组用作可变参数函数的最后一个命名参数会导致缓冲区下溢吗？

Great question! Let's unpack this clearly, since the stdarg.h note can feel confusing if you don't dig into how variadic functions work under the hood.

First: Why Does stdarg.h Prohibit Array Types as the Last Named Parameter? #

The key line from the man page states:

Because the address of this parameter is used in the va_start() macro, it should not be declared as a register variable, or as a function or an array type.

Here's the breakdown for arrays specifically:

• In C, when you declare a function parameter as an array (e.g., void my_func(int arr[], ...)), the compiler automatically adjusts it to a pointer type (int *arr)—this is the famous "array decay" behavior.
• But the va_start macro relies on the declared type of the last named parameter to calculate the memory offset to the first variadic argument. If you declare the parameter as an array, even though it's treated as a pointer at runtime, the macro might miscalculate this offset.
• For example: If you declared arr as int arr[5], some older or strictly conforming va_start implementations might assume the parameter takes up the full size of the array (20 bytes for 5 ints) instead of the size of a pointer (4 or 8 bytes). This shifts the starting point of the variadic arguments by the wrong amount, pointing to invalid memory.

Does This Cause Buffer Underflow? #

Short answer: It can, but more importantly, this usage triggers undefined behavior—the C standard doesn't guarantee any specific outcome. Here's why buffer underflow is a plausible consequence:

• When va_start miscalculates the starting address of the variadic arguments, the va_arg macro will read or write from the wrong memory location.
• If you're reading arguments, you might pull data from outside the intended variadic argument area—possibly from other parts of the stack, or even beyond the stack's bounds (a form of buffer underflow/overread).
• If you're writing to arguments (though less common), you could overwrite critical stack data like return addresses or local variables—this is a buffer overflow/write, which can crash your program or create security vulnerabilities.
• Worse, in some cases, it might appear to work correctly (if the offset miscalculation lands on the right spot by accident), but this is just luck and will break unpredictably with different compilers, optimizations, or input sizes.

The Bottom Line #

Always follow the stdarg.h guidelines: never use an array type as the last named parameter in a variadic function. Instead, declare it explicitly as a pointer (since that's what the compiler treats it as anyway) to ensure va_start works correctly and avoids undefined behavior like buffer underflow.

内容的提问来源于stack exchange，提问作者Shoblade X