Динамическая структура данных

Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

Содержание

• Введение
• 1. Теоретическая часть
• 1.1 Абстрактные типы данных. Линейные списки
• 1.2 Понятие объектно-ориентированного программирования
• 2. Практическая часть
• 3. Тестирование
• Заключение
• Приложение
• Введение

программирование абстрактный линейный алгоритм

Часто в процессе работы с данными невозможно определить, сколько памяти потребуется для их хранения, память следует распределять во время выполнения программы по мере необходимости отдельными блоками. Блоки связываются друг с другом с помощью указателей. Такой способ организации данных называется динамической структурой данных, поскольку она размещается в динамической памяти и ее размер изменяется во время выполнения программы.

Из динамических структур в данной работе используются линейные списки. Динамическая структура, в отличие от массива или записи, может занимать несмежные участки оперативной памяти.

Динамические структуры широко применяют и для более эффективной работы с данными, размер которых известен, особенно для решения задач сортировки.

Элемент любой динамической структуры состоит из двух частей: информационной, ради хранения которой и создается структура, и указателей, обеспечивающих связь элементов друг с другом.

1. Теоретическая часть

1.1 Абстрактные типы данных. Линейные списки

Понятие абстрактных типов данных является ключевым в программировании. Абстракция подразумевает разделение и независимое рассмотрение интерфейса и реализации.

Абстракция данных предполагает определение и рассмотрение абстрактных типов данных(АТД) или, что то же самое, новых типов данных, введенных пользователем.

Абстрактный тип данных -- это совокупность данных вместе с множеством операций, которые можно выполнять над этими данными.

Линейные списки

В линейном списке каждый элемент связан со следующим и, возможно, с предыдущим. В первом случае список называется односвязным, во втором -- двусвязным. Если последний элемент связать указателем с первым, получится кольцевой список.

Каждый элемент списка содержит ключ, идентифицирующий этот элемент. Ключ обычно бывает либо целым числом, либо строкой и является частью поля данных. В качестве ключа в процессе работы со списком могут выступать разные части поля данных. Ключи разных элементов списка могут совпадать.

Над списками можно выполнять следующие операции:

· начальное формирование списка (создание первого элемента);

· добавление элемента в конец списка;

· чтение элемента с заданным ключом;

· вставка элемента в заданное место списка (до или после элемента с заданным ключом);

· удаление элемента с заданным ключом;

· упорядочивание списка по ключу.

Для работы со списком в программе требуется определить указатель на его начало. Чтобы упростить добавление новых элементов в конец списка, можно также завести указатель на конец списка.

1.2 Понятие объектно-ориентированного программирования

По определению авторитета в области объектно-ориентированных методов разработки программ ГрадиБуча «объектно-ориентированное программирование (ООП) - это методология программирования, которая основана на представлении программы в виде совокупности объектов, каждый из которых является реализацией определенного класса (типа особого вида), а классы образуют иерархию на принципах наследуемости» [1].

Объектно-ориентированная методология так же, как и структурная методология, была создана с целью дисциплинировать процесс разработки больших программных комплексов и тем самым снизить их сложность и стоимость.

Объектно-ориентированная методология преследует те же цели, что и структурная, но решает их с другой отправной точки и в большинстве случаев позволяет управлять более сложными проектами, чем структурная методология.

Как известно, одним из принципов управления сложностью проекта является декомпозиция. Гради Буч выделяет две разновидности декомпозиции: алгоритмическую (так он называет декомпозицию, поддерживаемую структурными методами) и объектно-ориентированную, отличие которых состоит, по его мнению, в следующем: «Разделение по алгоритмам концентрирует внимание на порядке происходящих событий, а разделение по объектам придает особое значение факторам, либо вызывающим действия, либо являющимся объектами приложения этих действий» [2].

Другими словами, алгоритмическая декомпозиция учитывает в большей степени структуру взаимосвязей между частями сложной проблемы, а объектно-ориентированная декомпозиция уделяет больше внимания характеру взаимосвязей.

