Uncertain parameters in C

Ken H

13y1.9k

Hello everyone,
I want to know is how to achieve the C language printf function parameter uncertainty principle(Of course, we do not use the system-supplied "stdarg.h" header file).

The following is "printf" function prototype:

_CRTIMP int __cdecl printf(const char *, ...);

I do not think it uses a function overloading methods,As you know, when users use printf parameters are uncertain (Such as, order uncertain parameter types, the numbers of parameters uncertain and so on).I try to guess it may be using the stack.

Regards,

Ken

Thank for you.

6 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes13y ago
Accepted answer
As you know, printf is an example of a C function which takes a variable number of arguments. The first parameter is mandatory but the remaining parameters are optional. All parameters are pushed onto the stack when the function is called.

You can write these functions yourself but, to do so, you have to make use of an object of type va_list and the macros : va_start, va_arg and va_end all of which are defined in the "stdarg.h" header file. These enable you to iterate through the list of optional arguments and then clean up at the end.

I suppose you could define your own object type and macros, rather than use the standard ones, but there seems very little point.

If you're interested in writing your own version of printf (or a minimal version thereof), then there's an example on pages 155 and 156 of the second edition of K & R if you have this book.
Ken H13y ago
Yes, I agree with you that it is indeed extremely complex and the source code is particularly large number.
Vulpes13y ago
I haven't looked at the source code for printf but it's going to be extremely complicated given the huge number of options supported.

I'd imagine it will have to parse the first argument (the format parameter) to extract all the %d, %f, %s etc. included so it knows how many arguments have been passed and what the types of those arguments are. The 'va_arg' macro will then need to be called to pop those arguments from the stack so they can be processed and eventually find their way to stdout.
Ken H13y ago
Although we all know that it is the use of the stack, but I'm trying to read the code, but found it difficult to read the prototype code. Perhaps it is relatively unfamiliar code form. :(
Vulpes13y ago
Well, the book is copyright so I can't post the example here without the consent of the publishers.

However, here's an example of a 'varargs' function I've coded myself which calculates the mean of a series of non-zero numbers:

#include
#include

/* gets mean of a series of non-zero numbers. The last argument must be zero */
double mean(double first, ...)
{
double arg = first, sum = first;
int count = 1;
va_list arglist; /* variable to hold optional args */
va_start(arglist, first); /* set arglist to get first optional arg */
while(arg != 0.0)
{
arg = va_arg(arglist, double); /* get next optional arg */
sum += arg;
if (arg != 0.0) count++;
}
va_end(arglist); /* finish getting optional args */
return sum/count;
}

int main()
{
double average;
average = mean(1.0, 2.0, 3.0, 4.0, 5.0, 0.0);
printf("The average is %f\n", average);
average = mean(1.5, 2.5, 9.0, 1.0, 6.0, 0.0);
printf("The average is %f\n", average);
average = mean(0.0);
printf("The average is %f\n", average);
return 0;
}

The output should be:

The average is 3.000000
The average is 4.000000
The average is 0.000000
Ken H13y ago
hi Vulpes,

I haven't the second edition of K & R.