Работа с шаблонами С++

#include <iostream>
#include <stdarg.h> 
#include <vector>
#include <algorithm>
 
template < typename T >
class Compare
{
public:
    bool compare(T a, T b);
private:
    T a;
    T b;
};
 
template < typename T >
bool Compare<T>::compare( T a, T b )
{
    return( a > b );
};
 
template < typename T >
class RandomAccessIterator
{
public:
    ~RandomAccessIterator();
    typename std::vector< T >::iterator Get_first(){ return (_first = elem.begin()); };
    typename std::vector< T >::iterator Get_last(){ return (_last = elem.end()); };
    RandomAccessIterator(int n, ...);
 
private:
    typename std::vector< T >::iterator _first;
    typename std::vector< T >::iterator _last;
    std::vector< T >  elem;
        
 
    
};
 
template<typename T>
RandomAccessIterator<T>::RandomAccessIterator( int n, ... )
{
    int i;
    va_list vl;
    va_start(vl, n);
    for ( i = 0; i < n; i++ )
    {
        elem.push_back(va_arg(vl, T));
    }
    va_end(vl);
};
 
 
template<typename T>
RandomAccessIterator<T>::~RandomAccessIterator()
{
    elem.clear();
};
 
 
template < class RandomAccessIterator, class Compare >
//template < typename T>
class Sort
{
public:
    //void sort(RandomAccessIterator<T> iterator, Compare<T> comp);
    void sort(RandomAccessIterator iterator, Compare comp);
};
 
//template <class RandomAccessIterator<typename T>, class Compare<typename T>>
//template <typename T>
 
template < class RandomAccessIterator, class Compare >
void sort(RandomAccessIterator iterator, Compare comp) //sort(RandomAccessIterator<T> iterator, Compare<T> comp)
{
    int i;
    
    // строим пирамиду 
    for (i = std::distance(iterator.Get_first(), iterator.Get_last()) / 2; i >= 1; --i)
    {
        downHeap(iterator.Get_first(), i, std::distance(iterator.Get_first(), iterator.Get_last()));
    }
    // теперь a[0]...a[size-1] пирамида 
 
    for (i = std::distance(iterator.Get_first(), iterator.Get_last()); i > 1; --i)
    {
        // меняем первый с последним 
        std::iter_swap(iterator.Get_first(), iterator.Get_first() + i);
        // восстанавливаем пирамидальность a[0]...a[i-1] 
        downHeap(iterator.Get_first(), 1, i);
    }
};
 
template < typename T >
void downHeap(T p, int i, int d)
{
    int child;
    T tmp = p;
    while (i < d / 2)
    {
        child = 2 * i;
        if (child < d && comp.compare(*(p + child), *(p + child + 1)))
        {
            child++;
        }
        if (comp.compare(*(tmp + i), *(p + child)))
        {
            break;
        }
        else
        {
            std::iter_swap(p + i, child);    // переносим сына наверх 
            i = child;
        }
    }
};
 
 
int main()
{
    RandomAccessIterator<int> *b = new RandomAccessIterator<int>(4, 3, 4, 9, 17, 10, 2, 5, 21);
 
    Compare<int> *a = new Compare<int>();
 
    //Sort<int> *c = new Sort<int>();
 
    Sort<RandomAccessIterator<int>, Compare<int>> *c = new Sort<RandomAccessIterator<int>, Compare<int>>();
 
    (*c).sort(*b, *a);
 
    int i = 0;
    while (((*b).Get_first() + i) != (*b).Get_last())
    {
        std::cout << *((*b).Get_first() + i) << std::endl;
        i++;
    }
    delete c;
    delete a;
    delete b;
}