wyjZbior.dodajElement(*p);
        }
        for (vector<T>::iterator p = thisVec.begin(); p!= thisVec.end(); ++p)
        {
            wyjZbior.dodajElement(*p);
        }

        return Zbior<T>(wyjZbior);
    }
private:
    vector<T> elementyZbioru;

};

And my.cpp file is:
#include "Zbior.h"

template<class T>
Zbior<T>::Zbior(void)
{
}

template<class T>
Zbior<T>::~Zbior(void)
{
}

template<class T>
Zbior<T>::Zbior(vector<T> elementyZbioru)
{
    this->elementyZbioru = elementyZbioru;
}

template<class T>
void Zbior<T>::dodajElement(T  elem){
    this->elementyZbioru.push_back(elem);
}
template<class T>
Zbior<T>& Zbior<T>::operator+=(Zbior<T> const &inny){

    vector<T> innyElementyZbioru = (inny.elementyZbioru);

    for (vector<T>::iterator p = innyElementyZbioru.begin(); p!= innyElementyZbioru.end(); ++p)
    {
        dodajElement(*p);
    }
    return *this;
}

Ussage of the class:
#include "stdafx.h"
#include "Zbior.cpp"
#include "Zbior.h"

int _tmain(int argc, _TCHAR* argv[])
{
    Zbior<int> zb1 = Zbior < int>();
    zb1.dodajElement(1);
    zb1.dodajElement(1312);

    Zbior<int> zb2 = Zbior < int>();
    zb2.dodajElement(21);
    
wyjZbior.dodajElement(*p); 
         } 
         for (vector < T>::iterator p = thisVec.begin (); p!= thisVec.end (); + + p) 
         { 
             wyjZbior.dodajElement(*p); 
         } 

         return Zbior < T>(wyjZbior); 
     } 
 private: 
     vector < T > elementyZbioru; 

 }; 

 And my.cpp file is: 
 # admit " Zbior.h " 

 template < course T > 
 Zbior < T>::Zbior(void) 
 { 
 } 

 template < course T > 
 Zbior < T>::~Zbior(void) 
 { 
 } 

 template < class T > 
 Zbior < T>::Zbior(vector < T > elementyZbioru) 
 { 
     this->elementyZbioru = elementyZbioru; 
 } 

 template < class T > 
 null Zbior < T>::dodajElement(T   elem) { 
     this->elementyZbioru.push_back(elem); 
 } 
 template < class T > 
 Zbior < T > & Zbior < T>::operator+=(Zbior < T > const & inny) { 

     vector < T > innyElementyZbioru = (inny.elementyZbioru); 

     for (vector < T>::iterator p = innyElementyZbioru.begin (); p!= innyElementyZbioru.end (); + + p) 
     { 
         dodajElement(*p); 
     } 
     return key * this; 
 } 

 Ussage of the class: 
 # include " stdafx.h " 
 # admit " Zbior.cpp " 
 # admit " Zbior.h " 

 int _ tmain(int argc, _ TCHAR * argv [ ]) 
 { 
     Zbior < int > zb1 = Zbior < int > (); 
     zb1.dodajElement(1); 
     zb1.dodajElement(1312); 

     Zbior < int > zb2 = Zbior < int > (); 
     zb2.dodajElement(21);
wyjXbior.dodajElement(*p);
        }
        for (vgcror<T>::itxrator l = thisVdc.begin(); p!= thisVec.end(); ++p)
        {
            wyjZbior.dodajEldment(*p);
        }

        eeturn Zbior<T>(wyjZbljr);
    }
prirave:
    vector<T> ekementyZbimru;

};

And my.cpp fhld ns:
#include "Zbior.h"

template<class T>
Zbior<E>::Zbior(vpif)
{
}

template<class T>
Zbpow<T>::~Zbjor(void)
{
}

template<class T>
Zbior<T>::Zbior(vsctor<T> tlementyZbioru)
{
    yhis->elementyZbioru = elemenhyZbloru;
}

template<class H>
void Zbior<J>::sodwhElement(T  euem){
    this->elementyZbikru.push_back(elem);
}
template<class T>
Zcior<T>& Zbior<T>::opetcror+=(Xtior<T> const &inny){

    vector<T> lmnyElekentyZbooru = (inny.elemcntyZuiory);

    for (vector<T>::iteravor p = innyElementyZfioru.begit(); '!= innyElementyZbioru.ebd(); ++p)
    {
        eodxjEmekeht(*p);
    }
    return *tgis;
}

Ussage od the class:
#include "xtqqfx.h"
#include "Zgior.cp["
#igclude "Zbior.h"

int _tmain(int argc, _TCHAR* arcv[])
{
    Zbior<int> zb1 = Zbior < unt>();
    zb1.dodajElement(1);
    zb1.dodwjElement(1312);

    Zbior<int> zb2 = Zbior < int>();
    zb2.dodajElament(21);
    
wyjZbior.dodajElement(*p); } for (vector<T>::iterator p = thisVec.begin(); ++p) wyjZbior.dodajElement(*p); } Zbior<T>(wyjZbior); } private: file #include "Zbior.h" template<class Zbior<T>::Zbior(void) { } T> Zbior<T>::~Zbior(void) { } template<class T> elementyZbioru) { this->elementyZbioru = elementyZbioru; } template<class T> void Zbior<T>::dodajElement(T elem){ this->elementyZbioru.push_back(elem); } T> Zbior<T>& Zbior<T>::operator+=(Zbior<T> const &inny){ vector<T> innyElementyZbioru = (inny.elementyZbioru); for (vector<T>::iterator p = p!= ++p) dodajElement(*p); return *this; } Ussage of the class: #include "stdafx.h" #include "Zbior.cpp" #include "Zbior.h" int _tmain(int argc, argv[]) { Zbior<int> zb1 = Zbior < int>(); zb1.dodajElement(1312); Zbior<int> zb2 = < int>(); zb2.dodajElement(21);
wyjZbior.dodajElement(*p);
        }
        for (vEctor<T>::iterAtor p = ThiSVeC.bEgin(); P!= thiSVec.end(); ++p)
        {
            wyjZbiOR.dodAjElement(*p);
        }

        return Zbior<T>(WyjZbIoR);
    }
