Перегрузка операций. Классы., С++ Опции

[klem4]

Как мне при следующем описании класса перегрузить операции сравнения для 2-х переменных типа T

template <class T>
	class Vector{
public :
		void GetMem(int); // выделение памяти
		void Input(); // обычный ввод
		void Input(const T*); // передача массива - константы
		void Input(int); // заполнение случайными числами
		void Print(); // печать массива
		void Sort(); // сортировка
		int Search(T value); // поиск
	
private :
		T * V; // сам массив
		int size;
	};

[klem4]

В общем сделал я каждый элемента массива аналогично тому как было в файлах препода, чтобы не приставал, и получилось у меня следующее. Хотел бы услашать какие- либо замечания/поправки, так как с классами/шаблонами познакомился совсем недавно и опыта немного.


И так шаблон класса для работы с одномерным массивом

Имеются функции
- Ввод с клавиатуры
- Заполнение случайными сислами
- Передача массива - константы
- Сортировка (методом вставок)
- Линейный поиск

И класс Timer для замера времени. Конечно чтобы такими методами замерить время приходится выполнять процедуру много раз.

#include <iostream.h>
#include <string.h>

/********************** Class Timer **************************/
class Timer {
public :
	void On();
	void Off();
	void Show();
private:
	int start, end; 
};

void Timer :: On(){
	start = time(NULL);
};

void Timer :: Off(){
	end = time(NULL);
};

void Timer :: Show(){
	cout << "time = " << difftime(end, start) << " sec." << endl;
};

/************************* Class Element ********************************/

template <class T>
	struct Element{
		T Key;
		int Data;
		
		int operator > (Element & b);
		int operator < (Element & b);
		int operator >= (Element & b);
		int operator <= (Element & b);
		T& operator [] (long i);
	};

template <class T>
	int Element <T> :: operator > (Element<T> & b){
		return Key > b.Key;
	};
	
template <class T>
	int Element <T> :: operator < (Element<T> & b){
		return Key < b.Key;
	};
	
template <class T>
	int Element <T> :: operator >= (Element<T> & b){
		return Key >= b.Key;
	};
	
template <class T>
	int Element<T> :: operator <= (Element<T> & b){
		return Key <= b.Key;
	};
	
int Element<char*> :: operator > (Element<char*> & b){
	return strcmp(Key, b.Key) > 0;
}

int Element<char*> :: operator < (Element<char*> & b){
	return strcmp(Key, b.Key) < 0;
};

int Element<char*> :: operator >= (Element<char*> & b){
	return strcmp(Key, b.Key) >= 0;
};

int Element<char*> :: operator <= (Element<char*> & b){
	return strcmp(Key, b.Key) <= 0;
};

/********************* Class Vector ************************/

template <class T>
	class Vector{
	public :
		void GetMem(long); // выделение памяти
		void Input(); // обчный ввод с клавы
		void Input(long); // заполнение случайными числами (от 0 до значения входногопараметра)
		void Print(); // печать ключей массива
		long LSearch(T value); // линейный поиск, возвращает номер элемента или -1 если не найден
		void ISort(); // сортировка вставками
	private :
		Element <T> * V; 
		long size; 
	};
	
template <class T>
	void Vector <T> :: GetMem(long n){
		size = n;
		V = new Element <T> [size];
	};
	
void Vector <char*> :: GetMem(long n){
	size = n;
	V = new Element<char*> [size];
	for (long i = 0; i < size; i++) V[i].Key = new char [size];
};
	
template <class T>
	void Vector <T> :: Input(){
		for (long i = 0; i < size; i++){
			cout << "V[" << i << "]=";
			cin  >> V[i].Key;
		};
	};
	
template <class T>
	void Vector<T> :: Input(long rnd){
		srand(time(NULL));
		for (long i = 0; i < size; V[i++].Key = rand() % rnd);
	};
	
template <class T>
	void Vector <T> :: Print(){
		long i = 0;
		while (i < size) cout << V[i++].Key << endl;
	};
	
template <class T>
	long Vector <T> :: LSearch(T value){
		long i = 0;
		while ((i < size) && !(V[i++].Key == value));
		return i < size ? --i : -1;
	};
	
template <class T>
	void Vector <T> :: ISort() {
		long a,b;
		for (a = 1; a < size; a++) {
			Element<T> temp = V[a];
			for (b = a - 1; (b >= 0) && (temp.Key < V[b].Key); b--)
				V[b+1] = V[b];
			V[b+1] = temp;
		};
	};
	
Timer TIMER;


int main(void){
	
	Vector <int> a;
	
	long N = 100;
	a.GetMem(N);
	a.Input(100); // в данном случае заполнение массива сл. числами
	
	TIMER.On();
	long find = 0;
	for (long i = 0; i < 10000; i++) find = a.LSearch(3); // поиск и замер времени
	TIMER.Off();
	
	cout << "find = " << find << endl;
	
	cout << "\nBefore Sort : " << endl;
	a.Print();

	a.ISort(); // сортировка
	
	cout << "\nAfter sort : " << endl;
	a.Print();
	
	cout << "Search time : "; TIMER.Show();

	return 0;
}

Извините ввод с помощью константы я забыл сделать ) Добавлю.