На практике рекомендуется применять обе разновидности декомпозиции: при создании крупных проектов целесообразно сначала применять объектно-ориентированный подход для создания общей иерархии объектов, отражающих сущность программируемой задачи, а затем использовать алгоритмическую декомпозицию на модули для упрощения разработки и сопровождения программного комплекса [3].

ОО-программирование является, несомненно, одним из наиболее интересных направлений для профессиональной разработки программ.

Объекты и классы

Базовыми блоками объектно-ориентированной программы являются объекты и классы. Содержательно объект можно представить как что-то ощущаемое или воображаемое и имеющее хорошо определенное поведение. Таким образом, объект можно либо увидеть, либо потрогать, либо, по крайней мере, знать, что он есть, например, представлен в виде информации, хранимой в памяти компьютера. Дадим определение объекта, придерживаясь мнения Гради Буча: «Объект - осязаемая сущность, которая четко проявляет свое поведение».

Объект -- это часть окружающей нас реальности, т. е. он существует во времени и в пространстве (впервые понятие объекта в программировании введено в языке Simula). Формально объект определить довольно трудно. Это можно сделать через некоторые свойства, а именно: объект имеет состояние, поведение и может быть однозначно идентифицирован (другими словами, имеет уникальное имя).

Класс -- это множество объектов, имеющих общую структуру и общее поведение. Класс -- описание (абстракция), которое показывает, как построить существующую во времени и пространстве переменную этого класса, называемую объектом. Смысл предложений «описание переменных класса» и «описание объектов класса» один и тот же [4].

Объект имеет состояние, поведение и паспорт (средство для его однозначной идентификации); структура и поведение объектов описаны в классах, переменными которых они являются.

Определим теперь понятия состояния, поведения и идентификации объекта.

Состояние объекта объединяет все его поля данных (статический компонент, т.е. неизменный) и текущие значения каждого из этих полей (динамический компонент, т.е. обычно изменяющийся).

Поведение выражает динамику изменения состояний объекта и его реакцию на поступающие сообщения, т.е. как объект изменяет свои состояния и взаимодействует с другими объектами [5].

Идентификация (распознавание) объекта -- это свойство, которое позволяет отличить объект от других объектов того же или других классов. Осуществляется идентификация посредством уникального имени (паспорта), которым наделяется объект в программе, впрочем, как и любая другая переменная.

Выше уже говорилось, что процедурный (а также и модульный) подход позволяет строить программы, состоящие из набора процедур (подпрограмм), реализующих заданные алгоритмы. С другой стороны, объектно-ориентированный подход представляет программы в виде набора объектов, взаимодействующих между собой. Взаимодействие объектов осуществляется через сообщения. Предположим, что нашим объектом является окружность. Тогда сообщение, посланное этому объекту, может быть следующим: «нарисуй себя». Когда мы говорим, что объекту передается сообщение, то на самом деле мы вызываем некоторую функцию этого объекта (компонент-функцию). Так, в приведенном выше примере мы вызовем функцию, которая будет рисовать окружность на экране дисплея [6].

Инкапсуляция

Инкапсуляция - один из основополагающих принципов объектно-ориентированного программирования, идея которого заключается в том, что все свойства и методы объединены в рамках некоторого объекта.

Само название термина "инкапсуляция" происходит от английского слова encapsulate, которое в дословном переводе означает "запечатывать в капсулу" или "покрывать оболочкой". Таким образом объект (капсула) заключает в себе методы и свойства (содержимое) [7].

Понятие инкапсуляции может быть рассмотрено в более широком смысле, далеко выходящим за рамки объектно-ориентированного программирования в целом. Если говорить о инкапсуляции на максимально возможном уровне абстракции, тогда инкапсуляцию можно представить как способность объекта заключать в себе некое множество других объектов. Так применительно к компьютерной программе можно сказать, что она инкапсулирует в себе несколько модулей, каждый из которых в свою очередь инкапсулирует какие-то объекты, которые инкапсулируют в себе методы и свойства, которые, кстати, тоже могут быть объектами, и так далее [8].

