Converting an integer type to the corresponding promoted type is better than converting it to some other integer type.

``````void f(int x);
void f(short x);
signed char c = 42;
f(c); // calls f(int); promotion to int is better than conversion to short
short s = 42;
f(s); // calls f(short); exact match is better than promotion to int
``````

Promoting a `float` to `double` is better than converting it to some other floating point type.

``````void f(double x);
void f(long double x);
f(3.14f); // calls f(double); promotion to double is better than conversion to long double
``````

Arithmetic conversions other than promotions are neither better nor worse than each other.

``````void f(float x);
void f(long double x);
f(3.14); // ambiguous

void g(long x);
void g(long double x);
g(42); // ambiguous
g(3.14); // ambiguous
``````

Therefore, in order to ensure that there will be no ambiguity when calling a function `f` with either integral or floating-point arguments of any standard type, a total of eight overloads are needed, so that for each possible argument type, either an overload matches exactly or the unique overload with the promoted argument type will be selected.

``````void f(int x);
void f(unsigned int x);
void f(long x);
void f(unsigned long x);
void f(long long x);
void f(unsigned long long x);
void f(double x);
void f(long double x);
``````