Ho la seguente classe:
codice:
 
//////////////////////////////////////////////////////////////////////
// Vettore.h: interface for the Vettore class.
//
//////////////////////////////////////////////////////////////////////
#define DIM_STANDARD 10

template<class T>
class Vettore  
{
public:
	///////////////////////////////
    // Costruttori/distruttori
    ///////////////////////////////
	Vettore();
	Vettore(int dim);
	virtual ~Vettore();	
	///////////////////////////////
    // Utilita di ricerca
    ///////////////////////////////
	void Ordina();
	int cerca(int size, T a[], T key);
	///////////////////////////////
    // Funzioni di interfaccia
    ///////////////////////////////
	int getDimensione();
	T getElemento(int pos);
	///////////////////////////////
    // Funzioni vettore
    ///////////////////////////////
	void AggiungiElemento(T elemento, int pos);
	void AggiungiElemento(T elemento);
	void RimuoviElemento(int pos);

private:
	T* elementi; // gli elementi
	int dimensione; // la dimensione

};
Implementata cosi:
codice:
 //////////////////////////////////////////////////////////////////////
// Vettore.cpp: implementation of the Vettore class.
//
//////////////////////////////////////////////////////////////////////
#include "Vettore.h"

//////////////////////////////////////////////////////////////////////
// Construttore a un argomento
//////////////////////////////////////////////////////////////////////
template<class T>
Vettore<T>::Vettore(int dim)
{
	dimensione = (dim < 0) ? DIM_STANDARD : dim;
	elementi[dim] = new T[dim];
	for(int i=0;i<dimensione;i++)
	{
		dimensione[i] = NULL;
	}

}

//////////////////////////////////////////////////////////////////////
// Construttore standard
//////////////////////////////////////////////////////////////////////
template<class T>
Vettore<T>::Vettore()
{
	elementi[DIM_STANDARD] = new T[DIM_STANDARD];
	dimenione = MAX;
	for(int i=0;i<dimensione;i++)
	{
		dimensione[i] = NULL;
	}
}

//////////////////////////////////////////////////////////////////////
// Distruttore standard
//////////////////////////////////////////////////////////////////////
template<class T>
Vettore<T>::~Vettore()
{
	delete[] elementi;
}

//////////////////////////////////////////////////////////////////////
// Restituisce la dimensione
//////////////////////////////////////////////////////////////////////
template<class T>
int Vettore<T>::getDimensione()
{
	return dimensione;
}
//////////////////////////////////////////////////////////////////////
// Ordina gli elementi
//////////////////////////////////////////////////////////////////////
template<class T>
void Vettore<T>::Ordina()
{
	bool is_sorted=false;
	int p=0,q=0;
	T tmp;// la variabile temporanea di appoggio

	while(!is_sorted){
		is_sorted=true;
		++p;// p viene avanzato e poi visualizzato
		for(q=0;q<size-p;++q){
			if(elementi[q]>a[q+1]){
			tmp=elementi[q];
			elementi[q]=elementi[q+1];
			elementi[q+1]=tmp;
			is_sorted=false;// esce dal for
			}
		}
	}
}
//////////////////////////////////////////////////////////////////////
// Reicerca elementi
//////////////////////////////////////////////////////////////////////
template<class T>
int Vettore<T>::cerca(int size, T a[], T key)
{
	for(int i=0;i<size;i++)
	{
		if(a[i] == key)
			return i;
	}

	return -1;
}
//////////////////////////////////////////////////////////////////////
// Aggiunge un elemento (con posizione specificata)
//////////////////////////////////////////////////////////////////////
template<class T>
void Vettore<T>::AggiungiElemento(T elemento, int pos)
{
	if( (pos <= dimensione) && (pos > 0) )
		elementi[pos] = elemento;
}

//////////////////////////////////////////////////////////////////////
// Aggiunge un elemento (senza posizione specificata)
//////////////////////////////////////////////////////////////////////
template<class T>
void Vettore<T>::AggiungiElemento(T elemento)
{
	for(int pass=0;pass<dimensione;pass++)
	{
		if(elementi[pass] == NULL)
			elementi[pass] = elemento
		break; // esce dal for
	}
}
//////////////////////////////////////////////////////////////////////
// Restituisce un elemento (posizione specificata)
//////////////////////////////////////////////////////////////////////
template<class T>
T Vettore<T>::getElemento(int pos)
{
	return elementi[pos];
}
//////////////////////////////////////////////////////////////////////
// Rimuove un elemento (con posizione specificata)
//////////////////////////////////////////////////////////////////////
template<class T>
void Vettore<T>::RimuoviElemento(int pos)
{
	if( (pos <= dimensione) && (pos > 0) )
	elementi[pos] = NULL;
}
E ho questo test:
codice:
 // test.cpp
#include <iostream>
#include "Vettore.h"

using namespace std;

int main()
{
	Vettore<int> vet(5);
	vet.AggiungiElemento(3, 1);
	vet.AggiungiElemento(5);
	vet.Ordina();
	for(int i;i<vet.getDimensione();i++)
	{
		cout << "Vettore " << i << ": " << vet.getElemento(i)<<endl;
	}
	return 0;
}
Ma mi da:
Test.obj : error LNK2001: unresolved external symbol "public: virtual __thiscall Vettore<int>::~Vettore<int>(void)" (??1?$Vettore@H@@UAE@XZ)
Test.obj : error LNK2001: unresolved external symbol "public: int __thiscall Vettore<int>::getElemento(int)" (?getElemento@?$Vettore@H@@QAEHH@Z)
Test.obj : error LNK2001: unresolved external symbol "public: int __thiscall Vettore<int>::getDimensione(void)" (?getDimensione@?$Vettore@H@@QAEHXZ)
Test.obj : error LNK2001: unresolved external symbol "public: void __thiscall Vettore<int>::Ordina(void)" (?Ordina@?$Vettore@H@@QAEXXZ)
Test.obj : error LNK2001: unresolved external symbol "public: void __thiscall Vettore<int>::AggiungiElemento(int)" (?AggiungiElemento@?$Vettore@H@@QAEXH@Z)
Test.obj : error LNK2001: unresolved external symbol "public: void __thiscall Vettore<int>::AggiungiElemento(int,int)" (?AggiungiElemento@?$Vettore@H@@QAEXHH@Z)
Test.obj : error LNK2001: unresolved external symbol "public: __thiscall Vettore<int>::Vettore<int>(int)" (??0?$Vettore@H@@QAE@H@Z)
Debug/Vettore.exe : fatal error LNK1120: 7 unresolved externals
Error executing link.exe.