undefined symbol

[stc5097]

hello,i am creating a program that uses an indexList class and a class designed to store terms (5X^1). The term files work because they were for previous project. With this project, the indexList class uses a pointer variable to store the list of values. I have created my indexList.h file and my indexList.cpp (class declaration) but when i compile all the files together, i get this error:


Undefined first referenced
symbol in file
indexList<term>::indexList(int)
indexList<term>::~indexList()
indexList<term>::retrieve(int, term&)
indexList<term>::replace(int, term)
indexList<term>::search(term) const
std::basic_ostream<char, std::char_traits<char> >& operator<< <term>(std::basic_ostream<char, std::char_traits<char> >&, indexList<term> const&)/var/tmp//ccZrAvOq.o
indexList<term>::remove(int)
indexList<term>::indexList(indexList<term> const&)
indexList<term>::append(term)
indexList<term>::insert(int, term)

I have tried everything i could think of to fix it but nothing works. below is my code for these file. If anybody can help, i will be very great full. Thank you

INDEXLIST.h

//File:  indexList.h
//Author: Joshua Smith
//Ammended by:
//Course:  CSC 136
//Date:    Spring 2012
//Purpose: contains a list of elements accessible by index
#include <iostream>
#pragma once
using namespace std;


#ifndef INDEXLIST_H
#define INDEXLIST_H

template <class T>
class indexList
{
 public:
  //constuctor: sets default size to 10 and numberOfElements to 0
  indexList(int size = 10);

  //copy constructor
  indexList(const indexList<T> &rhs);

  //assignment operator
  indexList<T> &operator=(const indexList<T> &rhs);

  //deconstructor
  ~indexList();

  //append
  //Adds element to the end of the list
  //If array is full, returns false
  bool append(T value);

  //insert
  //Inserts an element at index indx, if indx valid
  //moves values up before inserting
  //If indx is invalid, returns false
  bool insert(int indx, T value);

  //replace
  //Replaces the value at indx if indx is valid
  //IF indx is not value, returns false
  bool replace(int indx, T newValue);


  //retrieve
  //Retrieves the value at index indx, if indx valid
    //If indx is not valid, returns false
  bool retrieve(int indx, T &value) const;

  //remove
  //Removes a value from a specific indx, if indx valid
  //remaining values are moved down
  //IF indx not valid, return false
  bool remove(int indx);

  //search
  //Searchs for the value in the array
  //Returns indx if found, -1 if not found
  int search(T value) const;

  //getSize
  //Returns the number of elements currently in
  //the array
  int getSize() const;

 private:
  T *list;
  int numberOfElements;
  int maxSize;
};
//<< stream operator will write out the entire list
template <class T>
ostream &operator<<(ostream &outStream, const indexList<T> &lst);

//#include "indexList.cpp"
#endif



INDEXLIST.cpp
//File:  indexList.cpp
//Author: Joshua Smith
//Ammeded by:
//Course:  CSC 136
//Date:    Spring 2012
//Purpose: contains a list of elements accessible by index
#include "indexList.h"
#include "term.h"
#include <iostream>
using namespace std;

  //constuctor:
template <class T>
indexList<T>::indexList(int size)
{
      numberOfElements = 0;
      maxSize = size;
      list = new T[size];
}


  //copy contructor
template <class T>
indexList<T>::indexList(const indexList<T> &rhs)
{
  numberOfElements = rhs.numberOfElements;
  maxSize = rhs.maxSize;
  list = new T[maxSize];
  *this = rhs;

}


  //assignment operator
template <class T>
indexList<T>& indexList<T>::operator=(const indexList<T> &rhs)
{
  if(this != &rhs)
    {
      numberOfElements = rhs.numberOfElements;
      maxSize = rhs.maxSize;
      delete list;
      list = new T[maxSize];
      for(int i = 0; i < maxSize; i++)
        {
          list[i] = rhs.list[i];
        }
    }
  return *this;
}


  //destructor
template <class T>
indexList<T>::~indexList()
{
  delete list;
}


  //append
  //Adds element to the end of the list
  //If array is full, returns false
template <class T>
bool indexList<T>::append(T value)
{
  if (maxSize > numberOfElements)
    {
      list[numberOfElements] = value;
      numberOfElements ++;
      return true;
    }
  else
    return false;
}


  //insert
  //Inserts an element at index indx, if indx valid
  //moves values up before inserting
  //If indx is invalid, returns false
template <class T>
bool indexList<T>::insert(int indx, T value)
{
  if (indx >= 0 && indx < numberOfElements && numberOfElements < maxSize)
    {
      for (int i=numberOfElements; i>indx; i--)
        list[i] = list[i-1];
      list[indx] = value;

      numberOfElements ++;
      return true;
    }
  else
    return false;
}

  //replace
  //Replaces the value at indx if indx is valid
  //IF indx is not value, returns false
template <class T>
bool indexList<T>::replace(int indx, T newValue)
{
  if (indx >= 0 && indx <numberOfElements)
    {
      list[indx] = newValue;
      return true;
    }
  else
    return false;
}


  //retrieve
  //Retrieves the value at index indx, if indx valid
  //If indx is not valid, returns false
template <class T>
bool indexList<T>::retrieve(int indx, T &value) const
{
  if (indx >= 0 && indx < numberOfElements)
    {
      value = list[indx];
      return true;
    }
  else
    return false;
}


  //remove
  //Removes a value from a specific indx, if indx valid
  //remaining values are moved down
  //IF indx not valid, return false
template <class T>
bool indexList<T>::remove(int indx)
{
  if (indx >= 0 && indx < numberOfElements)
    {
      for (int i= indx; i < numberOfElements-1; i++)
          list[i] = list[i+1];

      numberOfElements --;
      return true;
    }
  else
    return false;
}

  //search
  //Searchs for the value in the array
  //Returns indx if found, -1 if not found
