Declare a function signature with decltype() - c++

Question

Is it possible to declare a function bar to have the same signature as function foo?
int foo(int a)
{
return 0;
}
decltype(foo) bar
{
return 1;
} //imaginary syntax

Answer 1

I think the same applies as for typedefs and aliases: You may use decltype to declare a function, but not to define it:
int foo();
decltype(foo) bar;
int foo()
{
return bar();
}
int bar() { return 0; }
is accepted by clang++3.5 and g++4.8.1
[dcl.fct.def.general]/2 forbids (grammatically) the definition of a function w/o parentheses:
The declarator in a function-definition shall have the form
D1 ( parameter-declaration-clause ) cv-qualifier-seqopt
ref-qualifieropt exception-specificationopt attribute-specifier-seqopt trailing-return-typeopt
as described in 8.3.5.

Answer 2

You can use variadic templates to define a function which has the same signature as any function:
#include <iostream>
int foo(char const *blah) { return 0; }
template<typename... Args>
auto bar(Args ... args) -> decltype(foo(args...))
{
return 1;
}
int main() {
std::cout << foo("test") << std::endl;
std::cout << bar("test") << std::endl;
return 0;
}
This could also be modified slightly to pass "foo" as the first template argument, so that you could use the same "bar" with many different "foo"s:
template<typename Func, typename... Args>
auto bar(Func f, Args ... args) -> decltype(f(args...))
{
return 1;
}
int baz(double d) { return 3; }
int main() {
std::cout << bar(&foo, "test") << std::endl;
std::cout << bar(&baz, 1.2) << std::endl;
return 0;
}

Answer 3

The first thing that comes into mind is that you need to name the parameters so no, you can't.
The type of foo is:
int(int)
so any imaginary declaration syntax like:
decltype(foo) bar { //imaginary syntax
// can't access parameter
return 1;
}
will have the problem that bar can't access parameters.
So the best you can do is what #dyp suggests.
One other thing you could do is to check if two functions have the same signature:
static_assert(std::is_same<decltype(foo), decltype(bar)>::value, "Invalid bar signature");

Answer 4

Not trivially as you're posing, since you cannot set the arguments directly. decltype(foo) does return the actual type of foo, so you can use that to instantiate a template traits class that then exposes the return type and arguments type (somehow), and then use that to define your function.
#include <stdio.h>
int sf(int, float, double, bool) {}
template <typename RV, typename... args>
RV func(args... as) {
printf("%d %f %f %d\n", as...);
return sf(as...);
}
template <typename RV, typename... args>
RV(*generateFunc(RV(*)(args...)))(args...) {
return &func<RV, args...>;
}
int main() {
decltype(sf) *f = generateFunc(sf);
f(42, 1.0f, 12.0, true);
}
This generates a function to match sf's signature and then forwards the call to it.