Question

I’m wondering about one thing. I’ve got class which has 1 overloaded member function:

class A{
    public:
    class const_iterator{};
    class iterator : public const_iterator{};
    iterator find(const K &key);
    const_iterator find(const K &key) const;
};

Ad. iterator is inheriting from const_iterator, but it isn’t adding anything.

What I want to do is, inside normal find call const find. Something like this:

typename A::iterator A::find(const K &key){
     const_iterator it(find(key));
     return (*(iterator*)&it);
}

I don’t need different implementation of non-const find ATM. Is it possible to do something like this? Because now I’m getting into infinite loop, adding “A::” before find isn’t changing anything.

Answer 1

In general, there’s no clean solution for this, unfortunately.

You can call the overloaded find by simply casting this to A const* – but the result will be of the wrong type (const_iterator rather than iterator) and there may not be a conversion between these in the general case (your (*(iterator*)&it) won’t work in your case).

But of course, in your special case, since you defined the two classes, you can define such a conversion by adding an appropriate constructor to iterator:

class iterator : public const_iterator {
    iterator(const_iterator const& other) { 
        // Construct …
    }
};

Then you can re-write your non-const find implementation as follows:

A::iterator A::find(const int &key){
    const_iterator it(const_cast<A const*>(this)->find(key));
    return static_cast<iterator>(it);
}

Incidentally, note the absence of typename in the return type. Since A::iterator isn’t a dependent name, you don’t need (and, at least in C++03, are not allowed to) use typename here.