inheritance problem

[stdeez]

this is my list.h (an ex. im following in my book)

template<typename type>
class list {

private:
    struct node{
    type data;
    node *previous;
    node *next;
};
    
public:
    class const_iterator{};
    class iterator : public const_iterator{};
    
public:
    list(){}
    list(const list & rhs){}
    ~list(){}
    const list & operator=(const list & rhs){}
    
    iterator begin(){
        return iterator(head->next);
    }
    
    const_iterator begin(){
        return const_iterator(head->next);
    }
    
    iterator end(){
        return iterator(tail);
    }
    
    const_iterator end() const{
        return const_iterator(tail);
    }
    
    int size() const{
        return theSize;
    }
    
    bool empty() const{
        return size()==0;
    }
    
    void clear(){
        while (!empty())
            pop_front();
    }
    
    type & front(){
        return *begin();
    }
    
    const type & front() const{
        return *begin();
    }
    
    type & back(){
        return *--end();
    }
    
    const type & back() const{
        return *--end();
    }
    
    void push_front(const type & x){
        insert(begin(), x);
    }
    
    void push_back(const type & x){
        insert( end(), x);
    }
    
    void pop_front(){
        erase(begin());
    }
    
    void pop_back(){
        erase(end());
    }
    
    iterator insert(iterator itr, const type & x){}
    iterator erase(iterator itr){}
    
private:
    int theSize;
    node *head;
    node *tail;
    
    void init(){}
    
};

this is my implementation that will not identify "type". it isnt finished just no use in continuing if i cant see the problem with that.

#include "List.h"

class const_iterator{
public:
    const_iterator() : current(NULL){}
    
    const type & operator*()const{
        return retrieve();
    }
    
};

i know the list.h is templated but the functions arent (this is the way its done in the book) are they just stupid for writing it this way or do they assume that i should know this and change it all. like they are talking about it like this is a functioning implementation when it isnt.