Klasse zu Klassen - Template erweitern???

Hallo zusammen,

kann mir jemand einen Tipp geben, wie ich weiter vorgehen muss!

Ich habe ein Klasse CTEST erstellt, welche ich nun zu einer Klassen-Template
mit Variablentyp T erweitern möchte!

hier mal meine bisherige Klasse schon als template (glaub ich!!!):
-----------------------------
template <typename T>
class CTEST
{
private:
T a;
T b;

public:
CTEST(const CTEST &_t);
CTEST(T _a, T _b);
virtual ~CTEST();
void setb(T _b);
void seta(T _a);
CTEST geta() const;
CTEST getb() const;
bool operator==(const CTEST& ct) const
{
if((a == ct.geta())&&(ct.getb() == b))
return true;
return false;
}

};
-------------------------------------

So, nun frag ich mich erstens ob das richtig ist was ich gemacht habe;

Und zweitens weiß ich nicht wie ich nun die Methoden und Konstruktoren
implementieren muss, dass der Compiler die Verbindung zur Klasse herstellen
kann? (ich möchte sie nicht inline implementieren!)

Hier noch mal mein Anfang einer Implementierung (funkt nicht):
--------------------------------------
template <typename T> CTEST<T>::CTEST(const CTEST &_t)
{
a = _t.a;
b = _t.b;
}
-------------------------------------

Kann mir jemand helfen!?!?

Vielen Dank schon im voraus

Shlo

//Header

template<class T>
class Test
{
public:
	Test(const Test<T>& t);
	Test(const T& d, const T& e);
	T GetA() const;
	T GetB() const;
	bool operator==(const Test<T>& t) const;

private:
	T a;
	T b;
};

//*.cpp
#include "test.h"

template<class T>
Test<T>::Test(const Test<T>& t) { }

template<class T>
Test<T>::Test(const T& d, const T& e)
: a(d), b(e) { }

template<class T>
T Test<T>::GetA() const { return a; }

template<class T>
T Test<T>::GetB() const { return b; }

template<class T>
bool Test<T>::operator==(const Test<T>& t) const 
{ return a && b; }

ungefähr so