CAN ANY ONE TELLL ME WHY THIS CODE IS THROWING ERRORS

[naren26051991]

#ifndef LIST_H
#define LIST_H

#include <stdlib.h>

template <typename Object>
class List
{
private:
// The basic doubly linked list node.
// Nested inside of List, can be public
// because the Node is itself private
struct Node
{
Object data;
Node *prev;
Node *next;

Node( const Object & d = Object( ), Node * p = NULL, Node * n = NULL )
: data( d ), prev( p ), next( n ) { }
};

public:
class const_iterator
{
public:

// Public constructor for const_iterator.
const_iterator( ) : current( NULL )
{ }

// Return the object stored at the current position.
// For const_iterator, this is an accessor with a
// const reference return type.
const Object & operator* ( ) const
{ return retrieve( ); }

const_iterator & operator++ ( )
{
current = current->next;
return *this;
}

const_iterator operator++ ( int )
{
const_iterator old = *this;
++( *this );
return old;
}

const_iterator & operator-- ( )
{
current = current->prev;
return *this;
}

const_iterator operator-- ( int )
{
const_iterator old = *this;
--( *this );
return old;
}

bool operator== ( const const_iterator & rhs ) const
{ return current == rhs.current; }

bool operator!= ( const const_iterator & rhs ) const
{ return !( *this == rhs ); }

protected:
Node *current;

// Protected helper in const_iterator that returns the object
// stored at the current position. Can be called by all
// three versions of operator* without any type conversions.
Object & retrieve( ) const
{ return current->data; }

// Protected constructor for const_iterator.
// Expects a pointer that represents the current position.
const_iterator( Node *p ) : current( p )
{ }

friend class List<Object>;
};

class iterator : public const_iterator
{
public:

// Public constructor for iterator.
// Calls the base-class constructor.
// Must be provided because the private constructor
// is written; otherwise zero-parameter constructor
// would be disabled.
iterator( )
{ }

Object & operator* ( )
{ return retrieve( ); }

// Return the object stored at the current position.
// For iterator, there is an accessor with a
// const reference return type and a mutator with
// a reference return type. The accessor is shown first.
const Object & operator* ( ) const
{ return const_iterator::operator*( ); }

iterator & operator++ ( )
{
current = current->next;
return *this;
}

iterator operator++ ( int )
{
iterator old = *this;
++( *this );
return old;
}

iterator & operator-- ( )
{
current = current->prev;
return *this;
}

iterator operator-- ( int )
{
iterator old = *this;
--( *this );
return old;
}

protected:
// Protected constructor for iterator.
// Expects the current position.
iterator( Node *p ) : const_iterator( p )
{ }

friend class List<Object>;
};

public:
List( )
{ init( ); }

~List( )
{
clear( );
delete head;
delete tail;
}

List( const List & rhs )
{
init( );
*this = rhs;
}

const List & operator= ( const List & rhs )
{
if( this == &rhs )
return *this;
clear( );
for( const_iterator itr = rhs.begin( ); itr != rhs.end( ); ++itr )
push_back( *itr );
return *this;
}

// Return iterator representing beginning of list.
// Mutator version is first, then accessor version.
iterator begin( )
{ return iterator( head->next ); }

const_iterator begin( ) const
{ return const_iterator( head->next ); }

// Return iterator representing endmarker of list.
// Mutator version is first, then accessor version.
iterator end( )
{ return iterator( tail ); }

const_iterator end( ) const
{ return const_iterator( tail ); }

// Return number of elements currently in the list.
int size( ) const
{ return theSize; }

// Return true if the list is empty, false otherwise.
bool empty( ) const
{ return size( ) == 0; }

void clear( )
{
while( !empty( ) )
pop_front( );
}

// front, back, push_front, push_back, pop_front, and pop_back
// are the basic double-ended queue operations.
Object & front( )
{ return *begin( ); }

const Object & front( ) const
{ return *begin( ); }

Object & back( )
{ return *--end( ); }

const Object & back( ) const
{ return *--end( ); }

void push_front( const Object & x )
{ insert( begin( ), x ); }

void push_back( const Object & x )
{ insert( end( ), x ); }

void pop_front( )
{ erase( begin( ) ); }

void pop_back( )
{ erase( --end( ) ); }

// Insert x before itr.
iterator insert( iterator itr, const Object & x )
{
Node *p = itr.current;
theSize++;
return iterator( p->prev = p->prev->next = new Node( x, p->prev, p ) );
}

// Erase item at itr.
iterator erase( iterator itr )
{
Node *p = itr.current;
iterator retVal( p->next );
p->prev->next = p->next;
p->next->prev = p->prev;
delete p;
theSize--;

return retVal;
}

iterator erase( iterator start, iterator end )
{
for( iterator itr = start; itr != end; )
itr = erase( itr );

return end;
}

private:
int theSize;
Node *head;
Node *tail;

void init( )
{
theSize = 0;
head = new Node;
tail = new Node;
head->next = tail;
tail->prev = head;
}
};

