From: jakarppi AT paju DOT oulu DOT fi (Jari Karppinen)
Newsgroups: comp.os.msdos.djgpp
Subject: Trouble with templates and gcc-2.95
Date: 20 Sep 1999 12:09:59 GMT
Organization: University of Oulu, Department of Mathematical Sciences
Lines: 306
Message-ID: <7s586n$k60$1@ousrvr3.oulu.fi>
NNTP-Posting-Host: paju.oulu.fi
Mime-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 8bit
X-Trace: ousrvr3.oulu.fi 937829399 20672 130.231.240.20 (20 Sep 1999 12:09:59 GMT)
X-Complaints-To: news AT news DOT oulu DOT fi
NNTP-Posting-Date: 20 Sep 1999 12:09:59 GMT
X-Newsreader: TIN [UNIX 1.3 unoff BETA release 960807]
To: djgpp AT delorie DOT com
DJ-Gateway: from newsgroup comp.os.msdos.djgpp
Reply-To: djgpp AT delorie DOT com

I wrote a simple templatized vector class. There was no trouble 
compiling the source with egcs-1.1.2, but after I switched to 
gcc-2.95, I got the following:

vec.cc: In instantiation of `Vector<int>':
vec.cc:285:   instantiated from here
vec.cc:44: invalid use of undefined type `class Vector<int>'
vec.cc:48: forward declaration of `class Vector<int>'
vec.cc:44: confused by earlier errors, bailing out
 
I made no changes to the source, and can't see why this happens. I would
really appreciate advice from experts.

-- vec.cc:

#include <cmath>
#include <iostream>
#include <string>
#include <strstream>

template<class T> class Vector {
private:
	unsigned size_;
        T *data;
private:
	void init(unsigned);
        void copy(const T *);
        void destroy();
public:
	Vector();
	Vector(unsigned);
        Vector(unsigned, const T&);
        Vector(unsigned, const T *);
        Vector(unsigned, const char *);
	Vector(const Vector<T>&);
        Vector(istream&);
	~Vector();

	Vector<T>& operator = (const Vector<T>&);

	const T& operator() (unsigned) const;
	T& operator() (unsigned);

	friend ostream& operator << <> (ostream&, const Vector<T>&);
	friend istream& operator >> <> (istream&, Vector<T>&);

	unsigned size() const;
	void resize(unsigned);
        void fill(const T&);

	Vector<T> operator - ();

	Vector<T>& operator += (const Vector<T>&);
	Vector<T>& operator -= (const Vector<T>&);
	Vector<T>& operator *= (const T&);
	Vector<T>& operator /= (const T&);

	friend Vector<T> operator + <> (const Vector<T>&, const Vector<T>&);
	friend Vector<T> operator - <> (const Vector<T>&, const Vector<T>&);
	friend Vector<T> operator * <> (const Vector<T>&, const T&);
	friend Vector<T> operator * <> (const T&, const Vector<T>&);
	friend Vector<T> operator / <> (const Vector<T>&, const T&);
};

template<class T> inline void Vector<T>::init(unsigned size)
{
        data = new T[size_ = size];
}

template<class T> inline void Vector<T>::copy(const T *v)
{
        for (unsigned i = 0; i < size_; i++) {
        	data[i] = v[i];
	}
}

template<class T> inline void Vector<T>::destroy()
{
	delete[] data;
        data = 0;
}

template<class T> Vector<T>::Vector()
{
	size_ = 0;
        data = 0;
}

template<class T> Vector<T>::Vector(unsigned size)
{
	init(size);
}

template<class T> Vector<T>::Vector(unsigned size, const T& filler)
{
	init(size);
        fill(filler);
}

template<class T> Vector<T>::Vector(unsigned size, const T *v)
{
	init(size);
        copy(v);
}

template<class T> Vector<T>::Vector(unsigned size, const char *v)
{
        istrstream s(v, strlen(v));

        init(size);
        for (unsigned i = 0; i < size; i++) {
        	s >> data[i];
	}
}

template<class T> Vector<T>::Vector(const Vector<T>& vector)
{
	init(vector.size());
        copy(vector.data);
}

template<class T> Vector<T>::Vector(istream& s)
{
	unsigned size;

        s >> size;
        init(size);
        for (unsigned i = 0; i < size; i++) {
                s >> data[i];
	}
}

template<class T> Vector<T>::~Vector()
{
	destroy();
}

template<class T> Vector<T>& Vector<T>::operator = (const Vector<T>& vector)
{
        if (this == &vector) return *this;
	resize(vector.size());
        copy(vector.data);
        return *this;
}

template<class T> inline const T& Vector<T>::operator() (unsigned i) const
{
	return data[i];
}

template<class T> inline T& Vector<T>::operator() (unsigned i)
{
	return data[i];
}

template<class T> ostream& operator << (ostream& s, const Vector<T>& vector)
{
        s << vector.size() << endl;
        for (unsigned i = 0; i < vector.size(); i++) {
		s << vector(i) << " ";
	}
        s << endl;
	return s;
}

template<class T> istream& operator >> (istream& s, Vector<T>& vector)
{
	unsigned size;
        
        s >> size;
        vector.resize(size);
        for (unsigned i = 0; i < size; i++) {
                s >> vector(i);
	}
	return s;
}

template<class T> inline unsigned Vector<T>::size() const
{
	return size_;
}

template<class T> void Vector<T>::resize(unsigned size)
{
	if (size_ != size) {
        	destroy();
                init(size);
	}
}

template<class T> void Vector<T>::fill(const T& filler)
{
	for (unsigned i = 0; i < size_; i++) {
                data[i] = filler;
	}
}

template<class T> Vector<T> Vector<T>::operator - ()
{
	Vector<T> result(size_);
        for (unsigned i = 0; i < size_; i++) {
                result.data[i] = -data[i];
	}
        return result;
}

template<class T> Vector<T>& Vector<T>::operator += (const Vector<T>& vector)
{
 	for (unsigned i = 0; i < size_; i++) {
                data[i] += vector(i);
	}
        return *this;
}

template<class T>
Vector<T>& Vector<T>::operator -= (const Vector<T>& vector)
{
 	for (unsigned i = 0; i < size_; i++) {
                data[i] -= vector(i);
	}
        return *this;
}

template<class T> Vector<T>& Vector<T>::operator *= (const T& x)
{
	for (unsigned i = 0; i < size_; i++) {
		data[i] *= x;
	}
	return *this;
}

template<class T> Vector<T>& Vector<T>::operator /= (const T& x)
{
	for (unsigned i = 0; i < size_; i++) {
		data[i] /= x;
	}
	return *this;
}

template<class T>
Vector<T> operator + (const Vector<T>& A, const Vector<T>& B)
{
	Vector<T> result = A;
        result += B;
        return result;
}

template<class T>
Vector<T> operator - (const Vector<T>& A, const Vector<T>& B)
{
	Vector<T> result = A;
        result -= B;
        return result;
}

template<class T>
Vector<T> operator * (const Vector<T>& A, const T& x)
{
	Vector<T> result = A;
        result *= x;
        return result;
}

template<class T>
Vector<T> operator * (const T& x, const Vector<T>& A)
{
	Vector<T> result = A;
        result *= x;
        return result;
}

template<class T> Vector<T> operator / (const Vector<T>& A, const T& x)
{
	Vector<T> result = A;
        result /= x;
        return result;
}

template<class T> T dot(const Vector<T>& x, const Vector<T>& y)
{
 	T result(0);
	for (unsigned i = 0; i < x.size(); i++) {
        	result += x(i) * y(i);
	}
        return result;
}

template<class T> T norm(const Vector<T>& x)
{
	return sqrt(dot(x, x));
}

template<class T> void normalize(Vector<T>& x)
{
	x /= norm(x);
}

int main()
{
	Vector<int> vec(5);

	vec.fill(0);
        cout << vec << endl;
}