c++: template container, operator[] not working as expected - c++

Question

I'm trying to implement a template class that wraps around a
STL container of pointers, as in:
tContainer_t<T, vector<T*> >
or
tContainer_t<T, list<T*> >
Here's the class declaration:
template <typename T, typename Container>
class tContainer_t
{
public:
tContainer_t() {} //Default CTOR
~tContainer_t() {} //DTOR
bool IsEmpty() const;
size_t Size() const;
bool Insert(T* _element);
T* Find(T _value);
T* Remove(T _value);
T* operator[](size_t _index);
private:
tContainer_t(const tContainer_t& _other); //Disable Copy
Container m_container;
};
I want to practice different implementations for operator[] (for vector and list),so I wrote:
template <typename T, typename Container>
T* tContainer_t<T, Container>::operator[](size_t _index)
{
T* retval;
if (_index > m_container.size())
{
return 0;
}
if (typeid(m_container) == typeid(vector<T*>))
{
retval = m_container[_index];
}
if (typeid(m_container) == typeid(list<T*>))
{
typename Container::iterator contIter = m_container.begin();
advance(contIter, _index);
retval = *contIter;
}
return retval;
}
and I get strange behavior. when I use a vector in main, the code works fine. When I use a list, it doesn't even compile, showing:
container.h: In instantiation of ‘T* tContainer_t<T, Container>::operator[](size_t) [with T = int; Container = std::list<int*>; size_t = long unsigned int]’:
container.cpp:10:14: required from here
container.h:141:23: error: no match for ‘operator[]’ (operand types are ‘std::list<int*>’ and ‘size_t {aka long unsigned int}’)
retval = m_container[_index];
Here's how I'm using it:
int main(int argc, char const *argv[])
{
tContainer_t<int, list<int*> > a;
int i = 5;
a.Insert(&i);
cout << *a[0] << endl;
return 0;
}

Answer 1

All the code in a function will get compiled, regardless of whether or not it'll ever get run. So this:
if (typeid(m_container) == typeid(vector<T*>))
{
retval = m_container[_index];
}
cannot possibly ever work for list<T>, since list has no operator[]. Hence the compiler error. It doesn't matter that it won't get run, it still has to compile. The way to do this instead is to dispatch to different functions based on the type of m_container:
template <typename T, typename Container>
T* tContainer_t<T, Container>::operator[](size_t _index)
{
if (_index > m_container.size())
{
return 0;
}
return _get_index(m_container, _index);
}
With a vector version:
template <class T>
T* tContainer_t<T, Container>::_get_index(std::vector<T*>& v, size_t _index) {
return v[_index];
}
And a list version:
template <class T>
T* tContainer_t<T, Container>::_get_index(std::list<T*>& lst, size_t _index)
{
typename Container::iterator contIter = lst.begin();
advance(contIter, _index);
return *contIter;
}
At least that's a good general approach. In this case, we don't actually have to split them up, since we can use advance() for both container types. It'll be cheap for the vector and expensive for list:
template <typename T, typename Container>
T* tContainer_t<T, Container>::operator[](size_t _index)
{
if (_index >= m_container.size()) // note the off-by-one error I fixed here
{
return nullptr;
}
auto it = m_container.begin();
std::advance(it, _index);
return *it;
}
Or simply:
return *std::next(m_container.begin(), _index);