#endif

[Peter87]

Please put your code in code tags so that the code formatting stays intact.

What errors do you get?

[naren26051991]

these are errors

||=== linked, Debug ===|
C:\Users\NARENDRA\Desktop\pointers lab\linked\List.h||In member function 'Object& List<Object>::iterator::operator*()':|
C:\Users\NARENDRA\Desktop\pointers lab\linked\List.h|100|error: there are no arguments to 'retrieve' that depend on a template parameter, so a declaration of 'retrieve' must be available|
C:\Users\NARENDRA\Desktop\pointers lab\linked\List.h|100|note: (if you use '-fpermissive', G++ will accept your code, but allowing the use of an undeclared name is deprecated)|
C:\Users\NARENDRA\Desktop\pointers lab\linked\List.h||In member function 'List<Object>::iterator& List<Object>::iterator::operator++()':|
C:\Users\NARENDRA\Desktop\pointers lab\linked\List.h|111|error: 'current' was not declared in this scope|
C:\Users\NARENDRA\Desktop\pointers lab\linked\List.h||In member function 'List<Object>::iterator& List<Object>::iterator::operator--()':|
C:\Users\NARENDRA\Desktop\pointers lab\linked\List.h|124|error: 'current' was not declared in this scope|
||=== Build finished: 3 errors, 0 warnings ===|

[naren26051991]

#ifndef LIST_H
#define LIST_H

#include <stdlib.h>

template <typename Object>
class List
{
  private:    
    // The basic doubly linked list node.
    // Nested inside of List, can be public
    // because the Node is itself private
    struct Node
    {
        Object  data;
        Node   *prev;
        Node   *next;

        Node( const Object & d = Object( ), Node * p = NULL, Node * n = NULL )
          : data( d ), prev( p ), next( n ) { }
    };

  public:
    class const_iterator
    {
      public:
  
        // Public constructor for const_iterator.
        const_iterator( ) : current( NULL )
          { }

        // Return the object stored at the current position.
        // For const_iterator, this is an accessor with a
        // const reference return type.
        const Object & operator* ( ) const
          { return retrieve( ); }
        
        const_iterator & operator++ ( )
        {
            current = current->next;
            return *this;
        }

        const_iterator operator++ ( int )
        {
            const_iterator old = *this;
            ++( *this );
            return old;
        }

        const_iterator & operator-- ( )
        {
            current = current->prev;
            return *this;
        }

        const_iterator operator-- ( int )
        {
            const_iterator old = *this;
            --( *this );
            return old;
        }
            
        bool operator== ( const const_iterator & rhs ) const
          { return current == rhs.current; }

        bool operator!= ( const const_iterator & rhs ) const
          { return !( *this == rhs ); }

      protected:
        Node *current;

        // Protected helper in const_iterator that returns the object
        // stored at the current position. Can be called by all
        // three versions of operator* without any type conversions.
        Object & retrieve( ) const
          { return current->data; }

        // Protected constructor for const_iterator.
        // Expects a pointer that represents the current position.
        const_iterator( Node *p ) :  current( p )
          { }
        
        friend class List<Object>;
    };

    class iterator : public const_iterator
    {
      public:

        // Public constructor for iterator.
        // Calls the base-class constructor.
        // Must be provided because the private constructor
        // is written; otherwise zero-parameter constructor
        // would be disabled.
        iterator( )
          { }

        Object & operator* ( )
          { return retrieve( ); }

