ich hab hier eine vector klasse geschrieben, mit globalem op+ der auf op+= aufbaut. Hab in jede Funktion Ausgaben eingebaut um zu verstehen in welcher Reihenfolge da was passiert. Im op+ wird durch CopyCtor ein Objekt erzeugt, aber der CCtor meldet sich nicht wie meiner??? => der Compiler hat noch einen erzeugt?
Kennt meinen nicht??
Ich bin hier schon völlig an Ende.
Das ist mein Code auf das wesentliche reduziert benutze gcc 3.3.5

using namespace std; 
typedef long int size_type;

template<typename T> class Vector{
    protected:
		T	*vectorPtr;
		size_type dim;
    public:
		Vector();
		Vector(size_type dim);
		Vector(size_type n, T initVal);
		template <typename U> Vector(const Vector<U> &src);
		~Vector(){
			cerr << " Dtor Check\n";
			delete [] vectorPtr;
		}

		size_type length() const {return dim;}
		T* rootPtr() const {return vectorPtr;}
		void setCoutwidth(unsigned short i){coutwidth = i;}
		unsigned short getCoutwidth()const {return coutwidth;}

		Vector<T>& operator=(const Vector<T> &src);
		template <typename U> Vector<T>& operator+=(const Vector<U> &vec2);
};

template<typename T> Vector<T>::Vector(){
	cerr << " Standard Ctor Check\n";
	dim 		= 3;
	vectorPtr = new T[dim];
}

template<typename T> Vector<T>::Vector(size_type n, T initVal){
	cerr << " Ctor 2 Check\n";
	dim 		= n;
	vectorPtr = new T[dim];
	T *tmpPtr;
	for (tmpPtr = vectorPtr; tmpPtr - vectorPtr < dim; ++tmpPtr) 
		*tmpPtr = initVal;
}

template<typename T> template <typename U> Vector<T>::Vector(const Vector<U> &src){
	cerr << " Copy Ctor Check\n";
	dim 		= src.length();
	vectorPtr = new T[dim];
	U *srcPtr;
	T *tmpPtr;
	for (tmpPtr = vectorPtr, srcPtr = src.rootPtr(); tmpPtr - vectorPtr < dim; ++tmpPtr, ++srcPtr)
		*tmpPtr = *srcPtr;
}

template<typename T> Vector<T>& Vector<T>::operator=(const Vector<T> &src){
	cerr << " op= Check\n";
	if (this != &src){
		if (dim != src.dim){
			dim = src.dim;
			delete [] vectorPtr;
			vectorPtr = new T[dim];
		}
		T *srcPtr, *tmpPtr;
		for (tmpPtr = vectorPtr, srcPtr = src.vectorPtr; tmpPtr - vectorPtr < dim; ++tmpPtr, ++srcPtr)
			*tmpPtr = *srcPtr;

	}
	return *this;
}

template<typename T> template <typename U> Vector<T>& Vector<T>::operator+=(const Vector<U> &vec2){
	cerr << " op+= Check\n";
	if (dim != vec2.length()){
		cerr << " for operator += dimension of vectors must confirm!\n";
		exit(1);
	}
	else{	
		U *vec2Ptr = vec2.rootPtr();
		T *tmpPtr;
		for (tmpPtr = vectorPtr; tmpPtr - vectorPtr < dim; ++tmpPtr, ++vec2Ptr)
			*tmpPtr += *vec2Ptr;
	}
	return *this;
}

template<typename T, typename U> Vector<T> operator+(const Vector<T> &vec1, const Vector<U> &vec2){
	cerr << " op+ Check 1\n";
	if (vec1.length() != vec2.length()){
		cerr << " for operator + dimension of vectors must confirm!\n";
		exit(1);
	}
	cerr << " op+ Check 2\n";
	Vector<T> result(vec1);
	result += vec2;
	cerr << " op+ Check 3\n";
	return result;
}

int main(){
	int dim = 3;
	Vector<float> a(dim,1), b;
	Vector<double> c(a);
	cerr << " main Check 1\n";
	b = a + c;
	cerr << " main Check 2\n";
	return 0;
}

Das Programm erzeugt dann folgende Ausgabe:

Ctor 2 Check
 Standard Ctor Check
 Copy Ctor Check
 main Check 1
 op+ Check 1
 op+ Check 2
 op+= Check
 op+ Check 3
 op= Check
 Dtor Check
 main Check 2
 Dtor Check
 Dtor Check
 Dtor Check

Weis jemand Rat? Bin am verzweifeln

template <typename U> Vector(const Vector<U> &src);

Ist nicht der CopyConstructor, sondern irgendeiner. Du musst einen schreiben á la Vector( const Vector& src);