Generikus halmaz osztály készítése

Írjon generikus (template) halmaz (set) osztályt, amely

  • Képes elemeket tárolni (insert), addig, amíg el nem fogy a memória. Ha az elem már benne van a halmazban, ne tegye bele kétszer!
  • Eltávolít (remove) egy elemet a halmazból
  • Meg tudja mondani egy elemről, hogy benne van-e a halmazban (isElement)
  • Az osztály legyen átadható érték szerint függvényparaméterként és az s1=s2=s3; értékadás működjön helyesen (s1, s2, s3 ugyanazzal a típussal példányosított set template-ek)!
  • Milyen követelményeket támaszt az osztály a tárolandó típusokkal szemben (pl. alapértelmezett konstruktor rendelkezésre állása)?
  • Írjon egy egyszerű, maximum 10 utasításból álló programrészletet, amely bemutatja az osztály szolgáltatásainak használatát. Hibakezelést nem kell implementálnia!


A megoldásért kattints ide!

 

template<class TYPE>

class Set

{

      TYPE* pData;

      unsigned elements;

 

public:

 

      Set(){ pData=NULL; elements=0;}

      Set(const Set& theOther);

      ~Set() {delete[] pData;}

 

      const Set& operator=(const Set& theOther);

      void insert(const TYPE& element);

      void remove(const TYPE& element);

      bool isElement(TYPE element)const;

};

 

template <class TYPE>

Set<TYPE>::Set(const Set<TYPE> &theOther)

{

      // assert(this!==&theOther);

      pData=NULL;

      elements=0;

      *this=theOther;

}

 

template <class TYPE>

const Set<TYPE>& Set<TYPE>::operator=(const Set<TYPE>& theOther)

{

      // assert(this!==&theOther);

      elements=theOther.elements;

      delete[]pData;

 

      if(elements==0)

      {

            pData=NULL;

            return theOther;

      }

     

      pData=new TYPE [elements];

      for(unsigned int i=0;i<elements;i++)

      {

            pData[i]=theOther.pData[i];

      }

      return theOther;

}

 

template <class TYPE>

void Set<TYPE>::insert(const TYPE& element)

{

      if(isElement(element))return;

 

      TYPE* pTemp= new TYPE[elements+1];

      for(unsigned int i=0; i<elements; i++)

      {

            pTemp[i]=pData[i];

      }

      pTemp[elements]=element;

      elements++;

      delete[]pData;

      pData=pTemp;

}

 

template <class TYPE>

void Set<TYPE>::remove(const TYPE& element)

{

      // if(elements==0)return 0; Hibakezelés nem kell.

      // if(isElement())return; Hibakezelés nem kell. Feltesszük benne van.

     

      elements--;

      if(elements==0)

      {

            delete[] pData;

            pData=NULL;

            return;

      }

 

      TYPE* pTemp= new TYPE[elements];

      for(unsigned int i=0, j=0; i<=elements; i++,j++)

      {

            if(pData[i]==element)

            {

                  j--;       

            }

            else

            {

                  pTemp[j]=pData[i];

            }

      }    

      delete[]pData;

      pData=pTemp;

}

 

template <class TYPE>

bool Set<TYPE>::isElement(TYPE element)const

{

      for(unsigned int i=0;i<elements;i++)

      {

            if(element==pData[i])return true;

      }

      return false;

}

 

 

/* main.cpp

 

 

#include <iostream> // a NULL miatt

#include "set.h"

 

using namespace std;

 

int main()

{

      // A tartalmazott elem típusának kell

      //    - tartalmaznia default konstruktort (new-val hozzuk létre)

      //    - helyesen működő operator =-t (másoljuk az elemeket)

 

      Set<int> s1;

      s1.insert(1);

      s1.insert(2);

      s1.insert(3);

 

      Set<int> s2=s1;

      s2.remove(2);

 

      return 0;

}*/




2008.01.05. 10:59:27 |  Permalink  |  Hozzászólások száma: 0  |  Tárgyszavak: Sablonok


Írja meg Ön is véleményét!


Hozzászólásokat csak regisztrált, bejelentkezett felhasználóktól tudunk elfogadni!

Hozzászólások