        // Return the object stored at the current position.
        // For iterator, there is an accessor with a
        // const reference return type and a mutator with
        // a reference return type. The accessor is shown first.
        const Object & operator* ( ) const
          { return const_iterator::operator*( ); }
        
        iterator & operator++ ( )
        {
            current = current->next;
            return *this;
        }

        iterator operator++ ( int )
        {
            iterator old = *this;
            ++( *this );
            return old;
        }

        iterator & operator-- ( )
        {
            current = current->prev;
            return *this;
        }

        iterator operator-- ( int )
        {
            iterator old = *this;
            --( *this );
            return old;
        }

      protected:
        // Protected constructor for iterator.
        // Expects the current position.
        iterator( Node *p ) : const_iterator( p )
          { }

        friend class List<Object>;
    };

  public:
    List( )
      { init( ); }

    ~List( )
    {
        clear( );
        delete head;
        delete tail;
    }

    List( const List & rhs )
    {
        init( );
        *this = rhs;
    }

    const List & operator= ( const List & rhs )
    {
        if( this == &rhs )
            return *this;
        clear( );
        for( const_iterator itr = rhs.begin( ); itr != rhs.end( ); ++itr )
            push_back( *itr );
        return *this;
    }

    // Return iterator representing beginning of list.
    // Mutator version is first, then accessor version.
    iterator begin( )
      { return iterator( head->next ); }

    const_iterator begin( ) const
      { return const_iterator( head->next ); }

    // Return iterator representing endmarker of list.
    // Mutator version is first, then accessor version.
    iterator end( )
      { return iterator( tail ); }

    const_iterator end( ) const
      { return const_iterator( tail ); }

    // Return number of elements currently in the list.
    int size( ) const
      { return theSize; }

    // Return true if the list is empty, false otherwise.
    bool empty( ) const
      { return size( ) == 0; }

    void clear( )
    {
        while( !empty( ) )
            pop_front( );
    }
 
    // front, back, push_front, push_back, pop_front, and pop_back
    // are the basic double-ended queue operations.
    Object & front( )
      { return *begin( ); }

    const Object & front( ) const
      { return *begin( ); }

    Object & back( )
      { return *--end( ); }

    const Object & back( ) const
      { return *--end( ); }

    void push_front( const Object & x )
      { insert( begin( ), x ); }

    void push_back( const Object & x )
      { insert( end( ), x ); }

    void pop_front( )
      { erase( begin( ) ); }

    void pop_back( )
      { erase( --end( ) ); }

    // Insert x before itr.
    iterator insert( iterator itr, const Object & x )
    {
        Node *p = itr.current;
        theSize++;
        return iterator( p->prev = p->prev->next = new Node( x, p->prev, p ) );
    }

    // Erase item at itr.
    iterator erase( iterator itr )
    {
        Node *p = itr.current;
        iterator retVal( p->next );
        p->prev->next = p->next;
        p->next->prev = p->prev;
        delete p;
        theSize--;

        return retVal;
    }

    iterator erase( iterator start, iterator end )
    {
        for( iterator itr = start; itr != end; )
            itr = erase( itr );

        return end;
    }

  private:
    int   theSize;
    Node *head;
    Node *tail;

    void init( )
    {
        theSize = 0;
        head = new Node;
        tail = new Node;
        head->next = tail;
        tail->prev = head;
    }
};

#endif

[Peter87]

The problem is when you mix templates and inheritance you will have to be more explicit. In iterator's function write this->current and this->retrieve().

[viliml]

Peter87 pretty much explained everything. Only one complaint: don't use CAPS! It makes people think you are SHOUTING, which is RUDE!(I used caps just to show you the point)

[naren26051991]

so can u gimme the solution to resolve it pete

[o3hC5Di1]

Hi there,

Peter actually gave you the solution.
Change every occurrence of current into this->current[code] and do the same for [code]retrieve().

Example:

//line 122
iterator & operator-- ( )
{
        this->current = this->current->prev;
        return *this;
}

As a small kindly sidenote:

forum rules wrote:

Don't TYPE IN ALL CAPS; this is read as shouting and considered rude.

If you write like a semi-literate boob you will very likely be ignored. So don't use instant-messaging shortcuts.

Hope that helps.

All the best,
NwN