Copy function signature - c++

Question

I wish to create many functions with the same parameters, for example:
const int add(const int a, const int b) {
return (a + b);
}
decltype(add) subtract {
return (a - b);
}
/* many more functions */
The purpose being that I am able to easily change the types of the parameters once to change all of the functions. I know that this is possible with macros as so:
#define INT_OPERATION(name) const int name (const int a, const int b)
INT_OPERATION(add) { return (a + b); }
INT_OPERATION(subtract) {return (a - b); }
However, I dislike the use of macros. Is there a safer way of doing this?

Answer 1

A function signature cannot be typedefed. Only a function's type. So it's valid to say :
typedef int INT_OPERATION(int a, int b);
and then forward declare a function having this type :
INT_OPERATION Add;
but when it comes to defining the function you'd have to specify arguments, so the follwing is invalid
INT_OPERATION Add { /* No can do */ }
(as soon as you place a set of () after Add you'll be declaring a function returning a plain function which is not valid C++)
On generic types
The same procedure has similar limitations when using the tools for generic programming. You can declare the following typedef :
template<typename T>
using INT_OPERATION = const T(T const, T const);
And then use it for a function (forward) declaration
INT_OPERATION<int> add;
int main() {
std::cout << add(1, 2) << std::endl;
return 0;
}
but when it comes to defining it, you'd have to be mandane
const int add(int const a, int const b) {
return a + b;
}
Demo

Answer 2

Maybe something like that:
#include <iostream>
#include <functional>
typedef std::function<int(int, int)> IntFunction;
IntFunction add = [](int a, int b) {return a + b;};
IntFunction substract = [](int a, int b) {return a - b;};
int main(int, char**) {
std::cout << add(1, 2) << std::endl;
std::cout << substract(1, 2) << std::endl;
return 0;
}
Still boilerplate code, but worth a try ;)

Answer 3

If these were member functions you could declare their common type (typedef const int Fn(int, int)), declare the member functions inside the class using that type:
Fn add, subtract;
Then you define them outside the class in the normal way. Doesn't save boilerplate, but at least means it won't compile if you make a typo in the definitions.
Alternatively for non member functions see the question I linked to which has some clever ways to define function pointers rather than functions.

Answer 4

If your primary concern is being able to "easily change the types of the parameters", it's straightforward to write them as templates so that you never have to change the types of the parameters:
template <typename T1, typename T2>
auto add (const T1 &a, const T2 &b) -> decltype(a + b) {
return (a + b);
}
This also handles cases where a and b are not of the same type, or where a + b is not the same type as a or b.