шаблон класса

 
// лаб_2.cpp: определяет точку входа для консольного приложения.
//
 
#include "stdafx.h"
 
#include <iostream>
#include <conio.h>
 
using namespace std;
 
 
class Array  {
public:
    /*конструктор по умолчанию*/
    Array() {                                                                           //конструктор по умолчанию. Создаем массив размера 10.
        maxSize = 10;                                                                   //максимальный размер массива
        count = 0;                                                                      //текущее количество элементов пусто
        pArr = new long[maxSize];                                                       //выделяем память
        Clear();                                                                        //обнуляем каждый элемент массива
    }
    /*конструктор с параметрами*/
    Array(int size)  {                                                                  //конструктор с параметрами. Позволяет создать массив заданного размера
        maxSize = size;                                                                 //переданное значение размера массива установим как максимальный размер
        count = 0;                                                                      //элементов нет
        pArr = new long[maxSize];                                                       //выделяем память
        Clear();                                                                        //нулим элементы    
    }
    /*конструктор копирования*/ 
    Array(const Array &obj)  {                                                          //конструктор копирования. Позволяет инициализировать объект другим объектом. пример: Array a(10); Array b(a); Теперь "b" содержит все элементы "a"
        maxSize = obj.maxSize;                                                          //перепишем все поля из передаваемого объекта в наш новый который создаем
        count = obj.count;
        pArr = new long[maxSize];                                                       //выделяем такой же размер памяти
        for(int i = 0; i < count; i++)                                                  //поэлементно перепишем содержимое, оставляя соответствие количества элементов
            pArr[i] = obj.pArr[i];
    }
    /*деструктор*/
    ~Array()  {                                                                         //чистим память
        delete []pArr;
    }
    /*Функции*/
    void Push_Back(long value)  {                                                       //добавление элемента в массив, в случае необходимости массив расширяем
        count++;
        if(count - 1 < maxSize)                                                     //если место в массиве есть, просто запишем в конец новый элемент, увеличив счетчик элементов.
            pArr[count - 1] = value;
        else  {                                                                         //если достигли предела
            maxSize += 10;                                                              //размер массива увеличим на 10 элементов
            pArr = (long*)realloc(pArr, maxSize * sizeof(long));                        //перевыделим памяти нового размера
            pArr[count - 1] = value;                                                    //добавим за последним элементом
        }
    }
    long Pop_Back()  {                                                                  //выброс последнего добавленного элемента в массиве
        if(count == 0)                                                                  //если элементов нет, вернем -1
            return -1;
        count--;                                                                        //в противном случае уменшаем счетчик элементов
        long temp = pArr[count];                                                        //запоминаем последний элемент
        pArr[count] = NOT_USED;                                                         //затираем этот элемент в массиве
        return temp;                                                                    //выбрасываем значение элемента
    }
    void Clear()  {                                                                     //обнуление элементов массива
        count = 0;
        for(int i = 0; i < maxSize; i++)
            pArr[i] = NOT_USED;
    }
    int GetCount()  {                                                                   //функция возвращающая кличество элементов в массиве
        return count;
    }
    int getMaxSize()  {                                                                 //функция возвращающая текущую, максимальную вместимость массива
        return maxSize;
    }
/* op!*/    void operator!()  {                                                                 //перегруженный унарный оператор "!". Осущетсвляет сортировку массива
        int buff;
        for(int i = 0; i < count; i++)  {
            for(int j = i + 1; j < count; j++)  {
                if(pArr[i] > pArr[j])  {
                    buff = pArr[i];
                    pArr[i] = pArr[j];
                    pArr[j] = buff;
                }
            }
        }
    }
    bool Find(long key)  {                                                              //проверяет вхождение элемента в массив
        for(int i = 0; i < count; i++)  {
            if(pArr[i] == key)
                return true;
        }
        return false;
    }
/*op=*/ Array &operator=(const Array &obj)  {                                               //перегруженный оператор "=". Позволяет присваивать объекты типа "Array" друг другу
        if(this == &obj)                                                                //если переданный объект тот же куда и записываем
            return *this;                                                               //просто вернем его
        delete []pArr;                                                                  //иначе чистим память
        maxSize = obj.maxSize;                                                          //задаем новый размер массива
        count = obj.count;                                                              //перепишем количество элементов из передаваемого объекта в новый
        pArr = new long[maxSize];                                                       //выделим памяти нового размера
        Clear();                                                                        //почистим созданный массив
        for(int i = 0; i < count; i++)                                                  //поэлементно перепишем содержимое
            pArr[i] = obj.pArr[i];
        return *this;                                                                   //вернем новый массив
    }
/*op+*/ Array operator+(const Array &obj)  {                                                //перегруженный оператор "+". Позволяет складывать объекты типа "Array"
        Array temp(maxSize + obj.maxSize);                                              //создаем временный объект, который будет содержать в результирующие массивы
        temp.count = count + obj.count;                                                 //количество элементов будет равно сумме элементов в обоих массивах
        for(int i = 0; i < count; i++)                                                  //копируем элементы из массива слева от знака равно
            temp.pArr[i] = pArr[i];
        for(int i = 0; i < obj.count; i++)                                              //копируем элементы из массива справа от знака равно
            temp.pArr[i] = obj.pArr[i];
        return temp;                                                                    //вернем полученный объект
    }
/*<<*/  friend ostream &operator <<(ostream &os, const Array &obj)  {                       //перегруженный оператор вывода в поток, позволит выводить объекты как встроенные
        os << "MaxSize: " << obj.maxSize << endl;                                       //покажем всю информацию о массиве
        os << "Current size: " << obj.count << endl;
        os << "Elements: ";                                                             //если есть элементы, напечатаем их
        os << ((obj.count > 0) ? "" : "Array is empty\n");
        for(int i = 0; i < obj.count; i++)
            os << obj.pArr[i] << ((i < obj.count - 1) ? " " : "");
        os << endl;
        return os;                                                                      //вернем поток
    }               
/*>>*/  friend istream &operator >>(istream &is, const Array &obj)  {                       //оператор ввода из потока
        for(int i = 0; i < obj.count; i++)  {                                           //вводим каждый элемент массива поэлементно, с учетом его текущего количества элементов
            cout << "Arr[" << i << "] = ";                                              //фактически мы просто заменяем содержимое массива
            is >> obj.pArr[i];
        }
        return is;                                                                      //вернем поток
    }
 
protected:
    int maxSize;                                                                        //максимальный размер массива для заполнения без перераспределения памяти
    int count;                                                                          //количество элементов в массиве
    long *pArr;                                                                         //указатель на область памяти содержащую массив
    static const long NOT_USED = 0;                                                     //статическая константа которая будет использоваться как показатель незанятости ячейки
};
 
 
class Vector:public Array  {
public:
    Vector(){}
    Vector(int size):Array(size) {}
    Vector(const Vector &obj):Array(obj.maxSize) {                                      //конструктор копирования для случая вектор-вектор
        count = obj.count;
        for(int i = 0; i < count; i++)                                                  //поэлементно перепишем содержимое, оставляя соответствие количества элементов
            pArr[i] = obj.pArr[i];
    }
    Vector(const Array &obj):Array(obj) {}                                              //инициализация вектора массивом
    long &operator[](int index) {                                                       //доступ к элементам массива по индексу. С учетом границ. Перегрузка оператора [].
        if(count == 0)  {                                                               //если в массиве нет элементов
            count++;                                                                    //будем считать что один элемент все же есть, заполним его нулем и вернем на него ссылку
            pArr[0] = NOT_USED;
            cout << "Array is empty, use zeroth element\n";                             //при этом укажем что массив пуст, ну раз уже обратились на запись в массив, то получите ссылку на первый элем.
            return pArr[0];
        }
        else  {                                                                         //если в массиве все же есть элементы
            if(index < count && index >=0)                                              //проверим находимся ли мы в пределах границ
                return pArr[index];                                                     //вернем ссылку
            else  if(index < 0){                                                        //если задали отриц границу
                cout << "Index of array too small, use zeroth elementn\n";              //сообщим что ошибочный индекс
                return pArr[-1];                                                            //и вернем ссылку на нулевой элемент
            }
            else  {                                                                     //если индекс не отрицательный и при этом не попадаем в границы, значит индекс больше положенного
                cout << "Index of array too big, use last element\n";                   //сообщим об этом и вернем ссылку на последний элемент массива
                return pArr[count - 1];
            }
        }
    }
};
 
 
int main()  {
    char key;                                                           //ключи меню
    int index;                                                          //индекс будем хранить тут
    long value, _key;                                                   //переменная для добавления и поиска
    Vector a;
 
    do  {
        system("cls");                                                  //чистим экран
        cout << a << endl;                                              //перегруженный оператор "<<" вывода в поток, позволяет работать с нашим классом как со встроенным типом
        cout << "1. Push_Back\n";
        cout << "2. Pop_Back\n";
        cout << "3. operator[]\n";
        cout << "4. Sort\n";
        cout << "5. Search\n";
        cout << "6. Clear\n";
        cout << "ESC. Exit\n";
        key = _getch();
        switch(key)  {
            case '1':
                cout << "Press any key: ";
                key = _getch();
                cout << "\nadd code: " << (int)key << endl;
                a.Push_Back(key);                                       //добавление в конец массива
                break;
            case '2':
                cout << "Pop return -> " << a.Pop_Back() << endl;       //выброс последнего добавленного
                break;
            case '3':
                cout << "Index = ";
                cin >> index;
                cout << "Old value = " << a[index] << endl;             //используем оператор индексирования
                cout << "New value = ";
                cin >> value;
                a[index] = value;                                       //работает оператор индексирования
                break;
            case '4':
                !a;                                                     //сортировка массива по возрастанию
                break;
            case '5':
                cout << "Key for search = ";
                cin >> _key;
                cout << _key;
                if(a.Find(_key))                                        //проверка вхождения ключа в массив
                    cout << " found\n";
                else
                    cout << " not found\n";
                break;
            case '6':
                a.Clear();                                              //очистка массива
                break;
            default:
                break;
        }
 
        cout << "Press any key to continue...\n";
        _getch();
    }while(key != 27);
    Vector b(a);
    cin >> b;
    cout << b;
    system("pause");
    return 0;
}

template<typename T>