Vector Class

Yes i was given the problem to write a program using the Vecotr class and the following is what i have to implement into the program as member functions:
Overload >> cin
overload << cout
SortV- can use any sorting technique bubble selection or quick doesn't matter
ReverseV-to reverse the numbers in the vector
RemoveDup- to remove any duplicate elements if any.

any help would be appraited.
the header file is tvector.h that i have to use it is as follows

Code:

---

const int DEFAULT_VECTOR_SIZE = 50;

template <class T>
class Vector
{
  private:
      // dynamic list containing arraySize elements of type T
      T *arr;
      int arraySize;

      // create general error message and terminate program
      void error(const String& msg) const;

  public:
      // constructors and destructor

      // create uninitialized array with arrsize elements
      Vector(int arrsize = DEFAULT_VECTOR_SIZE);

      // all arrsize elements initialized to value
      Vector(int arrsize, const T& value);

      // initialize with C++ array
      Vector(T a[], int arrsize);

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

      // destructor. reasons for virtual discussed in Ch. 12
      virtual ~Vector();

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

      // index operators
      T& operator[](int n);
      // version for constant objects
      const T& operator[](int i) const;

      // convert to a C++ array
      T *c_arr() const;

      // access and update operations
      int size() const;      // return size
      void resize(int sz);    // modify the size
      void clear();          // clear the list
};

// ***********************************************************
//      Vector class implementation
// ***********************************************************

// private function to print an error message and
// terminate the program
template <class T>
void Vector<T>::error(const String& errmsg) const
{
  cerr << errmsg << endl;
  exit(1);
}

//constructor
template <class T>
Vector<T>::Vector(int arrsize): arraySize(arrsize)
{
  if (arraySize < 0)
      error("Negative Vector size is invalid.");
  else if (arraySize == 0)
  {
      // 0 size array. assign arr to NULL and return
      arr = NULL;
      return;
  }

  // dynamically create Vector
  arr = new T[arraySize];
  // make sure the allocation succeeded
  if (arr == NULL)
      error("Memory allocation failure.");
}

// constructor. initialize with n element array a
template <class T>
Vector<T>::Vector(T a[], int arrsize): arraySize(arrsize)
{
  int i;

  if (arraySize < 0)
      error("Negative Vector size is invalid.");
  else if (arraySize == 0)
  {
      // 0 size array. assign arr to NULL and return
      arr = NULL;
      return;
  }

  // dynamically create array
  arr = new T[arraySize];
  // make sure the allocation succeeded
  if (arr == NULL)
      error("Memory allocation failure.");

  // copy array to arr
  for(i=0; i < arraySize; i++)
      arr[i] = a[i];
}

// constructor. initialize with arrsize copies of value
template <class T>
Vector<T>::Vector(int arrsize, const T& value): arraySize(arrsize)
{
  int i;
 
  if (arraySize < 0)
      error("Negative Vector size is invalid.");
  else if (arraySize == 0)
  {
      // 0 size array. assign arr to NULL and return
      arr = NULL;
      return;
  }

  // dynamically create array
  arr = new T[arraySize];
  // make sure the allocation succeeded
  if (arr == NULL)
      error("Memory allocation failure.");

  // each entry of arr has given value
  for(i=0; i < arraySize; i++)
      arr[i] = value;
}

// copy constructor
template <class T>
Vector<T>::Vector(const Vector<T>& obj)
{
  int i;

  // copy across fixed data member arraySize
  arraySize = obj.arraySize;

  if (arraySize == 0)
  {
      // object as 0 size
      arr = NULL;
      return;
  }

  // allocate new dynamic memory for the array
  arr = new T[arraySize];
  // make sure the allocation succeeded
  if (arr == NULL)
      error("Memory allocation failure.");

  // copy items from obj.arr to the newly allocated array
  for (i = 0; i < arraySize; i++)
      arr[i] = obj.arr[i];
}

// destructor
template <class T>
Vector<T>::~Vector()
{
  if (arr != NULL)
      delete [] arr;
}

// overloaded assignment
template <class T>
Vector<T>& Vector<T>::operator= (const Vector<T>& rhs)
{
  int i;

  // can't assign a Vector object to itself.  just return
  if (this == &rhs)
      return *this;

  // if rhs is a 0 size array, handle as a special case
  if (rhs.arraySize == 0)
  {
      if (arr != NULL)
        delete [] arr;
      arraySize = 0;
      arr = NULL;
      return *this;
  }

  // check size to see if arr in current object can be used
  if (arraySize != rhs.arraySize)
  {
      // de-allocate existing memory and allocate new memory
      delete [] arr;
      arr = new T[rhs.arraySize];
      if (arr == NULL)  // vefify allocation succeeded
        error("Memory allocation failure.");
  }

  // copy fixed data member arraySize
  arraySize = rhs.arraySize;

  // copy items from obj.arr to current object's array
  for (i = 0; i < arraySize; i++)
      arr[i] = rhs.arr[i];

  // return reference to the current object
  return *this;
}

// indexing operators

// non-constant version. provides general access to array
// elements
template <class T>
T& Vector<T>::operator[](int i)
{
  if (i < 0 || i > arraySize-1)
  {
      cerr << i << ": ";
      error("Index out of bounds");
  }
  return arr[i];
}

// constant version.  can be used with a constant object.
// does not allow modification of an array element
template <class T>
const T& Vector<T>::operator[](int i) const
{
  if (i < 0 || i > arraySize-1)
  {
      cerr << i << ": ";
      error("Index out of bounds");
  }
  return arr[i];
}

// convert to a C++ array
template <class T>
T *Vector<T>::c_arr() const
{
  return arr;
}

// return the number of elements in the array
template <class T>
int Vector<T>::size() const
{
  return arraySize;
}

// modify the size of the array
template <class T>
void Vector<T>::resize(int sz)
{
  int i, n;
 
  // handle case of negative size with error message
  if (sz < 0)
      error("Negative new size is invalid.");

  // handle case of no size change with a return
  if (sz == arraySize)
      return;

  // handle the case of a resize to size 0
  if (sz == 0)
  {
      delete [] arr;
      arr = NULL;
      arraySize = 0;
      return;
  }
 
  // allocate new list with sz elements
  T* newlist = new T[sz];

  // make sure the allocation succeeded
  if (newlist == NULL)
      error("Memory allocation failure.");

  // set n to be smaller of new size and current size
  if (sz <= arraySize)
      n = sz;
  else
      n = arraySize;

  // copy n elements from old list to new list
  // this may truncate the list
  for (i = 0; i < n; i++)
      newlist[i] = arr[i];

  // delete original list, set arr to point to newlist,
  // update arraySize
  delete[] arr;
  arr = newlist;
  arraySize = sz;
}

template <class T>
void Vector<T>::clear()
{
  resize(0);
}

---

any help would be great thanks guys
achilles

Hey guys i think i understand the other fucntions i only need help on overload functions of CIN and COUT pls help me with these functions.
thanks
achilles

How do you want the output displayed? Do you want the entire vector ouputted as a table, or do you want selective parts of it outputted?

I'm not helping until you post some code :) Just kidding. I think you mean something like this.

If not you are going to have to explain a bit better.