Using class template argument deduction to make a static interface - c++

Question

I want to create some macros to create static interfaces for templated argument passing, storage, etc. I'm using class template argument deduction, but I'm hitting a wall.
#include <iostream>
template <typename Type>
struct Person
{
Type &object;
Person(Type &object) : object(object) {}
void walk(unsigned steps)
{
object.walk(steps);
}
void talk(const std::string &words)
{
object.talk(words);
}
};
struct MySelf
{
void walk(unsigned steps)
{
std::cout << "walking: " << steps << std::endl;
}
void talk(const std::string &words) const
{
std::cout << "talking: " << words << std::endl;
}
};
template <typename Type>
void testNConst(Person<Type> object)
{
object.walk(50);
object.talk("testing");
}
template <typename Type>
void testConst(Person<const Type> object)
{
object.talk("testing");
}
int main()
{
MySelf myself;
testNConst(Person{myself}); // compiles
testNConst(myself); // does not compile
testConst(myself); // does not compile
return 0;
}
Output:
../../../../src/py.com.personal/other/hanaTest/main.cpp:53:5: error: no matching function for call to 'testNConst'
testNConst(myself); // does not compile
^~~~~~~~~~
../../../../src/py.com.personal/other/hanaTest/main.cpp:35:6: note: candidate template ignored: could not match 'Person<type-parameter-0-0>' against 'MySelf'
void testNConst(Person<Type> object)
^
../../../../src/py.com.personal/other/hanaTest/main.cpp:54:5: error: no matching function for call to 'testConst'
testConst(myself); // does not compile
^~~~~~~~~
../../../../src/py.com.personal/other/hanaTest/main.cpp:42:6: note: candidate template ignored: could not match 'Person<const type-parameter-0-0>' against 'MySelf'
void testConst(Person<const Type> object)
^
2 errors generated.
Any ideas?

Answer 1

Class template argument deduction applies only to creating objects (variable declarations, etc.).
It simply does not apply to either function parameters or function return types. You cannot call testNConst(myself) because myself is not a Person<T> for some T - normal function deduction rules apply.
In short:
template <typename T> struct X { X(T ); };
X x = 42; // ok, ctad here
template <typename T>
void foo(X<T> );
foo(42); // error, ctad doesn't apply here
X bar() { return 42; } // error, ctad doesn't apply here either

Answer 2

An other approach could be using the curiously recurring template pattern (CRTP), inherit from the interface, which takes the type itself as the template parameter, remember you can downcast with static_cast and there is no problem with overload resolution, when using the interface as the parameter. You must know that you cannot use an object of type Person, if it is not subclassed. So you must pass the objects by reference to functions (which is faster than copying the object)...
Instead of the object of type Type living inside Person, the Interface lives inside the Type itself. (The interface does not have any members, when empty structs are inherited from, there is no additional memory overhead, the sizeof MySelf is the same as without the inheritance). With this approach never use Person<Type> without const&, & or && in a parameterlist.
#include <iostream>
template <typename Type>
struct Person
{
/// this returns the subclass-object
Type &object() { return static_cast<Type&>(*this); }
Type const &object() const { return static_cast<Type const&>(*this); }
void walk(unsigned steps)
{
object().walk(steps);
}
void talk(const std::string &words) const /// const was eventually missing
{
object().talk(words);
}
protected:
~Person() = default; /// this disallows the user to construct an instance of this class that is not used as a base object
};
struct MySelf : Person<MySelf>
{
void walk(unsigned steps)
{
std::cout << "walking: " << steps << std::endl;
}
void talk(const std::string &words) const
{
std::cout << "talking: " << words << std::endl;
}
};
template <typename Type>
void testNConst(Person<Type>& object) /// works fine with instances of MySelf and Person<MySelf>
{
object.walk(50);
object.talk("testing");
}
template <typename Type>
void testConst(Person<Type> const& object)
{
object.talk("testing");
}
int main()
{
MySelf myself;
testNConst(myself); // compiles
testConst(myself); // compiles
return 0;
}
Some other tips
always pass objects by reference if you want to change the object
always pass objects by const reference if you do not want to change the object
Edit
a protected destructor avoids that the class is instantiated without a derived class, this prevents the programmer from otherwise invoke undefined behavior (the static_cast<Type&> is the critical point).