Thread: help with nodeType function?

for some reason when i try to implement this function it says my list is not declared???

node *find (string address) const;
// precondition : none
// postcondition : returns a pointer to node containing address or
// NULL if not present
my list(the node)is already declared in the private part of the class header file but when i try to do anything with list it says its not declared? could anyone give me a pointer please? thank you

ok heres the header file

Code:

--------------------------------------------------------------------------------------------------
#ifndef IPLIST
#define IPLIST

#include <iostream>
#include <cstdlib>
using namespace std;

struct node
{
   string IPaddress;
   int count;
   node *link;
};

class IPlist
{
   // contains an ordered list of IP addresses and a count of each
   // occurrence
   public:

    IPlist();  // default constructor
               // creates a new empty list

    ~IPlist(); // destructor - reallocates all dynamic memory of list

    IPlist (const IPlist & other);
               // copy constructor to create a deep copy of other IPlist
               // object

    bool empty() const; 
               // precondition : none
               // postcondition : returns true if list is empty 
               //                 and otherwise false

    void insertInOrder(string address);
               // precondition : list is ordered and address is not in list
               // postcondition : list is ordered and contains address

    bool isPresent(string address) const;
               // precondition : none
               // postcondition : returns true if a node containing address
               //                is present in list and otherwise false

    void updateCount(string address);
               // precondition : address is in list
               // postcondition : the count of node with address has been incremented

    node *find (string address) const;
               // precondition : none
               // postcondition : returns a pointer to node containing address or
               //                 NULL if not present

    void display() const; 
               // precondition : none
               // postcondition : the list has been displayed 
               // one record per line, tab-separated
               // with heading IPaddress Count
    private:
    
       node *list;
};
#endif
-------------------------------------------------------------------------------------------

this is what i tried to do to implement it:


  node IPlist::*find (string address) const
               // precondition : none
               // postcondition : returns a pointer to node containing address or
               //                 NULL if not present
               
 131             {
  132                node *current=list;
   133                   if(current==address)
                      {//checks 1st node
                          //current=list->IPaddress;
   136                       return current;
                      }
                      else 
                      {//increments to the next node
                          return NULL;                         
                      }
                  
               }

several errors are then given.......-_-

131 C:\Documents and Settings\IPlist.cpp non-member function `node IPlist::* find(std::string)' cannot have `const' method qualifier
132 C:\Documents and Settings\IPlist.cpp `list' undeclared (first use this function)
133 C:\Documents and Settings\IPlist.cpp no match for 'operator==' in 'current == address'
136 C:\Documents and Settings\IPlist.cpp cannot convert `node*' to `node IPlist::*' in return

how to implement this function -_-

i just added a "IPlist::" to what was declared in the header file? did i do it wrong?

lol.....all the errors just disappered except for the

133 C:\Documents and Settings\IPlist.cpp no match for 'operator==' in 'current == address'

135 C:\Documents and Settings\IPlist.cpp could not convert `((std::string*)current)->std::basic_string<_CharT, _Traits, _Alloc>:perator= [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>](((const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)((const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*)(&address))))' to `bool'

after changing current to current->IPaddress, getting more and more confused

Code:

 node *IPlist::find (string address) const
               // precondition : none
               // postcondition : returns a pointer to node containing address or
               //                 NULL if not present
               
              {
                  node *current=list;
                  while (current!=NULL)
                  {
                      if(current->IPaddress = address)
                      {//checks 1st node
                          return current;
                      }
                      else 
                      {//increments to the next node
                          current=current->link;
                      }
                  }
                  return NULL;
               }

this gives error:
135 C:\Documents and Settings\IPlist.cpp could not convert `((std::string*)current)->std::basic_string<_CharT, _Traits, _Alloc>erator= [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>](((const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)((const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*)(&address))))' to `bool'

oops lol
it works fine now thx a lot for you help Salem~!

this is my current code

Code:

#include <iostream>
#include <cstdlib>


