Главная/

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

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

        return &data[--sp];      }

template <class T,int size> void StackSA<T,size>::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--; }

void main()

{  StackSA<int,20> s;  //стек из 20-ти int

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

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

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

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

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

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

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

template <class T,int size> class StackSA

{  private:

        T               data[size];

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

   public:

        StackSA();

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

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

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

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

                              //результат:если нельзя то [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;    //стек полный

        data[sp]=element;

   return sp++; }

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

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

        return &data[--sp];      }

template <class T,int size> T *StackSA<T,size>::operator[](int num)

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

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

   return &data[num];    }

void main()

{  StackSA<int,20> s;  //стек из 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();}//вытаскиваем эл-ты

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

//3. статический массив

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

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

template <class T,int size> class SArray

{  private:

                T       *data[size];

        public:

        SArray();

     ~SArray();

      void operator+(T *q);

      T* operator[](int i);};

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

{       for(int k=0;k<size;k++) data[k]=NULL;   }

template <class T,int size> SArray<T,size>::~SArray()

{       for(int k=0;k<size;k++) if(data[k]!=NULL) delete data[k]; }

template <class T,int size> void SArray<T,size>::operator+(T *q)

{       for(int k=0;k<size&&data[k]!=NULL;k++);

        if(k==size) return; //нет места в массиве

   for(;k>0&&*data[k-1]>*q;k--) data[k]=data[k-1]; //раздвигаем элементы

   data[k]=q; } //вставляем элемент

template <class T,int size> T* SArray<T,size>::operator[](int i)

{  if(i<0||i>=size) return NULL;

   if(data[i]==NULL) data[i]=new T;

        return data[i]; }

void main()

{  SArray<int,10> a;    //заводим массив указателей на int

        a+new int(5);   a+new int(25);  a+new int(15);  //заносим значения

        int k=*a[1];    }          // получаем значение 15

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

//3. статический массив

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

//2. Поиск и возвращение минимального об"екта.

template <class T,int size> class SArray

{  private:

                T       *data[size];

        public:

        SArray();

     ~SArray();

      T* Min();

      T* operator[](int i);};

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

{       for(int k=0;k<size;k++) data[k]=NULL;   }

template <class T,int size> SArray<T,size>::~SArray()

{       for(int k=0;k<size;k++) if(data[k]!=NULL) delete data[k]; }

template <class T,int size> T* SArray<T,size>::Min()

{  for(int k=0;k<size&&data[k]==NULL;k++); //номер первого не NULL элемента

        int tmp=k++;                            //в tmp

        for(;k<size;k++)

                if(data[k]!=NULL&&*data[k]<*data[tmp]) tmp=k; //поиск минимального

   return data[tmp];  }

template <class T,int size> T* SArray<T,size>::operator[](int i)

{  if(i<0||i>=size) return NULL;

   if(data[i]==NULL) data[i]=new T;

        return data[i]; }

void main()

{  SArray<int,10> a;    //заводим массив указателей на int

        *a[1]=5; *a[4]=3; *a[3]=7;   //заносим значения

        int k=*a.Min();   }           // получаем значение 3

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

//3. статический массив

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

//3. Сортировка (любым методом).

template <class T,int size> class SArray

{  private:

                T       *data[size];

        public:

        SArray();

     ~SArray();

      void Sort();

      T* operator[](int i); };

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

{       for(int k=0;k<size;k++) data[k]=NULL;   }

template <class T,int size> SArray<T,size>::~SArray()

{       for(int k=0;k<size;k++) if(data[k]!=NULL) delete data[k]; }

template <class T,int size> void  SArray<T,size>::Sort()

{       for(int i=0;i<size-1;i++)

        for(int j=i+1;j<size;j++)

        if(data[i]==NULL||(data[j]!=NULL&&*data[j]<*data[i]))   //сравнение

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

template <class T,int size> T* SArray<T,size>::operator[](int i)

{  if(i<0||i>=size) return NULL;

   if(data[i]==NULL) data[i]=new T;

        return data[i]; }

void main()

{  SArray<int,10> a;    //заводим массив указателей на int

        *a[1]=15; *a[4]=9; *a[3]=17;   //заносим значения

        a.Sort();                 //сортируем

        int i=*a[0],j=*a[1],k=*a[2]; } //достаем отсортированнные по возрастанию

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

//3. статический массив

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

//4. Двоичный поиск на основе сравнения с внешним об"ектом-ключом

template <class T,int size> class SArray

{  private:

                T       *data[size];

        public:

        SArray();

     ~SArray();

      T* FindBin(T &key);