Borland C++ 6.0 Builder + szablony

Witam, mam problem.
Przepisalem sobie z ksiazki Jerzego Grebosza jeden przyklad, zeby sprawdzic, czy lista jest rzeczywiscie tworzona "na koncu", mniejsza o przyczyny... problem jest taki, ze w borland C++ builderze 6.0 jak chce zbudowac projekt, to wywala mi takie bledy:

[C++ Warning] osoba.h(20): W8058 Cannot create pre-compiled header: code in header
[Linker Error] Unresolved external 'operator <<(_STL::basic_ostream<char, _STL::char_traits<char> >&, Dlista<osoba>&)' referenced from C:\FAVORITY\GREBOSZ001\GLOWNY.OBJ

a oto jak wygladaja pliki:
glowny.cpp

#include <iostream.h>
#include <string.h>

#include "osoba.h"
#include "Dlista.h"
#include <iomanip.h>


int main(void)
{
	osoba
		skarbD("stary Dab"),
		skarbG("Glaz nad strumieniem"),
		skarbA("Ambona mysliwska"),
		skarbW("Wyspa"),
		skarbKP("Kurchan"),
		skarbKA("kamieniolom");

	Dlista<osoba> trasa;

	iteratorL<osoba> druzynowy(trasa);

	trasa.wstaw(skarbD, druzynowy);
	trasa.wstaw(skarbG, druzynowy);
	trasa.wstaw(skarbA, druzynowy);

	trasa.wstaw(skarbW, 1);

	trasa.wstaw(skarbKP, druzynowy);

	cout<<trasa;

	cout<<"Zmieniamy wyspe..."<<endl;

	trasa.usun(1);
	
	druzynowy.na_wezel(3);
	trasa.wstaw(skarbW,druzynowy);

	cout<<trasa;
	cout<<"iteratory...."<<endl;

	iteratorL<osoba> druh(trasa), harcerka(trasa);

	druh.na_koniec();

	cout<<"Harcerka:			Druh:"<<endl;
	for(int i =0; i < trasa.rozmiar(); i++, harcerka++)
	{
		cout<<setw(20)<<*harcerka<<" "<<setw(20)<<*(druh--)<<endl;
	}
	
	return 0;
}

osoba.h:

#include <string.h>

class osoba
{
	char nazwisko[30];
	
	public:

	osoba(char *n=NULL)
	{
		strcpy(nazwisko, n);
	}

	friend ostream & operator<<(ostream &s, const osoba &o);

	friend ostream & operator<<(ostream &s, const osoba *wsk);
};

ostream &operator<<(ostream &s, const osoba &o)
{
	s<< o.nazwisko ;
	return s;
}

ostream &operator<<(ostream &s, const osoba *wsk)
{
        s<< wsk->nazwisko ;
	return s;
}

Dlista.h:

template <class typOBJ>
class iteratorL;


template <class typOBJ>
class Dlista
{
	public:
		struct wezel
		{
			typOBJ * wskobj;
			wezel *nastepca;
			wezel *poprzednik;

			wezel():nastepca(NULL), wskobj(NULL), poprzednik(NULL)
			{}
		};
	private:
		wezel *pierwszyW;
		wezel *ostatniW;
		int dlugosc;

	public:
		typedef iteratorL<typOBJ> itLis;

		Dlista()
		{
			pierwszyW = ostatniW = NULL;
			dlugosc = 0;
		}

		~Dlista();

		void wstaw(typOBJ &obj, itLis & iter);

		void wstaw(typOBJ &obj, int nr)
		{
			itLis iter(*this);
			iter.na_wezel(nr);
			wstaw(obj, iter);
		}

		void wstaw(typOBJ &obj)
		{
			itLis iter(*this);
			iter.zakoniec();
			wstaw(obj, iter);
		}

		void usun(itLis &iter);

		void usun(int nr)
		{
			itLis it(*this);
			usun(it.na_wezel(nr));
		}

		int rozmiar() const
		{
			return dlugosc;
		}

	private:
		void daje_na_poczatek(wezel *nowyW, itLis &iter);
		void daje_w_srodku(wezel *nowyW, itLis &iter);
		void daje_na_koniec(wezel *nowyW);

		void usuwam_pierwszy(itLis &iter);
		void usuwam_ostatni(itLis &iter);
		void usuwam_ze_srodka(itLis &iter);
	public:
		friend ostream &operator<<(ostream &stru, Dlista<typOBJ> &x);

		friend class iteratorL<typOBJ>;
};

template <class typOBJ>
void Dlista<typOBJ>::wstaw(typOBJ &obj, itLis &iter)
{
	wezel *nowyW = new wezel;

	nowyW->wskobj =&obj;
	dlugosc++;

	if(iter.wybranyW != NULL)
	{
		if(iter.wybranyW == pierwszyW)
		{
			daje_na_poczatek(nowyW,iter);
		}
		else
		{
			daje_w_srodku(nowyW, iter);
		}
	}
	else daje_na_koniec(nowyW);
}

template<class typOBJ>
void Dlista<typOBJ>::daje_na_poczatek(wezel *nowyW, itLis &iter)
{
	pierwszyW = nowyW;
	nowyW->nastepca = iter.wybranyW;
	iter.wybranyW->poprzednik = nowyW;
	nowyW->poprzednik = NULL;

	iter.wybranyW = nowyW;
}

