Разреженный массив

#include <iostream>
#include <conio.h>
#include <windows.h>
#include <assert.h>
#include <math.h>
using namespace std;
 
// Класс, определяющий один элемент, хранящийся в разреженном массиве:
template <class Type> class SparseList;
template <class Type> class SparseOb
{
    friend class SparseList<Type>;
    // Обратите внимание на то, что класс SparseList предварительно объявлен
    long index; // индекс элемента массива
    SparseOb<Type> *next; // указатель на следующий узел
    SparseOb<Type> *prior; // указатель на предыдущий объект
    SparseOb() { info = 0; index = -1; next = prior = NULL; }
    // конструктор
public:
    Type info; // элемент данных
    int operator+(int *array, int array_size){ return true; };
};
 
// Класс  списка:
template <class Type>
class SparseList
{
    SparseOb<Type> *start, *end; // указатели на начало и конец списка
public:
    SparseList() { start = end = NULL; }
    ~SparseList();
    SparseOb<Type> * store(long ix, Type c); // добавление элемента
    void remove(long ix); // удаление элемента
    // возвращение указателя на элемент по заданному индексу:
    SparseOb<Type> * find(long ix);
};
 
// Параметризованный класс разреженного массива:
template <class Type>
class SparseArray : public SparseList<Type>
{
    long length; // размер массива
public:
    SparseArray(long size = 0) : length(size) {} // конструктор
    Type& operator [](long i); // операция [ ]
};
 
// Определение функций:
// Деструктор:
template <class Type> SparseList<Type>::
~SparseList()
{
    SparseOb<Type>* p, *p1;
    // удаление всех элементов списка:
    p = start;
    while (p)
    {
        p1 = p->next;
        delete p;
        p = p1;
    }
}
 
// Добавление элемента в список:
template <class Type> SparseOb<Type> * SparseList<Type>::
store(long ix, Type c)
{
    SparseOb<Type> *p = new SparseOb<Type>;
    assert(p); // проверяем, выделена ли память
    p->info = c;
    p->index = ix;
    if (start == NULL) start = end = p;
    // если добавляется первый элемент списка
    else // добавление элемента в конец списка
    {
        p->prior = end;  end->next = p;  end = p;
    }
    return p;
}
 
// нахождение элемента массива по индексу:
template <class Type> SparseOb<Type> * SparseList<Type>::
find(long ix)
{
    SparseOb<Type> *temp;
    temp = start;
    while (temp)
    {
        if (ix == temp->index) return temp;
        // если найдено вхождение элемента, возвращается указатель на него
        temp = temp->next;
    }
    return NULL; // если нет в списке
}
 
/* Удаление из списка элемента с указанным индексом и
обновление указателей на начало и конец списка: */
template <class Type> void SparseList<Type>::
remove(long ix)
{
    SparseOb<Type> *ob = find(ix); // получаем указатель на элемент
    if (!ob) return; // если элемент не существует
    if (ob->prior) // если удаляется не первый элемент
    {
        ob->prior->next = ob->next;
        if (ob->next)  // если удаляется не последний элемент
            ob->next->prior = ob->prior;
        else // последний
            end = ob->prior;
        delete ob;
    }
    else // удаляется первый
    if (ob->next) // если элемент - не единственный
    {
        ob->next->prior = NULL;
        start = ob->next;
        delete ob;
    }
    else start = end = NULL; // теперь список пуст
}
 
// Индексация в массиве:
template <class Type> Type& SparseArray<Type>::
operator [] (long ix)
{
    if (ix<0 || ix > length - 1)
    {
        cout << "Индекс выходит за пределы области определения\n\n\n";
        system("pause");
        exit(1);
    }
    SparseOb<Type> * p;
    p = find(ix); // получаем указатель на элемент
    if (!p) // эсли это новый элемент
    {
        p = store(ix, 0); // добавляем его в массив со значением 0
    }
    return p->info;
    /* функция возвращает ссылку на эту ячейку, поэтому значение элемента можно изменять */
}
//void line::input();
template <class Type> int SparseOb<Type>::operator+(int *array, int array_size)
{
    int i = 0;
    int buf;
    char swap_cnt = 0;
    if (array_size == 0)
        return (0);
    while (i < array_size)
    {
        if (i + 1 != array_size && array[i] > array[i + 1])
        {
            buf = array[i];
            array[i] = array[i + 1];
            array[i + 1] = buf;
            swap_cnt = 1;
        }
        i++;
        if (i == array_size && swap_cnt == 1)
        {
            swap_cnt = 0;
            i = 0;
        }
    }
    return (array);
}
 
// пример использования разреженного массива:
int main()
{
    //Настройки шрифтов и региональных стандартов: 
    if (SetConsoleCP(1251) == 0)
        //проверка правильности установки кодировки символов для ввода
    {
        cerr << "Fialed to set codepage!" << endl;
        /* если не удалось установить кодовую страницу, вывод сообщения об ошибке */
    }
    if (SetConsoleOutputCP(1251) == 0)//тоже самое для вывода
    {
        cerr << "Failed to set OUTPUT page!" << endl;
    }
    SparseArray <int> iob(7+2); // Объявляем массив целых чисел
    // поместим в массив некоторые значения:
    for (int i = 0; i < 5; i++)
        iob[i] = i + 1;
        iob[2] = iob[3];
        iob[7] = 9345;
        iob[6] = iob[7] + 100;
    // выведем значения элементов на экран:
    cout << "Значения элементов массива:\n";
    for (int i = 0; i<9; i++)   {   cout << iob[i] << " ";  }
    cout << endl;
    ///**********************************
    /// переставляет числа:
    for (int i = 1; i<9; i++)
    {
        int j = i;
        while (j>0 && iob[j]>0 && iob[j - 1] <= 0)
        {
            swap(iob[j], iob[j - 1]); //поменять значения элементов местами
            j--;
        }
    }
    for (int i = 0; i<9; i++)   { cout << iob[i] << " "; }
    int count = 0;
    while (count<9 && iob[count]>0) count++;
    int *a = new int[count];
    operator+(*a, count);
    for (int j = 0; j < count; j++)  cout << a[j] << " ";
    delete[] a;
    system("pause");
    return 0;
}