convert inheritance to templates - c++

Question

I have C++11 project that uses inheritance. Here is small fragment:
class ICountable{
public:
virtual ~ICountable(){}
unsigned getCount() const{
return _getCount();
}
bool isEmpty() const{
return _getCount() == 0;
}
private:
virtual unsigned _getCount() const = 0;
};
Suppose we have some LinkList that inherits from ICountable and implements _getCount(). Then you can make function like this:
void doSomething(ICountable &countable){
if (countable.isEmpty())
doSomethingElse();
}
...
LinkList ll;
doSomething(ll);
This is all very good, but there must be another way to do all this:
template <typename T>
void doSomething(T countable){
if (countable.isEmpty())
doSomethingElse();
}
...
LinkList ll;
doSomething(ll); // we do not even need to add <>
Template way is faster and probably easier to implement. std::vector and std::deque are like this as well.
However, how I can avoid code duplication - function isEmpty() must be pasted in all "list things".
I can imagine preprocessor #include or...
I can imagine decorator-like class that may implements all those sugar methods and to proxy the others:
template <typename T>
class List{
T list;
public:
unsigned getCount() const{
return list.getCount();
}
bool isEmpty() const{
return list.getCount() == 0;
}
...
}
What is better inheritance or templates, if there will be no runtime polymorphism?
Is there better way to avoid code duplication?

Answer 1

There is a C++ feature that has not been formally added to the standard (but has been in the works for quite some time) called Concepts that would essentially let you declare your doSomething(T countable) to have the requirement that T implement a certain interface (ie, that it has an isEmpty() function). Until then, you can't avoid polymorphism if what you want is to avoid code duplication by sharing a set of common functions (re: interface) between different classes. That's one of the main reasons to use polymorphism in the first place.
With that said, you are looking for the Curiously Recurring Template Pattern like Igor Tandetnik mentioned in the comments. This allows you to share common code between classes without the runtime penalty of virtual functions (runtime polymorphism). Using CRTP lets the compiler do that stuff for you.
Using a simple base class:
template <typename T>
struct ICountable {
bool isEmpty() const { return static_cast<T*>(this)->_getCount() == 0; }
};
And then your derived list:
class LinkedList : public ICountable<LinkedList> {
int _getCount() const { return size; }
};
Any class that derives from ICountable in this way will now have an isEmpty() method that uses the implementation-specific _getCount() method without the use of virtual functions.

Answer 2

With templates, you just imply the interface. You write a function template and require that the type you pass in meets your criteria. In this case, just:
template <typename T>
void doSomething(T const& countable) {
if (countable.empty()) {
doSomethingElse();
}
}
All the C++ standard containers have an empty() method, and you could do worse than copy the standard interfaces for containers that you write yourself. This function already works for vector and list and string and ..., all without any dynamic dispatch overhead or without the OOP requirements of having to inherit from some interface.
Generic programming works if the types have the interface you need - they don't need to inherit from all the correct named interfaces to get them.