Исходя из всего вышеописанного, еще одним представлением инкапсуляции может считаться любая древовидная структура, в которой любой узел дерева инкапсулирует в себе всех своих непосредственных детей, которые могут быть как листьями (примитивы, который не могут ничего в себе инкапсулировать) так и другими узлами.

И все же, если говорить о объектно-ориентированном программировании, тогда инкапсуляция - объединение данных и методов в рамках объекта.

Иногда говоря о инкапсуляции в объектно-ориентированном программировании понятие инкапсуляции приравнивается к понятию "черного ящика" или сокрытию данных, однако это не одно и то же. Да, в некоторых объектно-ориентированных языках программирования при помощи инкапсуляции разработчик может сделать свой объект черным ящиком, однако это реализуется при помощи модификаторов доступа, которые есть не во всех объектно-ориентированных языках программирования. Само понятие инкапсуляции намного шире. И даже более того, мы может все свойства и методы сделать доступными из вне, то есть ни о каком черном ящике и речи идти не может, однако инкапсуляция все еще будет присутствовать в любом объекте. Поэтому сокрытие данных по средствам модификаторов доступа является следствием инкапсуляции но никак не являются тождественно равными понятиями [9].

Чем инкапсуляция заслужила право считаться одним из основных принципов объектно-ориентированного программирования?

Во-первых благодаря инкапсуляции объекты перестали быть просто пользовательскими структурами данных, основная цель которых просто быть логически объединить несколько отдельных типов данных в рамках нового составного типа данных. Благодаря инкапсуляции каждый объект теперь может содержать в себе данные, описывающие состояние объекта, и свое поведение, описанное в виде методов. Другими словами объект в объектно-ориентированном программировании перестал быть примитивным пассивным типом данных, управление которым полностью отдано на откуп внешней среде, но стал обладать собственным поведением, можно даже сказать, некоторой волей и разумом, способностью активно реагировать на внешние воздействия и изменять свое состояние и по своим собственным законам и правилам.

Во-вторых, инкапсуляция дает нам возможность контролировать доступ к данным объекта. Ограничение видимости можно так же рассматривать, как проявление собственной воли объекта - объект сам решает, что из своего поведения или свойств сделать доступным для всех, что сделать доступным только для определенного круга объектов, а что и вовсе сделать сугубо интимным, о чем не будет знать ни один другой объект. Зачем, да за тем, что только сам объект точно знает, как с ним можно работать а как нет. Можно даже сказать о новой философии программирования, где объекты более на предметы, над которыми производятся некоторые действия, а, если можно так сказать, новая форма абстрактного синтетического разума, взаимодействуя с которой можно достичь нужного результата.

И еще раз повторюсь, что именно благодаря инкапсуляции объект может быть наделен некоторой волей, разумом, способностью реагировать на внешние воздействие, а не быть пассивным хранилищем данных.

Наследование.

Наследование -- один из четырёх важнейших механизмов объектно-ориентированного программирования (наряду с инкапсуляцией, полиморфизмом и абстракцией), позволяющий описать новый класс на основе уже существующего (родительского), при этом свойства и функциональность родительского класса заимствуются новым классом.

Другими словами, класс-наследник реализует спецификацию уже существующего класса (базовый класс). Это позволяет обращаться с объектами класса-наследника точно так же, как с объектами базового класса

Простое наследование.

Класс, от которого произошло наследование, называется базовым или родительским (англ. baseclass). Классы, которые произошли от базового, называются потомками, наследниками или производными классами (англ. derivedclass).

В некоторых языках используются абстрактные классы. Абстрактный класс -- это класс, содержащий хотя бы один абстрактный метод, он описан в программе, имеет поля, методы и не может использоваться для непосредственного создания объекта. То есть от абстрактного класса можно только наследовать. Объекты создаются только на основе производных классов, наследованных от абстрактного.

