Question

I have a code that has the following logic. g++ gives me the error that I have not declared n in my iterator2. What could be wrong?

template <typename T> class List{
    template <typename TT> class Node;
    Node<T> *head;
    /* (...) */
    template <bool D> class iterator1{
        protected: Node<T> n;
        public: iterator1( Node<T> *nn ) { n = nn }
        /* (...) */
    };
    template <bool D> class iterator2 : public iterator1<D>{
        public:
        iterator2( Node<T> *nn ) : iterator1<D>( nn ) {}
        void fun( Node<T> *nn ) { n = nn; }
        /* (...) */
    };
};

EDIT :

I attach the actual header file. iterator1 would be iterable_frame and iterator2 – switchable_frame.

#ifndef LST_H
#define LST_H

template <typename T>
class List {
    public:
    template <typename TT> class Node;
    private:
    Node<T> *head; 
    public:
    List() { head = new Node<T>; }
    ~List() { empty_list(); delete head; }
    List( const List &l );

    inline bool is_empty() const { return head->next[0] == head; }
    void empty_list();

    template <bool DIM> class iterable_frame {
        protected:
        Node<T> *head; 
        Node<T> **caret;
        public:
        iterable_frame( const List &l ) { head = *(caret = &l.head); }
        iterable_frame( const iterable_frame &i ) { head = *(caret = i.caret); }
        ~iterable_frame() {}
    /* (...) - a few methods follow */
        template <bool _DIM> friend class supervised_frame;
    };
    template <bool DIM> class switchable_frame : public iterable_frame<DIM> {
        Node<T> *main_head;
        public:
        switchable_frame( const List& l ) : iterable_frame<DIM>(l) { main_head = head;     }
        inline bool next_frame() {
            caret = &head->next[!DIM];
            head = *caret;
            return head != main_head;
        }
    };
    template <bool DIM> class supervised_frame {
        iterable_frame<DIM> sentinels;
        iterable_frame<DIM> cells;
        public:
        supervised_frame( const List &l ) : sentinels(l), cells(l) {}
        ~supervised_frame() {}
    /* (...) - a few methods follow */
    };

    template <typename TT> class Node {
        unsigned index[2];
        TT num;
        Node<TT> *next[2];
        public:
        Node( unsigned x = 0, unsigned y = 0 ) {
            index[0]=x; index[1]=y;
            next[0] = this; next[1] = this;
        }
        Node( unsigned x, unsigned y, TT d ) {
            index[0]=x; index[1]=y;
            num=d;
            next[0] = this; next[1] = this;
        }
        Node( const Node &n ) {
            index[0] = n.index[0]; index[1] = n.index[1];
            num = n.num;
            next[0] = next[1] = this;
        }
        ~Node() {}
        friend class List;
    };
};
#include "List.cpp"

#endif

the exact error log is the following:

In file included from main.cpp:1:
List.h: In member function ‘bool List<T>::switchable_frame<DIM>::next_frame()’:
List.h:77: error: ‘caret’ was not declared in this scope

Answer 1

Proper two-phase name look-up mandates that non-dependent names (i.e., names not depending on a template argument) are looked up in phase 1. At that point the base class members of a templatized base cannot be seen (because a specialization may yield a different layout). The fix is to make the names dependent. Change

n = nn;

to become

this->n = nn;

or, in the expanded example, change

inline bool next_frame() {
    caret = &head->next[!DIM];
    head = *caret;
    return head != main_head;
}

to become

inline bool next_frame() {
    this->caret = &head->next[!DIM];
    head = *this->caret;
    return head != main_head;
}