template <typename Object>
class ObjectList : public IObject
{
public:
    typedef typename std::vector<Object *> list;
    typedef typename list::const_iterator const_iterator;
    typedef typename list::iterator iterator;

    const_iterator begin() const { return items_.begin(); }
    const_iterator end() const { return items_.end(); }

    iterator begin() { return items_.begin(); }
    iterator end() { return items_.end(); }
protected:
    list items_;
};

class BaseImportList : public ObjectList<BaseImport>
{
...
}

class MacImport : public BaseImport
{
...
}

class MacImportList : public BaseImportList
{
    typedef typename std::vector<MacImport *> list;
    list::const_iterator begin() const { return reinterpret_cast<const list &>(items_).begin(); }
    list::const_iterator end() const { return reinterpret_cast<const list &>(items_).end(); }
}

struct BasePtrVec {
  typedef std::vector<void*> items_t;
  items_t items_;
};

template<class T> struct PtrVecTraits {
  struct iterator {
    BasePtrVec::items_t::iterator it;

    T*& operator*() const { return (T*&)*it; }
    T** operator->() const { return (T**)(it.operator->()); }
    .....
  };
  .....
};

// заготовка контейнера с функциями доступа
template<class T, class C> struct PtrVecCRTP : PtrVecTraits<T> {
  BasePtrVec& src() { return static_cast<C*>(this)->src_; }

  iterator begin() { return iterator(src().begin()); }
  size_t size() const { return src().size(); }
  T*& operator[] (size_t i) { return (T*&)src()[i]; }
  .....
};

// собственно, типизированный контейнер
template<class T> struct PtrVec : PtrVecCRTP<T, PtrVec<T>> {
  BasePtrVec src_;

  PtrVec() {}
  PtrVec(size_t n) : src_(n, nullptr) {}
  .....
};

// ссылка на контейнер - строго инвариантная
template<class T> struct PtrVecRef : PtrVecCRTP<T, PtrVecRef<T>> {
  BasePtrVec& src_;

  PtrVecRef(PtrVec& v) : src_(v.src_) {}  // ссылка на первоисточник - ок
};


// приведения типов, наверно, лучше делать явно руками

// downcast может снимать константность, upcast может накладывать
// ну или этот момент отдельно явно расписать

template<class Derived, class T>
std::enable_if< std::is_convertible<T*, Derived*>::value, PtrVecRef<Derived> >
ptr_vec_ref_downcast(PtrVecRef<T> r) { return PtrVecRef<Derived>(r.src_); }  // 

template<class Base, class T>
std::enable_if< std::is_convertible<Base*, T*>::value, PtrVecRef<Base> >
ptr_vec_ref_upcast(PtrVecRef<T> r) { return PtrVecRef<Base>(r.src_); }

V>class BaseImportList : public ObjectList<BaseImport>
V>{
V>...
V>}
V>

V>class MacImport : public BaseImport
V>{
V>...
V>}

V>class MacImportList : public BaseImportList
V>{
V>    typedef typename std::vector<MacImport *> list;
V>    list::const_iterator begin() const { return reinterpret_cast<const list &>(items_).begin(); }
V>    list::const_iterator end() const { return reinterpret_cast<const list &>(items_).end(); }
V>}
V>

template <typename T>
struct BaseImportListIteratorAdaptor : boost::iterator_adaptor<
   BaseImportListIteratorAdaptor<T>,   // This class
   BaseImportList::const_iterator,     // Base iterator
   T*,                                 // Value type
   boost::use_default,                 // Category of traversal
   T*                                  // Reference (not allowing real references to pointers)
>
{
   // Use concepts instead of the static_assert on C++20
   static_assert(std::is_base_of_v<BaseImport, std::remove_pointer_t<std::decay_t<T>>>);

   using BaseIterator = BaseImportList::const_iterator;
   using BaseAdaptor = boost::iterator_adaptor<
      BaseImportListIteratorAdaptor,
      BaseImportList::const_iterator,
      T*,
      boost::use_default,
      T*
   >;

   BaseImportListIteratorAdaptor() = default;
   BaseImportListIteratorAdaptor(const BaseIterator& i) : BaseAdaptor(i) {}

   T* dereference() const { return static_cast<T*>(*BaseAdaptor::base()); }
};

class MacImportList : public BaseImportList
{
public:
   using const_iterator = BaseImportListIteratorAdaptor<MacImport>;
   using iterator = const_iterator;

   const_iterator begin() const { return items_.begin(); }
   const_iterator end() const { return items_.end(); }
};

class MacImportList : public BaseImportList
{
    typedef typename ObjectList<MacImport>::container container;
    typedef typename container::const_iterator const_iterator;
    const_iterator begin() const { return reinterpret_cast<const container &>(items_).begin(); }
    const_iterator end() const { return reinterpret_cast<const container &>(items_).end(); }
}