Например, абстрактным классом может быть базовый класс «сотрудник вуза», от которого наследуются классы «аспирант», «профессор» и т. д. Так как производные классы имеют общие поля и функции (например, поле «год рождения»), то эти члены класса могут быть описаны в базовом классе. В программе создаются объекты на основе классов «аспирант», «профессор», но нет смысла создавать объект на основе класса «сотрудник вуза» [10].

Множественное наследование.

При множественном наследовании у класса может быть более одного предка. В этом случае класс наследует методы всех предков. Достоинства такого подхода в большей гибкости. Множественное наследование реализовано в C++. Из других языков, предоставляющих эту возможность, можно отметить Python и Эйфель. Множественное наследование поддерживается в языке UML.

Множественное наследование -- потенциальный источник ошибок, которые могут возникнуть из-за наличия одинаковых имен методов в предках. В языках, которые позиционируются как наследники C++ (Java, C# и др.), от множественного наследования было решено отказаться в пользу интерфейсов. Практически всегда можно обойтись без использования данного механизма. Однако, если такая необходимость все-таки возникла, то, для разрешения конфликтов использования наследованных методов с одинаковыми именами, возможно, например, применить операцию расширения видимости -- «::» -- для вызова конкретного метода конкретного родителя.

Попытка решения проблемы наличия одинаковых имен методов в предках была предпринята в языке Эйфель, в котором при описании нового класса необходимо явно указывать импортируемые члены каждого из наследуемых классов и их именование в дочернем классе.

Большинство современных объектно-ориентированных языков программирования (C#, C++, Java, Delphi и др.) поддерживает возможность одновременно наследоваться от класса-предка и реализовать методы нескольких интерфейсов одним и тем же классом. Этот механизм позволяет во многом заменить множественное наследование -- методы интерфейсов необходимо переопределять явно, что исключает ошибки при наследовании функциональности одинаковых методов различных классов-предков.

2. Практическая часть

Для решения поставленной задачи используется объектно-ориентированная структура программы. Программа представлена двумя классами и основным cpp-файлом, содержащим пользовательский интерфейс для удобства работы со списками.

Класс c List представляет собой линейный односвязный список, состоящий из объектов класса c Element.

Классc Element имеет следующую структуру:

#pragmaonce

#include<iostream>

class cElement

{

private:

int data;

cElement *next;

public:

cElement(void);

cElement(void);

void setdata (int);

int getdata();

void setref (cElement*);

cElement* getref ();

};

Поле data типа int содержит числовое значение элемента списка, поле next типа c Element* - ссылку на следующий элемент списка. Методы set data и get data используются для доступа к приватному полю data класса с целью получения и соответственно установки значения данного поля. Метод set ref используется для установки ссылки с текущего на следующий элемент списка, а get ref - для перехода на следующий элемент.

void cElement::setdata(int sd)

this->data=sd;

int cElement::getdata()

returnthis->data;

void cElement::setref(cElement* rf)

this->next=rf;

cElement* cElement::getref()

returnthis->next;

Реализация данных методов исключительно проста, что видно из их программных кодов, представленных выше.

Теперь рассмотрим структуру класса c List

#pragmaonce

#include"cElement.h"

#include<iostream>

class cList

{

private:

c Element *head;

c Element *p;

int elcount;

public:

cList (void);

cList (void);

void Add (int);

void Print ();

void Del();

void Insert (int, int);

void Remove (int);

void RemoveAll ();

Данный класс содержит ссылку на головной элемент списка - head, типа c Element*. Хранение данной ссылки необходимо для корректного выполнения операций добавления, удаления данных и печати списка. Дело в том что, при выполнении любой из вышеуказанных операций, происходит перебор элементов списка, чтобы дойти до нужного, так как список не имеет произвольного доступа к элементам, поэтому перебор рациональней начинать с "головы" списка. Кроме ссылки на начало списка, каждый объект данного класса будет иметь поле el count, которое содержит количество элементов списка.

Продолжим рассмотрение данного класса с изучения методов, реализованных в нем, для работы со списками.

Метод Add - добавление данных в конец списка.

В качестве параметра данный метод принимает числовое значение (переменная xd), которое нужно сохранить в добавляемый элемент списка.

void cList::Add(int xd)

Так происходит создание нового элемента и установка значения его числового поля:

cElement *temp = newcElement;

temp->setdata(xd);

После осуществляется проверка количества элементов списка, если список пуст, то создается головной элемент, иначе "рядовой" компонент списка:

if (elcount ==0)

temp->setref(NULL);

head=temp;

p=head;

elcount++;

}

else

{

temp->setref(NULL);

p->setref(temp);

p=p->getref();

elcount++;

}

Можно заметить, что в вышеуказанной конструкции используется метод set ref класса c Element, который необходим для установки ссылки на следующий элемент списка, иначе список будет несвязанным, что чревато потерей данных и некорректной работы программы.

При первом запуске программы, описанный выше метод, используется для последовательного добавления элементов в список, с которым затем можно работать, для остановки ввода в командной строке необходимо вместо числового значения элемента ввести команду "stop" (см. рисунок 1).

Рисунок 1 - Процесс добавления элементов в список

После ввода команды "stop", происходит печать списка и программа переходит в режим ожидания команды (см. рисунок 2).

Рисунок 2 - Распечатанный список

Метод Print - печать списка.

Для печати важно знать начало списка, чтобы последовательно распечатать значения всех элементов списка, поэтому в переменную tempустанавливается ссылка на "голову" списка, после чего проверяется факт существования списка и выводится соответствующие сообщение, если он не подтверждается, если же список не пуст, то он выводится на экран:

void cList::Print()

{

C Element * temp = head;

if (temp == NULL) cout <<"***list is empty***"<<endl;

while(temp != NULL)

{

cout << temp->getdata()<<" ";

temp = temp->getref();

}

cout << endl;

}

Метод Del - удаление начального элемента списка.

Для удаления начального элемента необходимо сначала перенести ссылку на следующий компонент списка, сделав его первым, таким образом, и затем уже удалить требуемый элемент:

voidcList::Del()

{

cElement * temp = head;

head = head->getref();

delete temp;

elcount--;

}

Если бы ссылка не была перенесена, то вместе с удаляемым компонентом пропала и она, таким образом, доступ к списку был бы практически утрачен.

Метод Remove All - удаление всего списка.

Данный метод основан на вышеуказанном и заключается в последовательном удалении начальных элементов списка, пока не будет удален весь список.

void cList::Remove All ()

{

while (elcount!=0)

Del ();

}

Для запуска данного метода, в меню работы со списком необходимо ввести команду "dellist" (см. рисунок 3).

Рисунок 3 - Ввод команды на очистку списка

И если пользователь действительно уверен в своих действиях, необходимо принять предложение программы, после чего произойдет удаление всего списка (см. рисунок 4).

Рисунок 4 - Пустой список

Метод Remove - удаление определенного элемента списка.

Менее радикальный метод, чем предыдущий. Удаляется лишь один, указанный в качестве параметра, элемент списка. Происходит это следующим образом: программа сначала проверяет корректность введенного параметра, если номер удаляемого элемента меньше единицы или больше общего числа элементов списка, то она выводит сообщение об ошибке, если же претензий к введенному параметру у программы нет, то переносятся необходимые ссылки элементов, находящихся рядом с удаляемым, так чтобы список остался связанным, после чего происходит удаление требуемого элемента.

void cList::Remove(int del)

{

int j=1;

cElement *cur = head, *de;

if ((del>=1) && (del<=elcount))

if (del==1)

{

head = head->getref();

delete cur;

elcount--;

}

else

{

while (j!=del-1)

{

cur = cur->getref();

j++;

}

de=cur->getref();

if (j==del-1)

{

cur->setref(de->getref());

delete de;

elcount--;

}

else

{

cout<<"Unknown position"<<endl;

system ("pause");

}

Для запуска данного метода, в меню работы со списком необходимо ввести команду "delete". Затем ввести номер удаляемого элемента или же команду "back" для отмены удаления (см. рисунок 5).

Рисунок 5 - процесс удаления элемента списка

Список после удаления четвертого элемента будет выглядеть следующим образом (см. рисунок 6).

Рисунок 6 - Список после удаления одного элемента

Метод Insert - вставка нового элемента в указанное место в списке.

В качестве параметров данный метод принимает: позицию добавляемого элемента и его числовое значение. Новый элемент встанет именно на указанное место, таким образом, элементы находящие справа от текущего будут сдвинуты на одну позицию.

При добавлении нового элемента в начало списка необходимо просто перенести ссылку с данного элемента на следующий, связав тем самым список и указать ссылку на начальный элемент. Несколько другая ситуация возникает при добавлении нового элемента между двумя уже существующими, для этого с помощью цикла дойти до места вставки элемента, затем связать с новым элементом компоненты, находящиеся справа и слева от него.

Ведь что, к примеру, нужно сделать, если необходимо удлинить цепь: необходимо разомкнуть ее, затем прикрепив новое звено к первой части цепи, прицепить к этому же звену вторую, нечто подобное реализуется в данном методе. Стоит отметить, что при указании неверной позиции для добавления, которая меньше единицы или больше общего числа элементов, программа выдаст соответствующие сообщение об ошибке.

void cList::Insert (int pos, int val)

{

int j=1;

cElement *cur = head;

cElement *temp = new cElement;

temp->setdata(val);

if ((pos>=1) && (pos<=elcount))

if (pos==1)

{

temp->setref(head);

head=temp;

elcount++;

}

else

{

while (j!=pos-1)

{

cur = cur->getref();

j++;

}

p=cur->getref();

if (j==pos-1)

{

cur->setref(temp);

temp->setref(p);

elcount++;

}

else

{

cout<<"Unknown position"<<endl;

system ("pause");

}

Для запуска данного метода, в меню работы со списком необходимо ввести команду "insert".

Затем ввести позицию и числовое значение добавляемого элемента или же команду "back" для отмены удаления (см. рисунок 7).

Рисунок 7 - Процесс вставки элемента

Список после добавления в третью позицию элемента со значением 111, список будет выглядеть следующим образом (см. рисунок 8).

Рисунок 8 - Список после добавления элемента

В процессе описания не раз упоминалось меню работы со списком, остается отметить, что данное меню значительно облегчает работу со списком. Алгоритм его работы заключается в циклическом вызове одних и тех же методов, печати списка, например, пока не будет введена определённая команда. Список доступных команд можно увидеть, введя "help"в консоли (см. рисунок 9)

Рисунок 9 - Доступные команды

Полностью программный код меню представлен в приложении А.

3. Тестирование

Часто в процессе работы возникают ситуации, связанные с некорректным вводом данных, что может вызвать выход из строя программы. Разумеется, в каждой программе должны быть реализованы алгоритмы защиты от неопытного пользователя, предостерегающие программу от сбоя. Рассмотрим, каким образом функционируют такие алгоритмы в созданной программе.

Первоначальный ввод списка реализуется представленным ниже кодом:

cout<<"Enter the list elements (enter 'stop' to complete the input):"<<endl;

while (strstr(ss,"stop")==NULL)

{

cin>>ss;

if (atoi(ss)!=NULL)

mylist.Add(atoi(ss));

}

Перед вызовом метода add для добавления нового элемента в список, осуществляется проверка введенной строки. Функция atoi переводит строковое значение в числовое и возвращает NULL в случае, если введенная строка не является числом. Таким образом, при вводе будут игнорироваться любые строки не являющиеся числами, кроме строки с командой остановки ввода (см. рисунок 10).



Рисунок 10 - Ввод некорректных данных

После ввода таких данных, список будет выглядеть следующим образом (см. рисунок 11).

Рисунок 11 - Полученный список

Программа продолжает корректно работать после, даже после ввода ошибочных данных. Аналогичные методы борьбы с некорректными данными используются, при остальных операциях ввода, присутствующих в программе.

Заключение

В данной работе были получены понятия об абстрактные типах данных, о принципах их представления в современных языках программирования, в С++ в частности. В большинстве современных императивных языков основной концепцией, используемой для описания абстракций в программном коде, является объектно-ориентированный подход. Объектно-ориентированное программирование (ООП) также, как и подход к программированию на основе АТД, является, в некоторой степени, развитием идей о модульном программировании. Модули - это компоненты программы, которые имеют два важных свойства:

Модули скрывают в себе детали реализации.

Модули могут быть повторно использованы в различных частях программы.

Дэвид Парнас в своей работе 1972 года, представлял модули как абстрактные машины, хранящие внутри себя состояния и позволяющие изменять это состояние посредством определенного набора операций. Эта концепция является базовой, как для концепции абстрактных типов данных, так и для объектно-ориентированного программирования. Проведя параллели между работой Парнаса и современных понятиях ООП, нетрудно заметить взаимосвязь понятий класс и модуль.

В данной работе, линейные односвязные списки, являющие собой абстрактный тип данных, представлены разработанными модулями, для доступа к состояниям которых также реализованы специальные операции, называемые методами в объектно-ориентированном программировании.

Приложение

Программный код меню

#include<windows.h>

#include<iostream>

#include<stdio.h>

#include<fstream>

#include"cList.h"

#include"string.h"

usingnamespace std;

int main ()

{

int com_ind=0;

cList mylist;

char ss[255],com[255];

cout<<"Enter the list elements (enter 'stop' to complete the input):"<<endl;

while (strstr(ss,"stop")==NULL)

{

cin>>ss;

if (atoi(ss)!=NULL)

mylist.Add(atoi(ss));

}

system ("cls");

while (strstr(com,"exit")==NULL)

{

cout<<"Your list:"<<endl;

mylist.Print();

cout<<"Enter the comand:"<<endl;

cin>>com;

if (strstr(com,"help")!=NULL) com_ind=1;

if (strstr(com,"add")!=NULL) com_ind=2;

if (strstr(com,"insert")!=NULL) com_ind=3;

if (strstr(com,"delete")!=NULL) com_ind=4;

if (strstr(com,"dellist")!=NULL) com_ind=5;

switch (com_ind)

{

//nothing

case 0:

{

system ("cls");

break;

}

//help menu

case 1:

{

system ("cls");

cout<<"Next commands are available:"<<endl;

cout<<"add - to add elements to the end of list"<<endl;

cout<<"insert - to insert elements in any position in list "<<endl;

cout<<"delete - to delete elemets by number"<<endl;

cout<<"dellist - to remove all elements from list"<<endl;

cout<<"exit - for exit"<<endl;

cout<<"-"<<endl;

com_ind=0;

break;

}

//add elements

case 2:

{

cout<<"Enter the element (enter 'back' to return to the main menu):"<<endl;

cin>>ss;

if (strstr(ss,"back")==NULL)

if (atoi(ss)!=NULL)

mylist.Add(atoi(ss));

com_ind=0;

system ("cls");

break;

}

//insert elements

case 3:

{

int pos;

cout<<"Enter the position to insert (enter 'back' to return to the main menu):"<<endl;

cin>>ss;

if (strstr(ss,"back")==NULL)

{

if (atoi(ss)!=NULL)

pos=atoi(ss);

}

else

{

com_ind=0;

system ("cls");

break;

}

cout<<"Enter the number of element (enter 'back' to return to the main menu):"<<endl;

cin>>ss;

if (strstr(ss,"back")==NULL)

if (atoi(ss)!=NULL)

mylist.Remove(atoi(ss));

com_ind=0;

system ("cls");

break;

}

//remove list

case 5:

{

cout<<"Are you sure (yes/no):"<<endl;

cin>>ss;

if (strstr(ss,"yes")!=NULL)

mylist.RemoveAll();

com_ind=0;

system ("cls");

break;

}

mylist.RemoveAll();

system ("pause");

}

Размещено на Allbest.ru

...