template <class T>
int indexList<T>::search(T value) const
{
  for (int i=0; i<numberOfElements; i++)
    {
      if (list[i] == value)
        return i;
    }
  return -1;
}


  //getSize
  //Returns the number of elements currently in
  //the array
template <class T>
int indexList<T>::getSize() const
{
  return numberOfElements;
}


//<< stream operator writes out entire list
template <class T>
ostream &operator<<(ostream &out, const indexList<T> &lst)
{
  T element;
  int count = lst.getSize();

  for (int j=0; j<count; j++)
    {
      lst.retrieve(j, element);
      out << "[" << j << "] " << element << endl;
    }
  return out;
}

[stc5097]

here is the application file that will be using these classes.

indexListApp.cpp
//File:      indexListApp.cpp
//Author:    Joshua Smith
//Ammended by:
//Course:    CSC 136
//Date:      Spring 2012
//PUrpose:   Test the indexList Class with ints

#include "indexList.h"
#include "term.h"
#include <iostream>
#include <fstream>
using namespace std;

//FillList
//Description: opens a file and fills the list from the file
//Parameters:  indexList
//Return:      none
void FillList(indexList<term> &list);


//DisplayList
//Description: displays the list to the monitor
//Parameters: indexList
//Return:     none
void DisplayList(indexList<term> list);

//AddToList
//Description: adds to the list, either append or
//             insert based on user input
//Parameters: indexList
//Return:     none
void AddToList(indexList<term> &list);

//DeleteFromList
//Description: requests a value to remove and removes that value
//Parameters: indexList
//Return:     none
void DeleteFromList(indexList<term> &list);

//Retrieve
//Description: retrieves an element from a specific index
//Parameters: indexList
//Return:     none
void Retrieve(indexList<term> list);

//Replace
//Description: lets the user replace one value with another
//Parameters: indexList
//Return:     none
void Replace(indexList<term> &list);

//Menu
int menu();

int main()
{
        int choice;
        indexList<term> L;

        while ((choice = menu()) != 7)
        {
                switch (choice)
                {
                    case 1: FillList(L); break;
                    case 2: AddToList(L); break;
                    case 3: DeleteFromList(L); break;
                    case 4: Retrieve(L); break;
                    case 5: Replace(L); break;
                    case 6: DisplayList(L); break;
                }
        }


        return 0;
}


//menu
int menu()
{
        int ch;
        cout << endl;
        cout << "1. Fill from file" << endl;
        cout << "2. Add to the list" << endl;
        cout << "3. Delete from the list" << endl;
        cout << "4. Retrieve from an index" << endl;
        cout << "5. Replace a value" << endl;
        cout << "6. Display list" << endl;
        cout << "7. Quit" << endl;
        cout << "Choice: ";
        cin >> ch;
        return ch;
}

//FillList
//Description: opens a file and fills the list from the file
//Parameters:  indexList
//Return:      none
void FillList(indexList<term> &list)
{
  bool ok = true;
  term value;
  ifstream f;
  string fname;

  cout << "File: ";
  cin >> fname;
  f.open(fname.c_str());
  if (f.fail())
    {
      cout << "Failed to open" << endl;
      return;
    }

  f >> value;
  while (ok && !f.eof())
    {
      ok  = list.append(value);
      f >> value;
    }

  f.close();

}


//DisplayList
//Description: displays the list to the monitor
//Parameters: indexList
//Return:     none
void DisplayList(indexList<term> list)
{
  cout << endl;
  cout << list;
}

//AddToList
//Description: adds to the list, either append or
//             insert based on user input
//Parameters: indexList
//Return:     none
void AddToList(indexList<term> &list)
{
  char answer;
  term value;
  int index;
  bool result;

  cout << "Value to add: ";
  cin >> value;
  cout <<"Do you want to (A)ppend or (I)insert? ";
  cin >> answer;

  if (answer == 'A' || answer == 'a')
    {
      result = list.append(value);
    }
  else
    {
      cout << "State index at which to insert: ";
      cin >> index;
      result = list.insert(index, value);
    }

  if (!result)
    cout << "addition failed" << endl;
}

//DeleteFromList
//Description: removes the element from the obtained index
//Parameters: indexList
//Return:     none
void DeleteFromList(indexList<term> &list)
{
  term value;
  int index;

  cout << "Value you wish to delete: ";
  cin >> value;

  index = list.search(value);

  if (index != -1)
    {
      if (list.remove(index))
        cout << value << " at index " << index << " has been removed" << endl;
      else
        cout << "invalid index" << endl;
    }
  else
    cout << value << " not found" << endl;
}

//Retrieve
//Description: retrieves an element from a specific index
//Parameters: indexList
//Return:     none
void Retrieve(indexList<term> list)
{
  int index;
  term value;

  cout << "Index from which to retrieve: ";
  cin >> index;

  if (list.retrieve(index, value))
    cout << value << " is at index " << index << endl;
  else
    cout << "invalid request" << endl;
}

//Replace
//Description: allows the user to replace on value with another
//Parameters: indexList
//Return:     none
void Replace(indexList<term> &list)
{
  int index;
  term value, newValue;

  cout << "Value to replace: ";
  cin >> value;
  cout << "New value: ";
  cin >> newValue;

  index = list.search(value);
  if (index != -1 )
    list.replace(index, newValue);
  else
    cout << value << " not found" << endl;
}

[Stewbond]

It's a bit hard to get through 500 lines of code and offer advice.

When I stick all of these in one file and put:
typedef term char;
It compiles properly for me.