pole

Naučíme tě pracovat na home-office.

Zjistit více...

c-plus-plus

#include <iostream>
#include <cstdlib>

using namespace std;

template <typename T, int n>
class UsporadanePole
{
  public:
    unsigned int velikost;
    unsigned int iterator;
    T* pole;
    void swapf(T &, T &);
    T & find(const T &,int,int);

  public:
    UsporadanePole();
    ~UsporadanePole(){delete [] pole;}
    UsporadanePole & operator<<(const T &);
    bool operator-=(const T &);
    unsigned int operator()() const {return velikost;}
    const T *najit(const T & prvek){return &find(prvek,0,velikost+1);}
    bool prvni();
    bool dalsi();
    const T & aktual(){return pole[iterator];}
};



template <typename T, int n>
void UsporadanePole<T,n>::swapf(T & a, T & b)
{
  T c = a;
  a = b;
  b = c;
}

template <typename T, int n>
T & UsporadanePole<T,n>::find(const T & prvek, int b, int e)
{
  int med = (e + b) / 2;
  if(prvek > pole[med])
  {
    if(med == b)
      return *((T*)0);
    else
      return find(prvek,med,e);
  }
  else if(prvek < pole[med])
  {
    if(med == e)
      return *((T*)0);
    else
      return find(prvek,b,med);
  }
  else
    return pole[med];
}

template <typename T, int n>
UsporadanePole<T,n>::UsporadanePole() : velikost(0), iterator(0)
{
  pole = new T[n];
}

template <typename T, int n>
UsporadanePole<T,n> & UsporadanePole<T,n>::operator<<(const T & prvek)
{
  if(velikost < n)
  {
    if(!najit(prvek))
    {
      pole[velikost] = prvek;
      for(int i=velikost;i>0 && pole[i]<pole[i - 1];i--)
        swapf(pole[i], pole[i - 1]);
      velikost++;
    }
  }
  return *this;
}

template <typename T,int n>
bool UsporadanePole<T,n>::operator-=(const T & prvek)
{
  const T* p = najit(prvek);
  if(!p)
    return false;
  else
  {
    for(int i = p - pole;i<velikost - 1;i++)
      swapf(pole[i],pole[i + 1]);
    velikost--;
    return true;
  }
}

template <typename T,int n>
bool UsporadanePole<T,n>::prvni()
{
  iterator = 0;
  if(velikost == 0)
    return false;
  else
    return true;
}

template <typename T,int n>
bool UsporadanePole<T,n>::dalsi()
{
  if(iterator < velikost - 1)
    iterator++;
}

Neformátovaný

Přidáno: 12.12.2012
Expirace: Neuvedeno

Autor: Onda.Zadnik