How to "extract" a long double using va_arg?

Question

I'm learning C programming and facing a problem. I would like to "extract" a long double from a list of arguments. But, when I ask va_arg to "catch" a long double argument, I have a random error (as it is mentionned in the man about bad va_arg calls). But how would it be possible for me to solve this problem? Here is an example of code illustrating the pb:

void func(va_list *ptr)
{
    long double f;

    f = va_arg(*ptr, long double);
    printf("Value extracted: %Lf\n", f);
    return ;
}

void func2(char *format, ...)
{
    va_list ap;

    va_start(ap, format);
    func(&ap);
    va_end(ap);
    return ;
}

Thanks for your help!

Edit: I know how to use va_arg (at least for simple stuff). As you can see, the function takes a pointer to a va_list as argument. This is because I call va_start in the calling function (and va_end at the end of the same calling function). I just wanted to show you the problem and nothing else.

I have no problem with other data types (int, long, char, char *, etc.). It's just a long double pb.

Edit #2: I wrote a calling function to show you I am not forgetting va_start and va_end. And, to conclude, my problem is that I am trying to code my own printf function and I am dealing with the -Lf conversion. I didn't think it would be necessary to mention it, sorry about this.

Answer 1

There are numerous issues with your code, including the lack of va_start and va_end, but to address your specific question:

The va_arg function expects the type to be known when it is called; the type argument is you telling it "hey, the argument is this type", not "get the next argument in the list that has this type" which is what I'm guessing you think it does based on your question.

In general, at the assembly level, there really isn't any information about types as they are passed to functions - without debugging information that is. This is why that argument is needed by va_arg, and why variadic functions like printf and scanf require information about types being processed in their format strings.

If designing a variadic function that takes types that may vary, you need to account for the different possible types; a format string is one way.

Answer 2

You still haven't shown us the complete, compilable code you are using, so it's difficult to see what you're doing wrong. Here's some complete code which illustrates what you're trying to do.

#include <stdarg.h>
#include <stdio.h>

void vlist_one_ldouble(va_list *pargs) {
    long double value;

    value = va_arg(*pargs, long double);
    printf(" %Lf", value);
}

void vlist_ldouble(int count, va_list *pargs) {
    printf("Now printing %d long doubles:\n", count);

    for (int i=0; i<count; i++)
        vlist_one_ldouble(pargs);

    printf("\n");
}

void list_ldouble(int count, ...) {
    va_list args;
    va_start(args, count);

    vlist_ldouble(count, &args);

    va_end(args);
    return;
}

int main(void) {
    long double a = 1.1, b=2.2, c=3.3;

    list_ldouble(3, a, b, c);
    list_ldouble(4, 1.1L, 2.2L, 3.3L, 4.4L);

    return 0;
}

A very important thing which we can't check without your full code is that you have to be sure that you're actually passing long doubles. Here I'm doing it two ways: firstly, with long double variables; secondly with long double literals.

The L suffix here is an example of a "typed literal". When you specify the actual value of a variable in your source code (e.g. 1 or 3.14 or 'b' or "foo") that's a literal. Usually you don't have to specify explicitly what the type of the literal is, as the compiler can do any necessary conversions. For floating point literals, the standard says this:

An unsuffixed floating constant has type double. If suffixed by the letter f or F, it has type float. If suffixed by the letter l or L, it has type long double.

If a standard function with a prototype is called with a literal value, say func(1.2) then the compiler will know whether func() is expecting a float, a double or a long double and pass the appropriate type to the function. But with variable length argument list functions, there's no prototype to work from, so the compiler works from the type of the value you're passing. If you're passing 1.2, it will pass it as a double. If you want to pass a long double, you have to specify that your 1.2 is actually a long double, and that's what the L is for. If you end up passing a double, but expecting a long double, you'll not get the value you're expecting.

I can't find an ideal reference for this, but this page isn't bad, and these pages are good, but are about C++, rather than C.

If this doesn't answer your problem, post a complete, compilable program which isn't doing what you expect.