Как переоформить функцию под шаблонную?

Написал прогу, потом узнал что нужно и функции использовать шаблонами, чего я не сделал. Как и что не пробовал- не получается. Итак после дня копания по учебникам и гуглу решился отписатся здесь.

Собственно прошу я сделать так чтобы функции:

void PrintMax(Array<int> WA);
void PrintMin(Array<int> WA);
void QuickSort(int *items, int len);
void QS(int *items, int left, int right);

Были заданны через шаблоны.

К слову о ABS(), не знаю почему, но abs() у меня не работает, даже с #include <math.h>

Код:

//**********************************************************************
// Задание: В одномерном массиве (int), считываемом с клавиатуры, найти
//          наибольший и наименьший элемент, отсортировать массив так,
//          чтобы элементы равные нулю оказались в конце. Обязательно
//          использование функций и шаблонов. Использование глобальных
//          переменных не допускается.
//**********************************************************************

#include <iostream>

using namespace std;

const int DefaultSize=8; //для создания массива без указания размера
                         //размер будет выбран автоматически

//*************************Массив***************************************
template <class T>
class Array
{
  public:
    //конструкторы
    Array(int size);
    Array(const Array& rhs);
    ~Array() {delete [] pType;}

    //операторы
    Array& operator = (const Array&);
    T& operator[] (int offset)
      {
        if (offset>=0&&offset<GetSize()) return pType[offset];
        throw xBoundary();
        return pType[0];
      }
    const T& operator [] (int offset) const
      {
        if (offset>=0&&offset<GetSize()) return pType[offset];
        throw xBoundary();
        return pType[0];
      }

    //дружественная функция для переопределения оператора вывода
    template <class X> friend ostream& operator<< (ostream&, Array<X>&);

    //методы доступа
    int GetSize() const {return itsSize;}

    //определение класса исключений с множественным наследованием
    class xBoundary {}; //обращение к элементу вне массива
    class xSize       //ошибки связанные с заданием размера
      {
        public:
          virtual void PrintError() {cout<<"Size error!\n";}
      };
    class xBig :public xSize
      {
        public:
          virtual void PrintError() {cout<<"Entered size is big!\n";}
      };
    class xSmall :public xSize
      {
        public:
          virtual void PrintError() {cout<<"Entered size is small!\n";}
      };
    class xZero :public xSmall
      {
        public:
          virtual void PrintError() {cout<<"Can not be zero!\n";}
      };
    class xNegative :public xSize
      {
        public:
          virtual void PrintError() {cout<<"Can not be negative!\n";}
      };

  private:
    T *pType;
    int itsSize;
};

//определение конструкторов иметодов шаблона-класса Массив
template <class T>
ostream& operator << (ostream& output, Array<T>& theArray)
{
  for (int i=0;i<theArray.GetSize();i++)
    output<< "["<<i<<"]"<<theArray[i]<<endl;
  return output;
}

template <class T>
Array<T>::Array(int size):
itsSize(size)
{
  //проверка на ошибки размера массива
  if (size==0) throw xZero();
  if (size>100) throw xBig();
  if (size<1) throw xNegative();
  if (size<2) throw xSmall();

  pType=new T[size];
  for (int i=0;i<itsSize;i++)
    pType[i]=0;
}

template <class T>
Array<T>::Array(const Array& rhs)
{
  itsSize=rhs.GetSize();
  pType=new T[itsSize];
  for (int i=0;i<itsSize;i++)
    pType[i]=rhs[i];
}

template <class T>
Array<T>& Array<T>::operator = (const Array& rhs)
{
  if (this==&rhs) return *this;
  delete [] pType;
  itsSize=rhs.GetSize();
  pType=new T[itsSize];
  for (int i=0;i<itsSize;i++)
    pType[i]=rhs[i];
  return *this;
}
//*******************Класс исключение !int******************************
class xType {};
//*******************Прототипы функций**********************************

void PrintMax(Array<int> WA);
void PrintMin(Array<int> WA);
void QuickSort(int *items, int len);
void QS(int *items, int left, int right);
Array<int> ConvertAndSend(Array<int> WA);
int ABS(int N);    

//********************Главная функция***********************************
int main()
{ 
  int choise;
  while (true)
  {
    cout<<"Please enter array size: ";
    cin>>choise;
    cout<<"At now enter array elementh:\n";
    try               //обработчик ошибок
      {
        Array<int> workArray(choise);
        for (int i=0;i<workArray.GetSize();i++) cin>>workArray[i]; 
        PrintMax(workArray);
        PrintMin(workArray);
        workArray = ConvertAndSend(workArray);
        cout<<"Array after sort:\n"<<workArray<<endl;
      }
    catch (Array<int>::xBoundary) {cout<<"Boundary error!\n";}
    catch (Array<int>::xSize& theException) {theException.PrintError();}
    cout<<"Would do you like work on a new array? y(1)/n(other)\n";
    cin>>choise;
    if (choise!=1) break;
  }

  return 0;
}

void PrintMax(Array<int> WA)
{
  int max=0;
  for (int i=0;i<WA.GetSize();i++)
    if (max<WA[i]) max=WA[i];
  cout<<"Maximum element of array: "<<max<<endl;
}

void PrintMin(Array<int> WA)
{
  int min=2147483647;
  for (int i=0;i<WA.GetSize();i++)
    if (min>WA[i]) min=WA[i];
  cout<<"Minimum element of array: "<<min<<endl;
}
//моя неосведомленность или проблемы взаимопонимания Linux и чего-то
int ABS(int N)
{
  if (N>0) return N;
  else return -N;
}
//**********************Горе от !ума************************************
Array<int> ConvertAndSend(Array<int> WA)
{
  int temp[WA.GetSize()];
  for (int i=0;i<WA.GetSize();i++) temp[i]=WA[i];
  QuickSort(temp,WA.GetSize());
  for (int i=0;i<WA.GetSize();i++) WA[WA.GetSize()-i-1]=temp[i];
  return WA;
}
//************Алгоритм быстрой сортировки модифицированный**************
void QuickSort(int items[], int len)
{
  //для передачи в первый раз всего массива
  QS(items, 0, len);
}

void QS(int items[], int left, int right)
{
  int i, j, x, y;
  i = left; j = right;
  //нахождение середины
  x = items[( left+right) / 2 ] ;
  //перемещение элементов
  do 
    {
      while((ABS(items[i]) < ABS(x)) && (ABS(i) < ABS(right))) i++;
      while((ABS(x) < ABS(items[j])) && (ABS(j) > ABS(left))) j--;

      if(i <= j) 
        {
          y = items[i];
          items[i] = items[j];
          items[j] = y;
          i++; j-- ;
        }
    } 
  while(i <= j );

  //вызвать рекурсивно если массив недоотсортирован
  if(left < j) QS(items, left, j ) ;
  if(i < right) QS(items, i, right);
}