Главная/

Программирование, базы данных. /

Шпоры по Си++. Шаблоны стандартных структур данных

T *temp=data[j];data[j]=data[i];data[i]=temp; }  } // обмен

template <class T> T *StackDA<T>::FindBin(T &key)

{       int a=0,b=sp-1;     //начало,конец отрезка

   while(a<=b)

   {    int m=(a+b)/2;   //середина

      if(*data[m]==key) return data[m];  //совпало с ключом

      if(*data[m]>key) a=m+1;  //правая часть

                                                else b=m-1; }//левая часть

   return NULL; } //не найден

template <class T> StackDA<T>::~StackDA(void)

{       delete data;    }

void main()

{       StackDA<int> s(20);  //стек из 20-ти указателей на int

   int a=13,b=5,c=7,d=13;

   s.Push(a); s.Push(b); s.Push(c);  //укладываем данные

   s.Sort(); int *k=s.FindBin(d);  } //поиск

//----------------------------------------------------------------------------

// 1. стек представлен динамическим массивом

// 1. хранение указателей на объекты

// 5. включение элемента по номеру

template <class T> class StackDA

{  private:

        T                **data;          //динамический МУ на данные

      int               size,sp;       //размер стека,кол-во элементов

   public:

        StackDA(int _size);

      int Push(T &element);   //результат:если стек полный то [-1]

                                               //иначе, количество элементов

      T *Pop(void);           //результат:если стек пустой то [NULL]

      int Insert(T &element,int num); //включение по номеру

                              //результат:если нельзя то [-1]

                                               //иначе, количество элементов

     ~StackDA(void);    };

template <class T> StackDA<T>::StackDA(int _size)

{       size=_size;

        data=(T**)new char[size*sizeof(T*)];     //выделение памяти под МУ

   sp=0;   }

template <class T> int StackDA<T>::Push(T &element)

{  if(sp==size) return -1;    //стек полный

        data[sp]=&element;

   return sp++; }

template <class T> T *StackDA<T>::Pop(void)

{  if(sp==0) return NULL;     //стек пустой

        return data[--sp];      }

template <class T> int StackDA<T>::Insert(T &element,int num)

{  if(sp==size||num>sp||num<0)

                        return -1;//стек полный или номер слишком большой

   for(int p=++sp;p>num;p--) data[p]=data[p-1];

        data[num]=&element;

   return sp;   }

template <class T> StackDA<T>::~StackDA(void)

{       delete data;    }

void main()

{       StackDA<int> s(20);  //стек из 20-ти указателей на int

   int a=13,b=5,c=7;

   s.Push(a); s.Push(b);  //укладываем данные

   s.Insert(c,1);         //вставляем элемент

   int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();}//вытаскиваем эл-ты

//----------------------------------------------------------------------------

// 1. стек представлен динамическим массивом

// 1. хранение указателей на объекты

// 6. исключение элемента по номеру

template <class T> class StackDA

{  private:

        T                **data;          //динамический МУ на данные

      int               size,sp;       //размер стека,кол-во элементов

   public:

        StackDA(int _size);

      int Push(T &element);   //результат:если стек полный то [-1]

                                               //иначе, количество элементов

      T *Pop(void);           //результат:если стек пустой то [NULL]

      T *Exclude(int num);    //исключение по номеру

                              //результат:если нельзя то [NULL]

     ~StackDA(void);    };

template <class T> StackDA<T>::StackDA(int _size)

{       size=_size;

        data=(T**)new char[size*sizeof(T*)];     //выделение памяти под МУ

   sp=0;   }

template <class T> int StackDA<T>::Push(T &element)

{  if(sp==size) return -1;    //стек полный

        data[sp]=&element;

   return sp++; }

template <class T> T *StackDA<T>::Pop(void)

{  if(sp==0) return NULL;     //стек пустой

        return data[--sp];      }

template <class T> T *StackDA<T>::Exclude(int num)

{  if(sp==0||num>=sp||num<0)

                        return NULL;//стек пустой или номер слишком большой

   T *temp=data[num];

   for(int p=num;p<sp-1;p++) data[p]=data[p+1];

   sp--;

   return temp; }

template <class T> StackDA<T>::~StackDA(void)

{       delete data;    }

void main()

{       StackDA<int> s(20);  //стек из 20-ти указателей на int

   int a=13,b=5,c=7;

   s.Push(a); s.Push(b); s.Push(c); //укладываем данные

   int *k=s.Exclude(1);           //вытаскиваем элемент

   int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();}//вытаскиваем эл-ты

//----------------------------------------------------------------------------

// 1. стек представлен динамическим массивом

// 1. хранение указателей на объекты

// 7. поиск и возвращение элемента по номеру

template <class T> class StackDA

{  private:

        T                **data;          //динамический МУ на данные

      int               size,sp;       //размер стека,кол-во элементов

   public:

        StackDA(int _size);

      int Push(T &element);   //результат:если стек полный то [-1]

                                               //иначе, количество элементов

      T *Pop(void);           //результат:если стек пустой то [NULL]

      T *operator[](int num); //взятие по номеру

                              //результат:если нельзя то [NULL]

     ~StackDA(void);    };

template <class T> StackDA<T>::StackDA(int _size)

{       size=_size;

        data=(T**)new char[size*sizeof(T*)];     //выделение памяти под МУ

   sp=0;   }

template <class T> int StackDA<T>::Push(T &element)

{  if(sp==size) return -1;    //стек полный

        data[sp]=&element;

   return sp++; }

template <class T> T *StackDA<T>::Pop(void)

{  if(sp==0) return NULL;     //стек пустой

        return data[--sp];      }

template <class T> T *StackDA<T>::operator[](int num)

{  if(sp==0||num>=sp||num<0)

                        return NULL;//стек пустой или номер слишком большой

   return data[num];    }

template <class T> StackDA<T>::~StackDA(void)

{       delete data;    }

void main()

{       StackDA<int> s(20);  //стек из 20-ти указателей на int

   int a=13,b=5,c=7;

   s.Push(a); s.Push(b); s.Push(c); //укладываем данные

   int *k=s[1];           //берем элемент

   int *pa=s.Pop(),*pb=s.Pop(),*pc=s.Pop();}//вытаскиваем эл-ты

//----------------------------------------------------------------------------

// 1. стек представлен динамическим массивом