Inheritance and nested class - c++

Question

I'm trying to implement different versions of a data structure. Suppose it has an interface shown below (it's simplified):
template <typename T>
class Base {
public:
class Iterator {
virtual auto operator*() -> T& = 0;
};
public:
virtual auto Find(const T& value) -> Iterator = 0;
}
Now I want to inherit a class that will implement it:
template <typename T>
class Derived : public Base<T> {
public:
class Iterator {
auto operator*() -> T& override {
/* ... */
}
};
public:
auto Find(const T& value) -> Iterator override {
/* ... */
};
}
Problem is that I need to implement Iterator based on what Derived does, but Find function's signature brakes because of Derived::Iterator (it should be Base::Iterator). Is there a way to do so or do I have to give up on using interface class?

Answer 1

From what I understand, what you are trying to achieve is related to type erasure or maybe static polymorphism. You want Base::Iterator to be a non-abstract generalized type, that can be constructed from any Derived implementation.
This is a dynamic solution that you can optimize based on your needs
template<typename T>
struct Base
{
// This is the interface that needs to be implemented by the derrived classe's iterator
struct IIterator
{
virtual T& Get() = 0;
};
// this is the generalized type that needs to be returned by find()
struct Iterator
{
Iterator(std::unique_ptr<IIterator> impl ):
_impl(std::move(impl))
{
}
T& operator*() { _impl->Get(); }
private:
// You can implement small struct optimization by making a byte array big enough
// to store any of the implementations and avoid dynamic memory
std::unique_ptr<IIterator> _impl;
};
virtual Iterator find() = 0;
};
template<typename T>
struct Derived : public Base<T>
{
// Now in derived we implement our iterator
struct IteratorImpl : Base<T>::IIterator
{
IteratorImpl(T* p) : ptr(p) {}
T& Get() override { return *ptr; }
T* ptr;
};
typename Base<T>::Iterator find() override
{
IteratorImpl result(nullptr);
// After finding we need to construct the generalized type from the implementation
return typename Base<T>::Iterator(std::make_unique<IteratorImpl>( result ));
}
};
Another way to do something like that is by using templates and CRTP to make a static interface. CRTP is a technique that involves passing the derived type information back to the base class using it's template arguments and using that information to define or find an implementation for the Base iterator based on the derived type.