Inheritance vs class template specialization. Design dude - c++

Question

I have an implementation design trouble. I hope you can help me. Suppose I have the following class
class A
{
public:
vector<int> v() const { return m_v; }
bool isValid() const { return m_v.size() > m_components; }
int operator [] (const int index) const { return m_v[index]; }
...
private:
vector<int> m_v;
int m_components;
}
Now I want the m_v vector can be of different types, so I can template the class:
template<typename T>
class A
{
public:
vector<T> v() const { return m_v; }
T operator [] (const int index) const { return m_v[index]; }
...
private:
vector<T> m_v;
int m_components;
}
However, I realized that when the type T is for example double I need to extend class A and add more attributes, for example another vector<bool> m_foo; and change several methods that should use these new attributes.
Here is where I have the doubt. I think I have several options:
Option 1: I can make a non-templated base class A with the implementation of all the common methods, and derive several classes each one for each different type (with its own specific class attributes and method implementations), i.e.: Aint, Adouble, Afloat. This option requires that the vector<...> m_v; is stored at each derived class, and hence I have to replicate several times all the same code to access the m_v; attribute in each derived class. In the example, such methods are only v(), operator [] and isValid(), however in the real problem there are much more.
Option 2: Template specialization. I can specialize the class template for each type and hence provide only the implementation of the specific methods that change depending on the T type. However, this enforces to store a lot of stuff in the template class that is only used if T is of a specific type, i.e. the m_foo vector that is only used when T type is double (in the proposed example). Therefore, I am wasting memory. Moreover, it seems not very elegant or even coherent to implement a template class and provide template class specialization for almost most of the template types and store specific attributes that are only used for specific types.
I don't know if I managed to explain my problem well. Hope so.
Thank you in advance.
Javier.

Answer 1

This kind of depends.
General rule of thumb is asking yourself if "ADouble is-a A". When those have a is-a relationship you should use inheritance.
But you also have type dependency which is not really a "is-a" relationship.
You can also use both options: Having a base class with the common functionality which takes a template argument and having child classes with the additions they need. So you don't need to reimplement all the type dependend functions
So:
template<typename T>
class A
{
public:
vector<T> v() const { return m_v; }
T operator [] (const int index) const { return m_v[index]; }
...
private:
vector<T> m_v;
...
};
class ADouble : public A<double>
{
...
};
Btw: why do you think templates take more memory?

Answer 2

Partially specialise specific operations in your class (without specialising the whole class) with sub-operations.
#include <vector>
namespace detail
{
// general concept of indexing into something
template<class T> struct index_operation;
// indexing into most vectors
template <class T> struct index_operation<std::vector<T>>
{
T& operator()(std::vector<T>& v, std::size_t i) const
{
return v[i];
}
T const& operator()(std::vector<T> const& v, std::size_t i) const
{
return v[i];
}
};
// indexing into a vector<bool>
template <> struct index_operation<std::vector<bool>>
{
std::vector<bool>::reference operator()(std::vector<bool>& v, std::size_t i) const
{
return v[i];
}
std::vector<bool>::const_reference operator()(std::vector<bool> const& v, std::size_t i) const
{
return v[i];
}
};
}
template<typename T>
class A
{
using vector_type = std::vector<T>;
public:
std::vector<T> v() const { return m_v; }
decltype(auto) operator [] (const int index) const
{
auto op = detail::index_operation<vector_type>();
return op(m_v, index);
}
private:
std::vector<T> m_v;
};

Answer 3