template<class typOBJ>
void Dlista<typOBJ>::daje_w_srodku(wezel *nowyW, itLis &iter)
{
	(iter.wybranyW->poprzednik)->nastepca = nowyW;

	nowyW->nastepca = iter.wybranyW;
	nowyW->poprzednik = iter.wybranyW->poprzednik;
	iter.wybranyW->poprzednik = nowyW;
}


template<class typOBJ>
void Dlista<typOBJ>::daje_na_koniec(wezel *nowyW)
{
	if(!pierwszyW)
	{
		pierwszyW = nowyW;
	}
	else
	{
		ostatniW->nastepca = nowyW;
		nowyW->poprzednik = ostatniW;
	}
	ostatniW = nowyW;
}


template<class typOBJ>
void Dlista<typOBJ>::usun(itLis &iter)
{
	if(iter.wybranyW == NULL)return;

	dlugosc--;

	if(iter.wybranyW == pierwszyW)
	{
		usuwam_pierwszy(iter);
	}
	else
	{
		if(iter.wybranyW == ostatniW)
			usuwam_ostatni(iter);
		else
			usuwam_ze_srodka(iter);
	}
}



template <class typOBJ>
void Dlista<typOBJ>::usuwam_pierwszy(itLis &iter)
{
	pierwszyW = pierwszyW->nastepca;
	delete iter.wybranyW;
	iter.wybranyW = pierwszyW;
	if(pierwszyW != NULL) pierwszyW->poprzednik = NULL;
	else ostatniW = NULL;
}



template <class typOBJ>
void Dlista<typOBJ>::usuwam_ze_srodka(itLis &iter)
{
	wezel *poprzW = iter.wybranyW->poprzednik;

	poprzW->nastepca = iter.wybranyW->nastepca;
	(iter.wybranyW->nastepca)->poprzednik = poprzW;
	delete iter.wybranyW;
	iter.wybranyW = poprzW;
}


template <class typOBJ>
void Dlista<typOBJ>::usuwam_ostatni(itLis &iter)
{
	wezel *poprzW = iter.wybranyW->poprzednik;

	poprzW->nastepca = NULL;
	ostatniW = poprzW;
	delete iter.wybranyW;
	iter.wybranyW = NULL;
}


template <class typOBJ>
Dlista<typOBJ>::~Dlista()
{
	itLis iter(*this);
	for(int i =0; i < dlugosc; i++)
	{
		delete (iter++).wybranyW;
	}
}


template <class typOBJ>
ostream &operator<<(ostream &stru, Dlista<typOBJ> &x)
{
	iteratorL<typOBJ> skoczek(x);
	for(int i =0; i < x.rozmiar(); i++)
	{
		stru<< i <<" "<<*(skoczek++)<<" ";
		if(!( (i+1)%3 ))
		{
			stru<<endl;
		}
	}
	stru<<endl;
	return stru;
}



template <class typOBJ>
class iteratorL
{
	friend class Dlista<typOBJ>;

	Dlista<typOBJ>::wezel *wybranyW;

	Dlista<typOBJ> & pojemnik;

	public:

        iteratorL(Dlista<typOBJ> &pojem) : pojemnik(pojem)
        {
                wybranyW = pojemnik.pierwszyW;
        }


        iteratorL &na_poczatek()
        {
	        wybranyW=pojemnik.pierwszyW;
	        return *this;
        }

        iteratorL &na_koniec()
        {
	        wybranyW=pojemnik.ostatniW;
	        return *this;
        }

        iteratorL &za_koniec()
        {
	        wybranyW=NULL:
	        return *this;
        }

        iteratorL &operator++()
        {
	        wybranyW=wybranyW->nastepca;
	        return *this;
        }

        iteratorL &operator--()
        {
	        wybranyW = wybranyW->poprzednik;
	        return *this;
        }

        iteratorL operator++(int)
        {
	        iteratorL stary = *this;
	        ++*this;
	        return stary;
        }

        iteratorL operator--(int)
        {
	        iteratorL stary = *this;
	        --*this;
	        return stary;
        }

        typOBJ &operator*()
        {
	        return *(wybranyW->wskobj);
        }

        iteratorL &na_wezel(int n);

        iteratorL &operator=(const iteratorL &prawy)
        {
	        wybranyW = prawy.wybranyW;
	        return *this;
        }

        int operator==(const iteratorL &prawy)
        {
	        if(wybranyW == prawy.wybranyW) return 1;
	        else return 0;
        }

        int operator!=(const iteratorL &prawy)
        {
	        if(wybranyW != prawy.wybranyW) return 1;
	        return 0;
        }

        operator int()
        {
	        if(wybranyW!= NULL) return 1;
	        else return 0;
        }

};

template <class typOBJ>
iteratorL<typOBJ> & iteratorL<typOBJ>::na_wezel(int n)
{
	wybranyW = pojemnik.pierwszyW;
	for(int i = 0; i < n; i++, ++(*this));
	return *this;
}

Prosze o pomoc, bo juz kombinuje z tym 3 dni i nic...

Pozdrawiam.