Is it possible to have variable inputs in C functions - c

Question

I'm making a simple function to calculate the difference between two inputs. Just for convenience really. Something to refer to in personal header files.
I wish to input either:
two integers : output one integer
two doubles : output one double
I've tried searching online for some kind of global input declaration but can't find it.
I prefer not to have two functions, just one simple one.
Example code headers:
int diff(int a, int b);
double diff(double a, double b);
Thanks for the help!

Answer 1

No, this is called overloading and it's not a feature C has. You are best off creating distinct functions to handle this.
You can do it with all sorts of C wizardry (you can just about do anything with enough C wizardry), but the resulting code may be so ugly as to be unmaintainable :-)
For example, C11 introduced generic selections, with the _Generic primary expression, and this allows you to call different functions based on the input argument type. It actually does a little more than that, but that's the aspect you're interested in, based on your question.
For example, let's say you define two functions thus:
int diffi (int a, int b) { return a - b; }
double diffd (double a, double b) { return a - b; }
Normally, you would have to decide which to call based on what your input types were. The C11 generic selection feature allows you to do this:
#define diff(a,b) \
_Generic((a), \
double: diffd, \
int: diffi, \
default: diffX \
)(a,b)
And what this does is basically, on finding the macro diff(x,y) in the source code:
determine the type of the expression (a), without evaluating it;
inject into the source stream the token matching that type (or default if no match found);
inject into the source stream the (a,b) text at the end.
So, if your source file contains the lines:
x = diff (1, 2);
y = diff (1.0, 2);
this will be translated into:
x = diffi (1 , 2);
y = diffd (1.0, 2);
giving you your effective overloading.
Now that's a moderately easy case since it relies on only the first argument type - you'll see a hole there if you try to do:
z = diff (1, 2.0);
in that the type of the first argument is an int so you'll get:
z = diffi (1, 2.0);
which won't be what you actually want to do. This is where the complexities come in since you have to cover four possibilities: {int/int, int/double, double/int, double/double} and it gets more complex based on the number of arguments and the possible types for each argument.
That full case of yours, however, can be done with judicious use of defaults and nested generic selections, something like:
#define diff(a,b) \
_Generic((a), \
double: diffd, \
default: _Generic((b), \
double: diffd, \
default: diffi \
) \
)(a,b)
and this can be read as:
if the type of a is double, use diffd;
otherwise, if the type of b is double, use diffd;
otherwise, use diffi.
don't forget to inject the arguments as well.
The following complete program (compiled with clang 3.0) shows this feature in action:
#include <stdio.h>
int diffi (int a, int b) {
printf ("diffi %d %d", a, b);
return a - b;
}
double diffd (double a, double b) {
printf ("diffd %f %f", a, b);
return a - b;
}
#define diff(a,b) \
_Generic((a), \
double: diffd, \
default: _Generic((b), \
double: diffd, \
default: diffi \
) \
)(a,b)
int main (void) {
int i; double d;
i = diff (1 , 2 ); printf (" --> %d\n", i);
d = diff (1.0, 2 ); printf (" --> %f\n", d);
d = diff (1 , 2.0); printf (" --> %f\n", d);
d = diff (1.0, 2.0); printf (" --> %f\n", d);
return 0;
}
The output of that program is:
diffi 1 2 --> -1
diffd 1.000000 2.000000 --> -1.000000
diffd 1.000000 2.000000 --> -1.000000
diffd 1.000000 2.000000 --> -1.000000
showing that the correct function is being called for the four possibilities.
And, in fact, as rici points out in a comment, you can rely on the promotion rules of C, where adding a double and int (in any order) gives you a double while adding two int variables gives you an int:
#define diff(a,b) _Generic((a+b), double:diffd, default:diffi)(a,b)

Answer 2

Function overloading is not available in C.
Some possible workarounds
Use two functions with different names for ex: diff_i and diff_d
(Recommended)
Use varargs (not recommended) This will make code difficult to maintain with time.
Use _Generic

Answer 3

An IEEE754 double has more than 32bits of precision, so just write the double version and let automatic conversion take care of the rest.
Of course if you're using a system where sizeof(int)>4 or a char has more than 8 bits, it may be best to write variants for each type, and adopt some kind of Hungarian-naming-convension for them. You could then write, maybe:
int diffi(int, int);
double diffd(double, double);
ssize_t diffz(size_t, size_t);
etc. Essentially, this is manually name-mangling, the same technique the C++ compiler uses to generate distinct symbolic-names for the object-file's export table.