Funzione "prova" fa andare in crash

Il codice è questo, quando lo faccio partire la funzione "prova" mi fa andare in crash... Riuscite ad aiutarmi?

[#include <iostream>
#include <string>
using namespace std;

const int d = 10;

template <class T>
class Insieme
{
	private:
		T* V;
		int dim;
		void allarga()
		{
		T* A = new T [dim+d];
		for (int i=0; i<dim; ++i)
			A[i] = V[i];
		delete[] V;
		dim=dim+d;
		V = A;
		}
	public:
		Insieme()
			{
			V = NULL;
			dim=0;
			} //costruttore senza parametri
		
		Insieme (T A[], int n)
			{
			int i=0;
			V= new T[n];
			dim=n;
			for (i=0; i<n; i++)
				add(A[i]);
			} //costruttore con parametri
		
		Insieme (Insieme<T>& s)
		{
			V=new T[s.size()];
			dim=s.size();
			for (int i=0; i<dim; i++)
				V[i]=s.V[i];
		} //costruttore di copia
		
		~Insieme()
			{
			delete[] V;
			} //distruttore
		
		void add (T x)
			{
			int i=0;
			for (i=0; true; i++)
				{
				if (i==dim)
					{
					allarga();
					break;
					}
				else if (V[i]=="")
					break;
				} //trova il primo spazio vuoto nell'insieme
			V[i] = x;
			for (i=0; i<size(); i++)
			{
				for (int j=i+1; j<size(); j++)
				{
					if (V[i]==V[j])
						V[j]="";
				} //controlla che l'elemento x non sia già presente nell'insieme, se si lo elimina
			}
			}
		
		bool contains (T x)
			{
				for (int i=0; i<size(); i++)
					{
					if (V[i]==x)
						return true;
					else if (V[i]=="")
						return false;
					}
			} //controlla che la stringa x sia nell'insieme
			
		int size() const
			{
			int i;
			for (i=0; i<dim; i++)
				{if (V[i]=="")
					break;}
			return i;
			} //dice il numero di elementi di un insieme
			
		bool operator<(Insieme<T>&S) const
			{
			int uguale=0;
			for (int i=0; true; i++)
				{for (int j=0; true; j++)
					{
					if (V[j]=="")
						break;
					else if (V[j]==S.V[i])
						uguale++;
					if (uguale==size())
						return true;
					}
				if (S.V[i]=="")
					return false;
				}
			} //dice se l'insieme è sottoinsieme di un altro
		
		Insieme operator+ (Insieme<T>& S) const
			{
			int i=0;
			Insieme<T> ris;
			for (i=0; i<size(); i++)
			{
				if (V[i]=="")
					break;
				else ris.add(V[i]);
			}
			
			for (i=0; i<S.size(); i++)
			{
				if (S.V[i]=="")
					break;
				else ris.add(S.V[i]);
			}
			return ris;				
			} //unisce due insiemi
		
		Insieme<T>& operator= (const Insieme<T>& S)
		{
			int d;
			if (this==&S)
				return *this;
			d=S.dim;
			for (int i=0; i<d; i++)
				add(S.V[i]);
			return *this;
		} //copia l'insieme S nell'insieme che chiama la funzione
			
		void remove (T x)
		{
			int i=0, j;
			T temp;
			for (i=0; true; i++)
			{
				if (V[i]==x)
					break;
				else if (i==size()-1)
					throw string ("Elemento non presente");
			} //cerca l'elemento x
			V[i]=""; //elimina l'elemento x
			for (; true; i++)
			{
				j=i+1;
				temp=V[j];
				V[i]=temp;
				V[j]="";
				if (V[j+1]=="")
					break;
			} //ricompatta l'insieme
		}
		
		void stampa (ostream& f_out) const
			{
			int i=0;
			f_out<<"{";
			for (i=0; true; i++)
				{if (i==dim)
					break;
				f_out<<V[i];
				if (i!=size()-1)
					f_out<<", ";
				else break;}
			f_out<<"}";
			} //stampa tutti gli elementi di un insieme
			
};

template <class T>
ostream& operator<< (ostream& f_out, const Insieme<T>& x)
	{
	x.stampa(f_out);
	return f_out;
	}

void prova(string s, Insieme<string> X){       // test costruttore di copia (automatico)
  X.remove(s);
  X.add("cavallo");
  return;
  }

int main()
{
	Insieme<string> S;
	S.add("e");
	S.add("il");
	S.add("cane");
	prova("cane", S);
	system("pause");
	return 0;
}]