Главная/

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

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

{       StackDA<int> s(20);  //стек из 20-ти int

   s.Push(78); s.Push(10); s.Push(5);  //укладываем данные

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

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

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

// 2. хранение объектов

// 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 T[size];     //выделение памяти

   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

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

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

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

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

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

// 2. хранение объектов

// 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]

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

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

     ~StackDA(void);    };

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

{       size=_size;

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

   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> void StackDA<T>::Exclude(int num)

{       if(sp==0||num>=sp||num<0)return;//стек пустой или номер слишком большой

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

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

{       delete [] data;    }

void main()

{       StackDA<int> s(20);  //стек из 20-ти int

   s.Push(35); s.Push(11); s.Push(89); //укладываем данные

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

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

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

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

// 2. хранение объектов

// 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 T[size];     //выделение памяти

   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

   s.Push(54); s.Push(23); s.Push(87); //укладываем данные

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

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

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

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

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

// 1. включение элемента с сохранением упорядоченности

template <class T, int size> class StackSA

{  private:

        T                *data [size];          //cтатический МУ на данные

      int               sp;       //кол-во элементов

   public:

        StackSA();

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

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

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

template <class T, int size> StackSA<T, size>::StackSA()

{       sp=0;   }

template <class T, int size> int StackSA<T, size>::Push(T &element)

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

   for(int k=0;k<sp&&element<*data[k];k++);

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

        data[k]=&element;

   return sp;   }

template <class T, int size> T *StackSA<T, size>::Pop(void)

{  if(sp==0