I will try to formulate the question with an example closely to my real problem although it becomes a longer post.
Option1: Consider the following class implementation based on templates and template specialization.
template<typename T>
class A
{
public:
A() {}
vector<T> v() const { return m_v; }
bool isValid() const { return m_v.size() >= m_components; }
T operator [] (const int i) const { return m_v[i]; }
T& operator [] (const int i) { return m_v[i]; }
int components() const { return m_components; }
double value() const { return m_value; }
void method1();
private:
vector<T> m_v;
int m_components;
double m_value;
vector<bool> m_indices; // this is only used when T is int
map<int, char> m_map; // this is only used when T is double
queue<int> m_queue; // this is only used when T is bool
};
template<>
void A<int>::method1()
{
for (int i = 0; i < m_components; ++i) m_v.push_back(i);
// stuff only for int case
for (int i = 0; i < m_components; ++i) { i % 2 == 0 ? m_indices[i] = true : m_indices[i] = false; }
}
template<>
void A<double>::method1()
{
for (int i = 0; i < m_components; ++i) m_v.push_back(i);
// stuff only for double case
for (int i = 0; i < m_components; ++i) { i % 2 == 0 ? m_map[i] = 'e' : m_map[i] = 'o'; }
}
template<>
void A<bool>::method1()
{
for (int i = 0; i < m_components; ++i) m_v.push_back(i);
// stuff only for bool case
for (int i = 0; i < m_components; ++i) { i % 2 == 0 ? m_queue.push(1) : m_queue.push(0); }
}
As you can see, there are several methods that are common regardless the T type and involves the use of the m_v vector (methods: v(), isValid(), operator[]). However, there are also other methods (method1()) that have a specific implementation depending on T type, and also requires the use of specific data structures depending on this type (queues, maps, vectors). I see very very ugly the definition of queues, maps, vectors, etc in the class although if they are only used in concrete cases depending the T type.
Option 2: The other alternative:
class A
{
public:
A() {}
int components() const { return m_components; }
double value() const { return m_value; }
virtual void method1() == 0;
protected:
int m_components;
double m_value;
};
/***** Derived A for int case ****/
class Aint : public A
{
public:
Aint() {}
vector<int> v() const { return m_v; }
bool isValid() const { return m_v.size() >= m_components; }
int operator [] (const int i) const { return m_v[i]; }
int& operator [] (const int i) { return m_v[i]; }
void method1();
private:
vector<int> m_v;
vector<bool> m_indices;
};
void Aint::method1()
{
for (int i = 0; i < m_components; ++i) m_v.push_back(i);
for (int i = 0; i < m_components; ++i) { i % 2 == 0 ? m_indices[i] = true : m_indices[i] = false; }
}
/***** Derived A for double case ****/
class Adouble : public A
{
public:
Adouble() {}
vector<double> v() const { return m_v; }
bool isValid() const { return m_v.size() >= m_components; }
double operator [] (const int i) const { return m_v[i]; }
double& operator [] (const int i) { return m_v[i]; }
void method1();
private:
vector<double> m_v;
map<int, char> m_map;
};
void Adouble::method1()
{
for (int i = 0; i < m_components; ++i) m_v.push_back(i);
for (int i = 0; i < m_components; ++i) { i % 2 == 0 ? m_map[i] = 'e' : m_map[i] = 'o'; }
}
/***** Derived A for bool case ****/
class Abool : public A
{
public:
Abool() {}
vector<bool> v() const { return m_v; }
bool isValid() const { return m_v.size() >= m_components; }
bool operator [] (const int i) const { return m_v[i]; }
bool& operator [] (const int i) { return m_v[i]; }
void method1();
private:
vector<bool> m_v;
queue<int> m_map;
};
void Abool::method1()
{
for (int i = 0; i < m_components; ++i) m_v.push_back(i);
for (int i = 0; i < m_components; ++i) { i % 2 == 0 ? m_queue.push(1) : m_queue.push(0); }
}
As you can see, in this case the type specific data structures (queues, maps, etc) are only defined for their required cases (not in the general class template of the Option 1). But, now the m_v vector should be defined at each derived class due to its specific type. Hence, the stuff for accesing and manipulating the vector should be replicated always in all the derived classes although they are always the same (methods v(), isValid(), operator[], etc). It also seems non-well designed.
What is the best design for that purpose?
Thank you