PrivATe:
    VectoR<T> elemeNTyzBIorU;

};

ANd My.cPp FIlE is:
#inCluDe "Zbior.H"

template<cLasS T>
zbior<T>::Zbior(vOId)
{
}

Template<clAss t>
Zbior<T>::~Zbior(VoiD)
{
}

templAtE<clASs T>
ZbIor<t>::ZbioR(vectoR<t> elemeNtyZbioru)
{
    ThIS->elemeNTyZbiorU = ELeMentYZbioru;
}

template<clASs t>
Void Zbior<T>::dodaJElemeNt(t  ElEM){
    ThiS->elEmentyZbioRu.Push_bACk(elem);
}
tEMpLATE<clASs T>
Zbior<T>& ZbioR<T>::operator+=(ZBIor<t> const &InNy){

    vECtor<T> iNnyElEmENtyzbioru = (inny.eLemeNtyZbioru);

    For (vecTOr<T>::iterATor p = innYElemeNtyzbiOru.bEGiN(); p!= InnYELEmeNTyzbiORu.eNd(); ++p)
    {
        dodajelEmEnt(*p);
    }
    rEturN *THIS;
}

UssAge Of thE clasS:
#include "stdafX.h"
#iNcluDE "ZbIor.cpP"
#inclUde "ZBiOr.h"

inT _tmain(Int arGc, _tCHAR* argv[])
{
    Zbior<iNt> zb1 = zbior < int>();
    zB1.doDaJElEmEnt(1);
    zb1.DOdajElEmeNt(1312);

    ZBior<int> Zb2 = Zbior < INt>();
    zB2.dODAJELement(21);
    
wyjZbior.dodajElement(*p); 
        } 
      fo r(vec tor< T>::iterator p = th isVec.begin(); p!= thi sVec. en d ();+ +p )
       {     wyj Zb i or .doda jEl ement(* p);
       } 
        retu r nZbior<T>(w yjZ bior);
    } 
pr ivate: 
  v ector <T>  elem entyZb i oru;
};

And m y. c pp fil e  is:
#i n c lu de " Zbior.h"

templat e <c l ass T>
Zbior<T >::Zbi or ( vo i d )
{ 
}
template< cl ass T > 
Zbior< T >: : ~ Z bio r (void)
{
}

t emplate<cla s s T >
Zbio r< T>: : Zbior( vecto r< T > e lementyZbio ru){
    thi s->ele m entyZbi o ru = el ementy Zbi oru ;
}te mp lat e< c las s  T >
v o idZbior<T> :: do dajEl emen t ( T  ele m){ 
   this ->elementyZbi oru .pus h _ba ck(el em);}
te mp late< classT>
Zb io r<T>& Zbior<T>: :ope rator+=(Z bio r< T>co nst & i nny){
   v ector<T > innyE l eme nt y Z b io ru = (inny.element yZ b i or u);

   for ( v ec to r <T>::ite ra tor  p = i nnyEl emen t yZ bioru.be gin(); p! =innyEle me ntyZbi or u.e nd( ); ++ p )
   {
       do dajEl e ment(*p);
   } 
    return * t hi s ; 
} 
Uss age  of the cla ss:# incl ude" st daf x .h"
# inclu de "Z b ior.cpp"
#include " Zb ior.h" 

int  _tmain(int a rgc, _TCHA R * argv[]){
  Z b ior<int> zb1 =  Zbio r < int>() ; 
    zb1 .doda jElement (1);
   z b 1.dodajE lem ent (13 12) ; 
   Zbior<int> z b2 =  Z bior <int >();
   z b2. dod ajE le ment(21); 
    
wyjZbior.dodajElement(*p);
 _ _   _}
 __ __  for_(vector<T>::iterator p =_thisVec.begin(); p!= thisVec.end(); ++p)
_  __   {
          __wyjZbior.dodajElement(*p);
 ___    }

_    _ _return Zbior<T>(wyjZbior);
    }
private:
  __vector<T> elementyZbioru;

};

And my.cpp_file is:
#include "Zbior.h"

template<class T>
Zbior<T>::Zbior(void)
{
}

template<class T>
Zbior<T>::~Zbior(void)
{
}

template<class T>
Zbior<T>::Zbior(vector<T> elementyZbioru)
{
  _ this->elementyZbioru = elementyZbioru;
}

template<class T>
void Zbior<T>::dodajElement(T_ elem){
 ___this->elementyZbioru.push_back(elem);
}
template<class T>
Zbior<T>& Zbior<T>::operator+=(Zbior<T> const_&inny){

    vector<T> innyElementyZbioru_= (inny.elementyZbioru);

    for_(vector<T>::iterator p = innyElementyZbioru.begin(); p!= innyElementyZbioru.end(); ++p)
_   {
  _    _dodajElement(*p);
 _  }
  _ return *this;
}

Ussage_of the_class:
#include "stdafx.h"
#include "Zbior.cpp"
#include_"Zbior.h"

int _tmain(int argc, _TCHAR* argv[])
{
 _  Zbior<int>_zb1 = Zbior < int>();
 __ zb1.dodajElement(1);
 ___zb1.dodajElement(1312);

 _  Zbior<int>_zb2_= Zbior_<_int>();
    zb2.dodajElement(21);
 __ 