#include <iostream.h>


template < class T > class number
{
  private:
  T theNumber;
  public:
  number(T n);
  void displayNumber(void);
};

template < class T > number<T>::number(T n)
{
  theNumber = n;
}

template < class T > void number<T>::displayNumber(void)
{
  cout<<"Number #";
  cout<<theNumber<<endl;
}

int main()
{
  number<double> j(10);
  
  return 0;

}

number blah;
blah.theNumber

#include <iostream.h>              // used only once, in showitems() with cout<<
/*  
Programmer:      Regan DeDiana
Date        October 16, 2002
Description:    collection class
implementations:  Additem    -  used to add new items to the list 
          RemoveItem  -  removes an item from the list based on the item value
          RemoveIndex -  removes an item from the list based on the ordinal (index) positon
          Count    -  returns the total amount of items in the list
          Value    -  returns a value determined by the list index
          ShowItems  -  temp method to display list of all nodes data
*/
template <class NTYPE> class col 
{
private:
  NTYPE  data;                // data that can be stored 
  long  item_count;              // contians the node count for the list
  col    *next;                // Next - represents next node in list  
  col    *tail;                // tail - represents the last node in the list 
public:
  col()  {next = NULL;data = 0;tail = NULL;}  // constructor 
  void  AddItem(NTYPE value);        // used to add new item to list
  void  ShowItems();            // (temp) show list contents
  bool  RemoveItem(NTYPE);          // remove node by item value
  bool  RemoveIndex(long);          // remove node by list position
  long  Count(){return item_count;}      // return the count of nodes in list
  NTYPE  Item(long);              // return at value from the list based 
                        // on list position
};
template <class NTYPE>
NTYPE col<NTYPE>::Item(long index)
{
  /*
    +--------------------------- process -----------------------------------+
    + o check if index value is lareger the total nodes in list        +
    +    1. if True, return null                      +
    +    2. if False, search for node                  +
    + o  traverse list until desired node is located  (located by index    +
    +    position)                            +
    + o  return value                            +
    +-----------------------------------------------------------------------+
  */
  if(index <= item_count)
  {
    
    col *item;    // used to search list
    item = this->next;
    for(long x = 0; x <index ; ++x)
    {
      item = item->next;
    }
    return item->data;
  }
  return NULL;
}
template<class NTYPE>
void col<NTYPE>::AddItem(NTYPE value)
{
  /*
    +--------------------------- process -----------------------------------+
    + o  check if new node will be first in list (if this->next is NULL)    +
    +    if first set root->next node to new node            +
    + o  check if tail node is NULL: if tail node is null we are adding the  +
    +    the first node to the list                    +
    + o  if node isn't the first node in list then modify tail:        +
    +    1. point old tail's ->next to new node              +
    +    2. set new node as tail                      +
    + o  Increment node count                        +
    +-----------------------------------------------------------------------+
  */
  // create new node and assign value
  col *n_item;
  n_item = new col;
  n_item->data = value;

  if(this->next == NULL)    // root (this) always points to first node in list
  {  
    // this only occurs when the first node is added to the list
    this->next = n_item;  // point root node to the first node in list 
    item_count = 0;      // set up our item counter
  }
  if(tail == NULL)
  {
    tail = n_item;      // if tail is NULL then this node 
  }              // represents the first node added
  else
  {
    tail->next = n_item;  // set old tail node to point to new tail
    tail = n_item;      // set new node as tail
  }
  item_count++;  
  
//  return n_item;        // return newly added node
}
template<class NTYPE>
bool col<NTYPE>::RemoveItem(NTYPE value)
{
  /*
    +--------------------------- process -----------------------------------+
    + o  traverse list until node previous of removal node is located    +
    + o  set corpse to node we will remove                  +
    + o  set previous node (traverse) of corpse to point to node after corpse+
    + o  release corpse node memory reservation                +
    +-----------------------------------------------------------------------+
  */
  col *traverse,*corpse;          // Traverse: used to location node
                      // Corpse:   node being deleted
  traverse = this;            // set traverse to beginning of list
  while(traverse->next != NULL)      // locate item in list
  {
    if(traverse->next->data == value)
    {  corpse = traverse->next;    // select node to be removed
      traverse->next = corpse->next;  // remove link to node being removed
      this->item_count--;        // decrement item_count
      delete corpse;          // release memory
      return true;          // return true since node removal succeeded
    }
    traverse = traverse->next;
  }
  // removal failed (value was not located in list
  return false;
}
template<class NTYPE>
bool col<NTYPE>::RemoveIndex(long index)
{
  /*
    +--------------------------- process -----------------------------------+
    + o  traverse list until node previous of removal node is located    +
    + o  set corpse to node we will remove                  +
    + o  set previous node (traverse) of corpse to point to node after corpse+
    + o  release corpse node memory reservation                +
    +-----------------------------------------------------------------------+
  */ 
  if(index <= item_count)
  {
    
    col *traverse,*corpse;      // Traverse: used to location node
                    // Corpse:   node being deleted
    traverse = this;        // set traverse to beginning of list

    // move to correct location in list (index position)
    for(long x = 0; x <index ; ++x)
    {
      traverse = traverse->next;
    }

    corpse = traverse->next;    // select node to be removed
    traverse->next = corpse->next;  // break link so previous node of corpse points
                    //    to node after corpse
    delete corpse;          // release memory
    this->item_count--;        // decrement item_count
    return true;
  }
  return false;
  
}
template<class NTYPE>
void col<NTYPE>::ShowItems()
{
    // This was only added for testing purposes!!!!
    // If items have been added to list, traverse the list until
    // the last item has been encountered (next == NULL)
    int x = 0;
    col *traverse;
    traverse = this->next;
    while(traverse->next != NULL)
    {
      cout<<"Index ("<<x<<") = "<<traverse->data<<endl;
      traverse = traverse->next;
      x++;
    }
    cout<<"Index ("<<x<<") = "<<traverse->data<<endl;
    
}