Класс односвязного списка структур - C++ - Ответ 474401

#include <iostream.h>
 
//Оболочка список
class List{
private:
 
//Описание узла списка
struct Node {
int data;
Node *next;
Node *prev;
};
//-------------------------------------------------------------
 
Node *pbeg;          //начало списка
Node *pend;          //конец списка
int size;            //размер списка
 
public:
//Функции автоматизации----------------------------------------
List(){pbeg = NULL; pend =NULL; size = 0;} //Конструктор по умолчанию создаёт пустой список
List(int d);
List(const List&p);
virtual~ List();
//-------------------------------------------------------------
int popb();                //выборка из начала  
int find(int key);         //найти в списке
long add(int d);           //Добавить в конец списка           
const List& operator = (const List&p);
 
//Дополнителные фишки------------------------------------------
List& operator >>(int&d);      //альтернатива добавлению в конец
List& operator <<(int&d);      //альтернатива выборке
inline int getsize() const { return size; }    //получение размера
 
inline bool isEmpty()const { if(pbeg!=NULL)return 0; else return 1; }  //проверка существования списка
void Update();            //отчищает весь список: делает полную выборку из начала
};
 
//-------------------------------------------------------------
List::List(int d){
size = 0;           
Node *pv = new Node; //Созаём узел
pv->data=d;
pv->next = NULL;     //признак конца списка
pv->prev = NULL;     //признак начала списка
//Формируем начало и конец списка
pbeg=pv;
pend = pbeg;
size++;              //увеличиваем размер, один узел создан
//-------------------------------
}
 
//Конструтор копирования----------
List::List(const List&p){
//Если копировать не от куда, то есть передаваемы объект список пуст
//Ничего не делаем, создаём как: конструктор по умолчанию
if(p.pbeg==NULL||p.pend==NULL){
pbeg = NULL;
pend = NULL;
size=0;
}
 
//Иначе создаём список и копируем в него другой список
else { 
    
pbeg = NULL; //обнуляем
pend = NULL; //обнуляем
 
//Создаём начало-------------------
{
Node * pv = new Node;
pv->data=p.pbeg->data;  //копируем данные из начала
pv->next = NULL;      //Cледёющего ещё нет
pv->prev = NULL;      //предыдущего нет
pbeg = pv;            //форируем начало
pend = pbeg;          //формируем конец
}
 
{
//Формируем оставшиусь часть списка путём копирования элементов из драгого списка
Node *tmp = p.pbeg;
tmp=tmp->next;       //первый узел пропускаем
while(tmp){
//Добавляем в конец нового списка узлы
Node *pv = new Node ; //создаём новый узел
pv->data=tmp->data;     //копируем данные
pv->next = NULL;      //следующего пока нет
pv->prev = pend;      //новый связывается с последним
pend->next=pv;        //последний связывается с новым
pend =pv;             //новый становится последним
tmp=tmp->next;        //cледующий
}
 
}
 
//---------------------------------
size = p.size;  //копируем счётчик
}
 
}
 
//Операция присваивания-------------
 
const List& List::operator = (const List&p){
 
if(&p==this)return *this;    //проверка на самоприсваивание 
//Если не чего присваивать--------------------------------
if(p.pbeg==NULL||p.pend==NULL)return *this;
 
//Иначе создаём список и копируем в него другой список
else { 
Update();     //отчищаем список
 
pbeg = NULL;  //обнуляем
pend = NULL;  //обнуляем
 
//Создаём начало-------------------
{
Node * pv = new Node;
pv->data=p.pbeg->data;       //копируем данные из начала
pv->next = NULL;     //Cледующего ещё нет
pv->prev = NULL;     //предыдущего нет
pbeg = pv;           //форируем начало
pend = pbeg;         //формируем конец
}
 
{
//Формируем оставшуюся часть списка путём копирования элементов из другого списка
Node *tmp = p.pbeg;
tmp=tmp->next;        //первый узел пропускаем
 
//проходим по списку с которого копируем
while(tmp){
//Добавляем в конец нового списка узлы
Node *pv = new Node ; //создаём новый узел
pv->data=tmp->data;     //копируем данные
pv->next = NULL;      //следующего пока нет
pv->prev = pend;      //новый связывается с последним
pend->next=pv;        //последний связывается с новым
pend =pv;             //новый становится последним
tmp=tmp->next;        //cледующий
}
 
}
 
//---------------------------------
size = p.size;  //копируем счётчик
 
}
 
return *this ;               //возвращаем себя
 
}
 
 
 
 
 
//Деструктор-----------
List::~List(){
Update();     //отчищаем весь список если в нём что то есть
 
}
 
 
//Добавить в конец списка  
long List::add(int d){
//Если список не создан создаём 
if(pbeg==NULL){
size = 0;           
Node *pv = new Node; //Созаём узел
pv->data=d;
pv->next = NULL;     //признак конца списка
pv->prev = NULL;     //признак начала списка
//Формируем начало и конец списка
pbeg=pv;
pend = pbeg;
size++;              //увеличиваем размер, один узел создан
return 0;            //создали первую структуру
}
    
//Иначе добавляем в конец списка    
else{
Node *pv = new Node;    
pv->data=d;
pv->next = NULL;
 
pv->prev = pend;   //cвязываемся с конецом списка
pend->next = pv;   //конец связывается с новым узлом
pend=pv;           //концом становится новый узел
size++;            //увеличиваем размер, оузел добавлен в конец
return 1;          //добавили в конец  
}
 
 
}
 
//Добавление в конец: альтернатива
List& List::operator >>(int&d){
add(d);
return *this;
 
}
 
//выборка из начала
int List::popb(){
Node * pv = NULL;  //создаём указатель
//Если список не пуст
pv=pbeg;          //получаем узел из начала
int data(0);      //переменная через которую возвращаем значение
//Если есть что удалять
if(pv!=NULL){
pbeg=pbeg->next;   //следующий в начало
data=pv->data;     //получаем данные из начала
delete pv;         //удаляем узел: старое начало
size--;            //уменьшаем счётчик размера
return data;       //возвращаем полученные данные
}
//----------------------------------------------------------------
return data;       //если список пуст
 
}
 
//альтернатива выборке
List& List::operator <<(int&d){
d=popb();    
return *this;
 
}
 
//отчистак всего списка
void List::Update(){
//Пока не пуст делаем выборку---
while(!isEmpty()){
    popb();
}
 
}
 
//поиск----------------------------
int List::find(int key){
Node *tmp = pbeg;  //получаем узел из начала
int t(0);         //просто на всякий случай для возврата
//Перемещаемся от начала к концу--------------------
while(tmp){
if(tmp->data==key)return tmp->data;  //если ключ совпал, возвращаем данные
tmp=tmp->next;                     //следующий во временный указатель
}
//--------------------------------------------------
return t;          //Если не нашли
 
}
 
 
 
 
 
 
 
//Клиент------------
void main(){
return;
}
//------------------