g++ [flags ...] file ...

#include <SingleLinkedList.h>

SingleLinkedList(ALLOCATION alloc_d = DEF_ALLOCATION) ;
boolean insert(TObject* item, boolean insert_before);
boolean insertFirst(TObject* item);
boolean removeLast();
const TObject* getNext() const;
boolean apply(boolean (TObject::*method)());

// declare a character list and add two characters into it
//
SingleLinkedList<Char> list;
Char item0(L'a');
Char item1(L'b');
list.insertFirst(&item0);
list.insert(&item1);

// get the last character
//
list.gotoLast();
Char* item2 = list.getCurr();
if (item2->ne(item1)) {
   // error
}

T. Budd, Data Structures in C++ using the Standard Template Library, Addison Wesley, Reading, Massachusetts, USA, pp. 185-216, 1998.

• This example shows the basic operation of a SingleLinkedList

  #include <SingleLinkedList.h>
  #include <Char.h>
  
  int main() {
  
    // local variables
    //
    SingleLinkedList<Long> s;
    Long j;
  
    // add 10 items to the SingleLinkedList    
    //
    for (long i = 0; i< 10; i++) {
      j = i * 3;
      s.insert(&j);
    }
  
    // see what is on the SingleLinkedList
    //
    s.debug(L"after insertion");
         
    // get the elements and print them
    //
    s.gotoFirst();     
    Long* l = s.getFirst();
    l->debug(L"item from the List");
    
    while((l= s.getNext())!=NULL) {
      s.gotoNext();
      l->debug(L"item from the List");      
    }
  
    // exit gracefully
    //     
    Integral::exit();
  }

• This example shows the basic operation of a SingleLinkedList in USER mode. Note that memory is manually allocated before inserting it to the List and deleted later.

  #include <SingleLinkedList.h>
  #include <Char.h>
  
  int main() {
  
    // local variables
    //
    SingleLinkedList<Long> s(USER);
    Long* j;
  
    // add 10 items to the SingleLinkedList    
    //
    for (long i = 0; i< 10; i++) {
      j = new Long(i * 3);
      s.insert(j);
    }
  
    // see what is on the SingleLinkedList
    //
    s.debug(L"after insertion");
  
    // get the elements and print them
    //
    s.gotoFirst();     
    Long* l = s.getFirst();
    l->debug(L"item from the List");
    delete l;
    
    while((l=s.getNext())!=NULL) {
      s.gotoNext();
      l->debug(L"item from the List");      
      delete l;
    }
  
    // exit gracefully
    //     
    Integral::exit();
  }

• This example shows how to check if SingleLinkedLists are equal

  #include <SingleLinkedList.h>
  #include <Char.h>
  
  int main() {
  
    // prepare items for the list
    //
    Char** items = new Char*[10];
    
    // declare a SYSTEM-allocating SingleLinkedList and add items into it
    //
    SingleLinkedList<Char> char_list;
    
    for (long i = 0; i < 10; i++) {
      items[i] = new Char((unichar)((long)'a' + i));
      
      // insert the items to the list
      //
      char_list.insert(items[i]);
      
    }
      
    // copy the SingleLinkedList
    //
    SingleLinkedList<Char> char_copy_list(char_list);
    
    // declare a third list that is SYSTEM-allocating, and has the same items
    //
    SingleLinkedList<Char>* system_char_list = new SingleLinkedList<Char>();
    system_char_list->assign(char_list);
    
    // see if these SingleLinkedLists are equivalent
    //
    if(!char_list.eq(char_copy_list) || !system_char_list->eq(char_list)) {
  
      // exit with error
      //
      Integral::exit();
    }
  
    // clean up the memory used
    //
    delete system_char_list;
    delete [] items; 
    
    // exit gracefully
    //
    Integral::exit();
  }
         

• There are two memory allocation modes for SingleLinkedList as indicated by the protected member data, alloc_d. The default allocation mode is SYSTEM. If alloc_d is set to SYSTEM, the list handles allocation and deletion of the objects. When the user puts an object into the list, a copy of the object is made and inserted into the list via local memory allocation - note that this requires a call to the copy constructor so the user will experience an efficiency decrease. When the object is removed from the list, the object is automatically deleted.
  
  
• If alloc_d is set to USER, the user is required to handle all memory allocation and deletion. When the user adds an object to the list, the object passed in is stored in the list by pointer reference. when an object is removed, the user is required to accept a pointer to the object.
  
  
• Unlike other classes, we have two read and write methods in dstr classes. The interface is still the same as that in other classes. The reason behind this is that we can not use "CLASS_NAME" as default argument in the read and write methods here because the data structures build the class name on the fly.