problem z szablonem

0

witam,
mam projekt do napisania, klasa stosu na szablonach.Wcześniej napisałem juz klase stosu, teraz musze to przerobic na szablony, zrobilem to, ale mam jakis blad, i nie moge go zlokalizowac:
Plik naglowkowy:

template <class T>
class Stos
{
      public:
            Stos();              //Konstruktor domyślny
            Stos(T wart, int rozmiar);      //Konstruktor z parametrem
            Stos(const Stos<T> &copy);    //Konstruktor kopiujący
            ~Stos();             //Jawny destruktor
            friend std::ostream & operator<< (std::ostream &exit, Stos<T> &s)//Drukowanie zawartosci
            {
                   std::cout<<"Zawartosc stosu:"<<std::endl; 
                   int a=s.licznik-1;
                   if(a==-1) 
                             std::cout<<"Stos jest pusty"<<std::endl;
                   else
                       while(a!=-1)
                       {
                         std::cout<<s.bufor[a]<<",";
                         a--;
                       }
                   std::cout<<std::endl;
                   std::cout<<"Ilosc elementow stosu: "<<s.count()<<std::endl;
                   std::cout<<"Rozmiar stosu: "<<s.akt_size<<std::endl;
                   std::cout<<std::endl;
                   return exit;
            }
            Stos operator+(const Stos<T> &b)const; //dodawanie stosow
            Stos& operator+=(T wart); //dodawanie elementu
            Stos& operator-=(T& zmienna); //zdejmowanie elementu
            int count();  //Funkcja zlicza ilość elementów stosu
      private:
            T *bufor; //stos
            int licznik; //licznik elementow
            T* init(int rozmiar); //alokuje bufor w pamieci
            T* check_mem();  // sprawdza i wedle potrzeby zwieksz/pomniejsza stos
            int main_size; //rozmiar poczatkowy stosu
            int akt_size;  //rozmiar stosu
};

plik.cc:

#include"klasa.h"
template <class T>
Stos<T>::Stos()  //Konstruktor domyślny stosu
{    
            bufor=init(10); //inicjuje bufor o rozmiarze 10
}

template <class T>
Stos<T>::Stos(T wart, int rozmiar) //Konstruktor z parametrem
{     
            bufor=init(rozmiar);//inicjuje bufor o zadanym rozmiarze
            *this+=wart; // dodaje element wart
}

template <class T>
Stos<T>::Stos(const Stos<T> &copy) //Konstruktor kopiujący
{  
            bufor=init(copy.main_size); //inicjuje bufor o rozmiarze copy
            while(licznik<copy.licznik)
                  *this+=copy.bufor[licznik];//przepisuje elementy
}

template <class T>
Stos<T>::~Stos()  //Destruktor
{
           delete[] bufor; //usuwam bufor
}

template <class T>
Stos<T> Stos<T>::operator+(const Stos<T> &b)const //Dodawanie 2óch stosów
{
           Stos<T> wynik(*this);
           int stop=b.licznik;
           for (int count=0; count<stop; count++)            
                  wynik+=b.bufor[count];
           return wynik;  
}

template <class T>
Stos<T>& Stos<T>::operator+=(T wart)//Dodaje element do stosu
{
           bufor[licznik]=wart;
           licznik++;
           bufor=check_mem();
           return *this;              
}

template <class T>
Stos<T>& Stos<T>::operator-=(T &zmienna) //Zdejmuje element ze stosu
{
           if(licznik!=0)
           {                        
                  licznik--;
                  zmienna=bufor[licznik];
                  bufor=check_mem();
           }else
                  std::cout<<"Stos jest pusty"<<std::endl;       
           return *this;
}
template <class T>
int Stos<T>::count()
{
           return licznik;
}  
template <class T>
T* Stos<T>::init(int rozmiar)
{
           main_size=rozmiar;   //domyslnie dalem 10 elementow 
           akt_size=main_size;  
           licznik=0;
           return new T[rozmiar];    
}
template <class T>
T* Stos<T>::check_mem()
{
           if (licznik < akt_size - main_size - 1 && akt_size > main_size)
           {
                     akt_size -= main_size;
                     T* tmp;
                     int count;
                     tmp=new T[akt_size];        
                     for(count=0;count<licznik;count++)
                             tmp[count]=bufor[count];
                     delete bufor;
                     return tmp;
           }else
            if (licznik>=akt_size-1)
            {
                      akt_size += main_size;
                      T* tmp;
                      int count;
                      tmp=new T[akt_size];        
                      for(count=0;count<licznik;count++)
                          tmp[count]=bufor[count];
                      delete bufor;
                      return tmp;   
            }  
           return bufor; 
}

dostaje taki blad:

g++ klasa.o testuj.o -o projekt1
Undefined first referenced
symbol in file
Stos<int>::operator-=(int&) testuj.o
Stos<int>::Stos(int, int) testuj.o
Stos<int>::Stos(Stos<int> const&) testuj.o
Stos<int>::operator+(Stos<int> const&) consttestuj.o
Stos<int>::count() testuj.o
Stos<int>::~Stos() testuj.o
Stos<int>::Stos() testuj.o
Stos<int>::operator+=(int) testuj.o
ld: fatal: Symbol referencing errors. No output written to projekt1
collect2: ld returned 1 exit status

no zabijcie mnie, ale nie wiem czemu, jak znam życie, to penie jakis banal, jakby ktos znalazl, to pls help ...
pozdro

0

To są template'y... Przenieś to co jest w pliku .cc do pliku .h, po deklaracji klasy Stos. W pliku używającym klasy Stos dajesz tylko #include "xxx.h" i kompilujesz. Możesz też bawic się opcjami kompilatora albo w explicit instantiation...

1 użytkowników online, w tym zalogowanych: 0, gości: 1