Главная/

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

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

T;

        return data[i]; }

template <class T> void DArray<T>::Del(int i)

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

   if(data[i]==NULL) return;

        data[i]=NULL;   }

void main()

{  DArray<int> a(30);    //заводим массив указателей на int

        *a[0]=500; *a[1]=98; *a[2]=17;   //заносим значения

        a.Del(0); a.Del(1); a.Del(2);   }       //удаляем

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

//4. динамический массив

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

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

template <class T> class DArray

{  private:

        int  size;

                T       **data;

        public:

        DArray(int _size);

     ~DArray();

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

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

{  size=_size;

        data=(T**) new char[sizeof(T*)*size];

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

template <class T> DArray<T>::~DArray()

{       delete data; }

template <class T> T* DArray<T>::operator[](int i)

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

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

        return data[i]; }

void main()

{  DArray<int> a(20);    //заводим массив указателей на int

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

        int i=*a[4];    i=*a[6];        i=*a[1];        } //получаем значения

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

//4. динамический массив

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

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

template <class T> class DArray

{  private:

                T       *data;

        int size,sp;

        public:

        DArray(int _size);

     ~DArray();

      void operator+(T q);

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

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

{  size=_size;  sp=0;

        data=(T*) new T[size];

   for(int i=0;i<size;i++) data[i]=0;   }

template <class T> DArray<T>::~DArray()

{       delete [] data; }

template <class T> void DArray<T>::operator+(T q)

{       if(sp>=size) return;

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

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

template <class T> T* DArray<T>::operator[](int i)

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

        return &data[i];        }

void main()

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

   int x=5,y=99,z=7;

        a+x;    a+y;    a+z;  //заносим значения

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

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

//4. динамический массив

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

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

template <class T> class DArray

{  private:

                T        *data;

        int  size;

        public:

        DArray(int _size);

     ~DArray();

      T* Min();

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

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

{  size=_size;

        data=(T*) new T[size];

   for(int i=0;i<size;i++) data[i]=0;    }

template <class T> DArray<T>::~DArray()

{       delete [] data; }

template <class T> T* DArray<T>::Min()

{       int tmp=0;

        for(int k=1;k<size;k++)

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

   return &data[tmp];  }

template <class T> T* DArray<T>::operator[](int i)

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

        return &data[i];        }

void main()

{  DArray<int> a(3);    //заводим массив указателей на int

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

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

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

//4. динамический массив

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

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

template <class T> class DArray

{  private:

        int  size;

                T        *data;

        public:

        DArray(int _size);

     ~DArray();

      void Sort();

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

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

{  size=_size;

        data=(T*) new T[size];

   for(int i=0;i<size;i++) data[i]=0;    }

template <class T> DArray<T>::~DArray()

{       delete [] data; }

template <class T> void  DArray<T>::Sort()

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

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

        if(data[j]<data[i])   //сравнение

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

template <class T> T* DArray<T>::operator[](int i)

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

        return &data[i];        }

void main()

{  DArray<int> a(5);    //заводим массив указателей на int

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

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

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

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

//4. динамический массив

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

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

template <class T> class DArray

{  private:

        int  size;

                T        *data;

        public:

        DArray(int _size);

     ~DArray();

      T* FindBin(T &key);

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

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

{  size=_size;

        data=(T*) new T[size];

   for(int i=0;i<size;i++) data[i]=0;    }

template <class T> DArray<T>::~DArray()

{       delete [] data; }

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

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

   while(a<=b)

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

      while(data[m]==NULL&&m>a) m--;

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

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

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

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

template <class T> T* DArray<T>::operator[](int i)

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

        return &data[i];        }

void main()

{  DArray<int> a(15);    //заводим массив указателей на int

        *a[0]=5; *a[1]=9