template <typename Object>
class ObjectList : public IObject
{
    typedef typename std::vector<Object *> container;
    typedef typename std::vector<Object *>::const_iterator const_iterator;

    const_iterator begin() const { return items_.begin(); }
    const_iterator end() const { return items_.end(); }
protected:
    container items_;
};

V>Я правильно понимаю, что вы забыли приведение типов вокруг "items_.begin()" и "items_.end()"?

BaseImportListIteratorAdaptor(const BaseIterator& i) : BaseAdaptor(i) {}

template <typename T>
class BaseImportListIteratorAdaptor
{
public:
   // Use concepts instead of the static_assert on C++20
   static_assert(std::is_base_of_v<BaseImport, T>);
   using BaseIterator = BaseImportList::const_iterator;

   BaseImportListIteratorAdaptor() = default;
   BaseImportListIteratorAdaptor(const BaseIterator& i) : m_baseIterator(i) {}

   T* operator*() const { return static_cast<T*>(*m_baseIterator); }

   bool operator == (const BaseImportListIteratorAdaptor& rhs) const  { return m_baseIterator == rhs.m_baseIterator; }
   bool operator != (const BaseImportListIteratorAdaptor& rhs) const { return !(*this == rhs); }

   BaseImportListIteratorAdaptor& operator++() { ++m_baseIterator; return *this; }
   BaseImportListIteratorAdaptor operator++(int) { return m_baseIterator++; }

private:
   BaseIterator m_baseIterator;
};

#include <vector>
#include <iostream>
#include <memory>
#include <type_traits>
#include <utility>

template <typename BaseIterator>
class IndirectIterator
{
public:

   using TargetType = decltype(**std::declval<BaseIterator>());

   IndirectIterator() = default;
   IndirectIterator(const BaseIterator& i) : m_baseIterator(i) {}

   TargetType operator*() const { return **m_baseIterator; }

   bool operator == (const IndirectIterator& rhs) const { return m_baseIterator == rhs.m_baseIterator; }
   bool operator != (const IndirectIterator& rhs) const { return !(*this == rhs); }

   IndirectIterator& operator++() { ++m_baseIterator; return *this; }
   IndirectIterator operator++(int) { return m_baseIterator++; }

private:
   BaseIterator m_baseIterator;
};


template <typename BaseIterator, typename TargetType>
class StaticCastIterator
{
public:

   StaticCastIterator() = default;
   StaticCastIterator(const BaseIterator& i) : m_baseIterator(i) {}

   TargetType operator*() const { return static_cast<TargetType>(*m_baseIterator); }

   bool operator == (const StaticCastIterator& rhs) const { return m_baseIterator == rhs.m_baseIterator; }
   bool operator != (const StaticCastIterator& rhs) const { return !(*this == rhs); }

   StaticCastIterator& operator++() { ++m_baseIterator; return *this; }
   StaticCastIterator operator++(int) { return m_baseIterator++; }

private:
   BaseIterator m_baseIterator;
};


template <typename T>
class BaseList
{
   using Items_ = std::vector<std::unique_ptr<T>>;
public:

   using iterator = IndirectIterator<typename Items_::iterator>;
   using const_iterator = IndirectIterator<typename Items_::const_iterator>;

   iterator begin() { return items_.begin(); }
   iterator end() { return items_.end(); }

   const_iterator begin() const { return items_.begin(); }
   const_iterator end() const { return items_.end(); }

protected:
   Items_ items_;
};

class BaseImport {};

template <typename T>
class ImportList : public BaseList<BaseImport>
{
public:

   // Use concepts instead of the static_assert on C++20
   static_assert(std::is_base_of_v<BaseImport, T>);

   using BaseList = BaseList<BaseImport>;
   using iterator = StaticCastIterator<typename BaseList::iterator, T&>;
   using const_iterator = StaticCastIterator<typename BaseList::const_iterator, const T&>;

   iterator begin() { return BaseList::begin(); }
   iterator end() { return BaseList::end(); }

   const_iterator begin() const { return BaseList::begin(); }
   const_iterator end() const { return BaseList::end(); }

   template <typename... CreationParams>
   void CreateItem(CreationParams&&... params) {
      BaseList::items_.emplace_back(std::make_unique<T>(std::forward<CreationParams>(params)...));
   }
};

struct MacImport : BaseImport
{
   int id{};
   std::string name;

   MacImport(int id, const std::string& name) : id(id), name(name){}
};

int main()
{
   using MacImportList = ImportList<MacImport>;

   MacImportList l;

   l.CreateItem(101, "Mac Item 101");
   l.CreateItem(102, "Mac Item 102");
   l.CreateItem(103, "Mac Item 103");

   for (const MacImport& item : l)
   {
      std::cout << "[" << item.id << "]: " << item.name << std::endl;
   }
}

[101]: Mac Item 101
[102]: Mac Item 102
[103]: Mac Item 103