Yes. C++ inherits this from C. You can write:
void f(...);
This function can take any number of arguments of any types. But that is not very C++-style. Programmers usually avoid such coding.
However, there is an exception: in template programming, SFINAE makes use of this a lot. For example, see this (taken from here):
template <typename T>
struct has_typedef_type {
// Variables "yes" and "no" are guaranteed to have different sizes,
// specifically sizeof(yes) == 1 and sizeof(no) == 2.
typedef char yes[1];
typedef char no[2];
template <typename C>
static yes& test(typename C::type*);
template <typename>
static no& test(...);
// If the "sizeof" the result of calling test<T>(0)
// would be equal to the sizeof(yes), the first overload worked
// and T has a nested type named type.
static const bool value = sizeof(test<T>(0)) == sizeof(yes);
};
This uses test(...) which is a variadic function.
...(and which doesn't involve the types of the arguments the caller provides as varargs). A correct function declaration must be in scope to call it. So the caller and the callee agree on the function signature and hence the mangled name. If you want to know what ASCII characters are used to represent the...in the mangled name in your implementation, check the symbols in your executable.extern "C".