using namespace std;
#include "IPlist.h"


    IPlist::IPlist()
    // default constructor
    // creates a new empty list
{
    list=NULL;
}

    IPlist::~IPlist() 
    // destructor - reallocates all dynamic memory of list
{
    delete [] list;
}

    IPlist::IPlist (const IPlist & other)
               // copy constructor to create a deep copy of other IPlist
               // object
{
   if (other.list==NULL)
   {
      list = NULL;
   }
   else
   {
      // copy the first node
      node *current = other.list;
      list = new node;
      list->IPaddress = current->IPaddress;
      list->link = NULL;
      current = current->link;
      node *pt = list;
      // copy the rest of list
      while (current != NULL)
      {
          pt->link = new node;
          pt = pt->link;
          pt->IPaddress = current->IPaddress;
          pt->link = NULL;
          current = current->link;
      } 
   } 
}

    bool IPlist::empty() const 
    // precondition : none
    // postcondition : returns true if list is empty 
    //                 and otherwise false
{
         return list==NULL;
}
               

    void IPlist::insertInOrder(string address)
               // precondition : list is ordered and address is not in list
               // postcondition : list is ordered and contains address
               {
                  while(list!=NULL)
                  {
                    node* current=new node;
                    //temp->IPaddress=address;
                     //node *smaller=list;               
                    
                    if (list->IPaddress < address )
                    {
                        current->IPaddress =address;
                        current->link =list->link;
                        list->link = current;
                        list=current->link;                        
                    }
                    else
                    {
                        list=list->link;
                    }
                  }
               }
    bool IPlist::isPresent(string address) const
               // precondition : none
               // postcondition : returns true if a node containing address
               //                is present in list and otherwise false
{
              node *current=list; 
              while(current!=NULL)
              {
                 if (current->IPaddress==address)
                 {
                    return true;
                 }
                 else
                 {
                    current=current->link;
                 }
              }      
              return false;
}

    void IPlist::updateCount(string address)
               // precondition : address is in list
               // postcondition : the count of node with address has been incremented
{
               int count=0;
               node *current=list;
               while (current!=NULL)
               {
                     if (current->IPaddress==address)
                     {
                        current->count=count+1;
                     }               
                     else
                     {   
                        current=current->link;
                     }
               }
}
    node *IPlist::find (string address) const
               // precondition : none
               // postcondition : returns a pointer to node containing address or
               //                 NULL if not present
               
              {
                  node *current=list;
                  while (current!=NULL)
                  {
                      if(current->IPaddress == address)
                      {//checks 1st node
                          return current;
                      }
                      else 
                      {//increments to the next node
                          current=current->link;
                      }
                  }
                  return NULL;
               }

    void IPlist::display() const
               // precondition : none
               // postcondition : the list has been displayed 
               // one record per line, tab-separated
               // with heading IPaddress Count
{
               node *current=list;
               while(current!=NULL)
               {
                   cout<<"IPaddress   Count "<<endl;
                   cout<<current<<"   "<<current->count<<endl;
                   current=current->link;
               }
}               

and my main...


#include <iostream>
#include <cstdlib>
using namespace std;

#include "IPlist.h"
void testCopyConstructor(IPlist x);
int main()
{
    IPlist ip;
   if (ip.empty())
    {
      cout << "empty works" << endl;
    }
      
     string data[]={"a","b","c","a","b","c","a","d"};
  
    // some strings to insert into IPlist for testing
    // they don't really need to be IP addresses    
    for (int i = 0; i < 8; i++)
    {
       if (!ip.isPresent(data[i]))
          ip.insertInOrder(data[i]);
       else
          ip.updateCount(data[i]);
    }
    ip.display();
    cout << endl;
    node *current = ip.find("d");
    if (current != NULL)
       cout << "found "<< current->IPaddress << endl;
    system("pause");
    return EXIT_SUCCESS;
}

void testCopyConstructor(IPlist x)
{
// copy constructor will be automatically called when pass by value
// if we have written a correct copy constructor to make a deep copy
// then changing x will not change the corresponding argument
// (in this case ip in the main program)
      x.insertInOrder("w");
      x.insertInOrder("x");
}

im getting no output when i compile,its just giving me an empty list what error am i making?

could anyone help me to fix my problem?
how to insert data with the insertinorder if the list is empty?