Overloaded Template Classes - c++

Question

I'm working on a property-like system in c++, one component of which in an accessor template class, which creates static functions I can then pass pointers of, into my property class for get an set operations.
Here's what the accessor looks like:
template <typename T, typename V, V (T::*getf)(), void (T::*setf)(V)>
struct Accessor
{
static V Get(T* obj)
{
return (obj->*getf)();
}
static void Set(T* obj, V aValue)
{
return (obj->*setf)(aValue);
}
};
And a test class that I'll be using the accessor on. Note how SetFoo takes an int, where SetBar takes a const int&.
class TargetClass
{
int foo;
int bar;
public:
TargetClass(int f, int b)
: foo(f)
, bar(b)
{
}
int GetFoo()
{
return foo;
}
void SetFoo(int f)
{
foo = f;
}
int GetBar()
{
return bar;
}
void SetBar(const int& b)
{
bar = b;
}
};
And finally, here's the usage:
int main()
{
TargetClass* target = new TargetClass(5, 3);
// Works great
typedef Accessor<TargetClass, int, &TargetClass::GetFoo, &TargetClass::SetFoo> fooAcessor;
fooAcessor::Set(target, 13);
int foo = fooAcessor::Get(target);
// Doesn't work, because TargetClass::SetBar takes a const int& as an argument, instead of an int
typedef Accessor<TargetClass, int, &TargetClass::GetBar, &TargetClass::SetBar> barAcessor;
delete target;
return 0;
}
I've tried "overloading" the Acessor struct so it's 4th argument is a const V&, but that doesn't seem to work. Is what I'm trying to do here possible?

Answer 1

If you have access to c++17, and assuming that the proposed standard doesn't change in the meantime, you can have the types deduced automatically:
template <typename F>
struct get_types;
template <typename T, typename V, typename... VP>
struct get_types<V(T::*)(VP...)>
{
using return_type = V;
using class_type = T;
};
template <auto getf, auto setf>
struct Accessor {
using V = typename get_types<decltype(getf)>::return_type;
using T = typename get_types<decltype(getf)>::class_type;
static V Get(T* obj)
{
return (obj->*getf)();
}
static void Set(T* obj, V aValue)
{
return (obj->*setf)(aValue);
}
};
class TargetClass {
int foo;
int bar;
public:
TargetClass(int f, int b)
: foo(f)
, bar(b) {}
int GetFoo() { return foo; }
void SetFoo(int f) { foo = f; }
int GetBar() { return bar; }
void SetBar(const int& b) { bar = b; }
};
int main()
{
TargetClass* target = new TargetClass(5, 3);
using fooAccessor = Accessor<&TargetClass::GetFoo, &TargetClass::SetFoo>;
fooAccessor::Set(target, 13);
int foo = fooAccessor::Get(target);
using barAcessor = Accessor<&TargetClass::GetBar, &TargetClass::SetBar>;
barAcessor::Set(target, 13);
int bar = barAcessor::Get(target);
delete target;
return foo + bar;
}
As of this writing the program above compiles on gcc 7 (snapshot).

Answer 2

You could add another template parameter for the set function's parameter:
template <typename T, typename V, typename VP, V(T::*getf)(), void (T::*setf)(VP)>
And then use for both cases:
typedef Accessor<TargetClass, int, int,
&TargetClass::GetFoo, &TargetClass::SetFoo> fooAcessor;
typedef Accessor<TargetClass, int, const int&,
&TargetClass::GetBar, &TargetClass::SetBar> barAcessor;
Full program:
template <typename T, typename V, typename VP, V(T::*getf)(), void (T::*setf)(VP)>
struct Accessor
{
static V Get(T* obj)
{
return (obj->*getf)();
}
static void Set(T* obj, V aValue)
{
return (obj->*setf)(aValue);
}
};
class TargetClass
{
int foo;
int bar;
public:
TargetClass(int f, int b)
: foo(f)
, bar(b)
{
}
int GetFoo()
{
return foo;
}
void SetFoo(int f)
{
foo = f;
}
int GetBar()
{
return bar;
}
void SetBar(const int& b)
{
bar = b;
}
};
int main()
{
TargetClass* target = new TargetClass(5, 3);
// now has extra int parameter
typedef Accessor<TargetClass, int, int, &TargetClass::GetFoo, &TargetClass::SetFoo> fooAcessor;
fooAcessor::Set(target, 13);
int foo = fooAcessor::Get(target);
// Works now, because TargetClass::SetBar's function parameter was specified explicitly as const int&
typedef Accessor<TargetClass, int, const int&, &TargetClass::GetBar, &TargetClass::SetBar> barAcessor;
barAcessor::Set(target, 13);
int bar = barAcessor::Get(target);
delete target;
return 0;
}