具有double类型的可变数字参数的函数的奇怪输出

Question

I tried function with variable number of integer parameters, it worked as expected. But when I tried variable number of parameters of type "double", it gave strange output:

$ g++ -fpermissive -std=c++11 te2d.cc
te2d.cc: In function ‘void maxof(double, long int, ...)’:
te2d.cc:19:16: warning: return-statement with a value, in function returning 'void' [-fpermissive]
$ ./a.out
dum=100.200000
debug 1 0.000000
debug 2 0.000000
debug 3 -5486124068793688683255936251187209270074392635932332070112001988456197381759672947165175699536362793613284725337872111744958183862744647903224103718245670299614498700710006264535590197791934024641512541262359795191593953928908168990292758500391456212260452596575509589842140073806143686060649302051520512.000000
debug 4 0.000000

Here is the short code:

#include <stdio.h>
#include <stdarg.h>
typedef unsigned char uchar;
typedef unsigned short uint16;
using namespace std;
typedef unsigned char uchar;
void maxof(double dum, long n_args, ...){
        printf("dum=%f\n", dum);
        register int i;
        int max = 0;
        va_list ap;

        va_start(ap, n_args);
        for(i = 1; i <= n_args; i++) {
            printf("debug %d %f\n", i, va_arg(ap, double));
        }

        va_end(ap);
        return max;
}

int main(int argc, char *argv[]) {
    maxof(100.2, 4, 10,14,13,11);
    return 0;
}

Any ideas? Thanks.

Answer 1

C variadic functions don't magically handle conversions from int to double *. You need to specify the type that went into the function, not the type you want to end up with after conversions. Think of it as telling the compiler how to interact with the stack. If you tell it the top of the stack has a double and double is bigger than int , you've now just told it to take extra bytes off of the stack, which is terrible. Even if they were the same size, they do not have the same binary representation.

You really have to be careful with C variadic functions. The better solution, if available, would be to use variadic templates, which are perfectly typesafe and trigger compile-time errors rather than undefined behaviour. In this case, since you want all arguments to be the same type, you can use std::initializer_list :

#include <initializer_list> //be sure not to forget this when using std::initializer_list

double maxof(std::initializer_list<double> nums) {
    double max = 0; //hope you don't have negative numbers
    for (const auto &num : nums) {
        if (num > max) {max = num;}
    }

    return max;
}

...

maxof({10,14,13,11})

Note that there's an overload of std::max that does this, so no need to write your own.

If you're stuck with pre-C++11, you could potentially create many overloads to get the same effect, but you'd be much better off creating a function based on a container or iterators, like std::max_element .

---

*Promotions are applied to arguments, so it's not always the exact type that goes in. For example, passing in a char will require the function to extract an int . These promotions are well-specified and are mostly <small integral type> -> int .