I have a list derived from std::list and the iterators are derived from std::list::iterator and std::list::const_iterator. I know deriving STL containers is not a recommended method. But I dont have an choice.

Most of the things working fine except the implicit conversion of my iterator to std::list::iterator/const_iterator. I’m attaching the code.

#include <iostream>
#include <list>

template <class T>
class MyList;

template <class T>
class MyConstIterator;

template <class T>
class MyIterator : protected std::list<T>::iterator
{
public:
  MyIterator()
  {
    mList = nullptr;
  }

  MyIterator(typename std::list<T>::iterator itr, MyList<T>* list)
    : std::list<T>::iterator(itr)
  {
    mList = list;
  }

  operator typename std::list<T>::const_iterator() const
  {
    return *this;
  }
  operator typename std::list<T>::iterator() const
  {
    return *this;
  }

private:
  MyList<T>* mList;
};
//-------------------------------------------------------------------------------------
template <class T>
class MyConstIterator : protected std::list<T>::const_iterator
{
public:
  MyConstIterator()
  {
    mList = nullptr;
  }
  MyConstIterator(typename std::list<T>::iterator itr, MyList<T>* list)
    : std::list<T>::iterator(itr)
  {
    mList = list;
  }
private:
  MyList<T>* mList;
};
//-------------------------------------------------------------------------------------
template <class T>
class MyList : protected std::list<T>
{
public:
  typedef MyIterator<T>              iterator;
  typedef MyConstIterator<T>         const_iterator;

  MyList() :std::list <T>()
  {

  }
  iterator begin()
  {
    MyIterator<T> first(std::list<T>::begin(), this);
    return first;
  }
  iterator end()
  {
    MyIterator<T> enditr(std::list<T>::end(), this);
    return enditr;
  }
  const_iterator begin() const
  {
    MyConstIterator<T> first(std::list<T>::begin(), this);
    return first;
  }
  const_iterator end() const
  {
    MyConstIterator<T> enditr(std::list<T>::end(), this);
    return enditr;
  }
  void push_back(const T& v)
  {
    std::list<T>::push_back(v);
  }

  iterator insert(iterator _Where, const T& _Val)
  {
    return MyIterator<T>(std::list<T>::insert(static_cast<typename std::list<T>::iterator>(_Where), _Val), this);
  }
};
//-------------------------------------------------------------------------------------
int main()
{
  MyList<int> lst;
  lst.push_back(5);
  lst.push_back(6);

  MyIterator<int> itr = lst.begin();
  lst.insert(itr, 8);
}

insert call is failing. It gives the following compilation error.

I understand that When I call std::list::insert it is looking for std::list::const_iterator as the first parameter but what I have is MyIterator. But I have provided the type conversion operator for MyIterator class which converts it into std::list::const_iterator. Im wondering what am I missing?

i tried to provide the type conversion operator but it didnt work.