simplified/alternative version of std::bind()/ tr1::bind() - c++

Question

I am using C++03. Thus I don't have std::bind(). My compiler is ported from g++, but tr1::bind() is not ported.
I want to bind a function having 3 arguments. Thus std::bind1st() and std::bind2nd() won't work. In addition, neither std::bind1st() or std::bind2nd() deal with reference type of argument.
Thus I am writing my own version of bind1st() as follows, including sample invocation of my bind1st():
#include <iostream>
// c++03 does not define nullptr
#ifndef nullptr
#define nullptr ((void*)0)
#endif
namespace mybinder {
void *binder3ArgToBind;
void *binder3FunctorToCall;
template <int uniqueID, typename USER_FUNC_TYPE, typename BOUND_FUNC_TYPE,
typename returnType, typename T1, typename T2, typename T3>
class binder3 // 3 arguments binder
{
public:
static void setParams(void **pArg1, void **pFunc) {
*pArg1 = binder3ArgToBind;
*pFunc = binder3FunctorToCall;
binder3ArgToBind = nullptr;
}
static returnType f_bound1st_common(T2 &arg2, T3 &arg3) {
static void *arg1;
static void *func;
returnType ignored;
if (binder3ArgToBind != nullptr) {
setParams(&arg1, &func);
return ignored;
}
return ((USER_FUNC_TYPE)func)(*(T1*)arg1, arg2, arg3);
}
static returnType f_bound1st(T2 arg2, T3 arg3) {
return f_bound1st_common(arg2, arg3);
}
static returnType f_bound1st(T2 &arg2, T3 arg3) {
return f_bound1st_common(arg2, arg3);
}
static returnType f_bound1st(T2 arg2, T3 &arg3) {
return f_bound1st_common(arg2, arg3);
}
static returnType f_bound1st(T2 &arg2, T3 &arg3) {
return f_bound1st_common(arg2, arg3);
}
static BOUND_FUNC_TYPE bind1st(USER_FUNC_TYPE f, T1 &arg1) {
binder3FunctorToCall = (void*)f;
binder3ArgToBind = (void*) &arg1;
(*(void (*)())f_bound1st_common)();
return f_bound1st;
}
};
}
using namespace std;
using namespace mybinder;
typedef short (*FUNC)(int const, int&);
// test function
short f(int &a, int const b, int &c)
{
int val = 100 * a + 10 * b + c;
a+=100;
c+=10;
return val;
}
int main(void)
{
int a[2] = {2, 5};
for (int i=0; i<2; ++i) {
// bind function f with a[i] as its 1st argument.
FUNC ff = binder3<__COUNTER__, short(*)(int&, int const, int&), short(*)(int const,int&), short, int, int const, int>::bind1st(f, a[i]);
int k;
int m;
for (m=0; m<2; ++m) {
k = 1-m;
cout << "before: a[i]=" << a[i] << endl;
cout << "before: m=" << m << endl;
cout << "before: k=" << k << endl;
cout << ff(m, k) << endl;
cout << "after: a[i]=" << a[i] << endl;
cout << "after: m=" << m << endl;
cout << "after: k=" << k << endl << endl;
}
}
}
And the execution results:
before: a[i]=2
before: m=0
before: k=1
201
after: a[i]=102
after: m=0
after: k=11
before: a[i]=102
before: m=1
before: k=0
10210
after: a[i]=202
after: m=1
after: k=10
before: a[i]=5
before: m=0
before: k=1
501
after: a[i]=105
after: m=0
after: k=11
before: a[i]=105
before: m=1
before: k=0
10510
after: a[i]=205
after: m=1
after: k=10
It works fine on my PC, as an emulation. However, it raises several problems in my embedded compiler:
(1) The embedded compiler does not support __COUNTER__
(2) The invoke of bind1st() is tedious, and those redundant types in the template may get problem, if they are not synchronized.
Thus my question:
(1) How do I implement __COUNTER__ as in regular g++/gcc? Or, In fact, I only need a unique number/identifier than a counter.
(2) Is there anyway I can derive argument types and return types from the function pointer type?
(3) Even if Question (2) can be done, can I derive bare types from a reference type? For example, can I derive int from int &? Please note that the source type can be int or int &, and I need to derive the resulting type int in both cases. Please note that it's C++03, not C++11 or higher.
(4) Any other suggestions? Perhaps someone can provide a simpler or better implementation?
The goal of Q.2 and Q.3 is to make template call shorter, like FUNC ff = binder3<__COUNTER__, short(*)(int&, int const, int&)>::bind1st(f, a[i]);. All other types can be derived from the first function pointer type. In addition, I don't have to write 4 overloads.
---UPDATE---
Since the implementation uses pointers to get the binding argument and the function, it may have a potential bug/design flaw:
If the caller changes the value of the binding variable after it calls binder3<...>::bind1st(), but before the use(call) of the bound function, the effective value is the value AFTER change, not BEFORE change!
Currently I can live with it, by careful coding. And normally I use(call) the bound function right after the bind1st() (without any command in-between).
Ideas to improve this problem are welcome.
--UPDATE--
Currently, use of __COUNT__ contains a bug: Since __COUNT__ is not globally unique (restart count from zero for each compilation of .cpp file), the bounding variable may be overwritten, if they are not used promptly. If I can get a program-wide global unique number to replace __COUNT__, the above implementation should be good enough (except for those tedious stuff).