class Werte{
public:
	Werte(int,int*);
	virtual ~Werte();
	Werte operator+(Werte&);
	Werte& operator=(Werte&);
	int operator[](int);

private:
	int size;
	int *feld;
};

Werte::Werte(int sz, int *values)
{
	size = sz;
	feld = new int[sz];
	for(int i=0;i<sz;i++)
		feld[i] = values[i];
}

Werte::~Werte()
{
	delete[] feld;
}

Werte Werte::operator +(Werte& w)
{
	int tempsize;

	if(size < w.size)
		tempsize = size;
	else
		tempsize = w.size;

	int *temparray = new int[tempsize];
	for(int i =0;i<tempsize;i++)
		temparray[i] = feld[i]+w.feld[i];

	Werte tmp(tempsize, temparray);

	return tmp;
}

Werte& Werte::operator=(Werte& w)
{
	w.size = size;
	for(int i=0;i<size;i++)
		w.feld[i] = feld[i];
	return w;
}

int Werte::operator [](int i)
{
	return feld[i];
}

Bitte unterlasst Kommentare zum code da ich ihn nur eben schnell hingeklatscht habe damit ich mein Verstädnisproblem besser erläutern kann.
Wie ihr seht erzeuge ich in der Funktion des überladenen Plus Operators ein temporäres Objekt welches ich anschliessend zurückgeben möchte.
Das Problem ist aber das ja temporäre Objekte nach verlassen der Methode zerstört werden, d.h. der Destruktor "löscht" mein Wertearry.
Was ist zu tun, dass dies nicht passiert ich steh grad extrem auf dem Schlauch und zerbrech mir schon den ganzen morgen den Kopf darüber, wie sich das vermeiden lässt ohne Speichermüll zurückzulassen indem ich die delete[] Zeile im Destruktor entferne.

Und genau in dem kursiven Teil da oben steckt dein Problem: Du hast keinen Copy-Ctor definiert, also legt der Compiler einen eigenen an. Und der default-angelegte Copy-Ctor führt eine flache Kopie durch (sprich: er kopiert lediglich die Member 'size' und 'feld' - aber letzteres zeigt weiterhin auf das Feld, das tmp's Dtor freigegeben hat => BUMM).