Кольцевой двунаправленный список. ООП.

[Purr]

С++. Написала программку...но ошибка уже при вводе. Не знаю, какая... Кто сможет, подскажите((

Задание:
1.Реализовать кольцевой двунаправленные список
2.Создать список положительных целых чисел. Конец ввода - ноль
3. Распечатать список в двух направлениях (две самостоятельные функции)
4. Просуммировать четные элементы списка
5.Сформировать на базе исходного два списка: в первый отправить элементы с четными значениями, во второй - с нечетными. распечатать оба списка, после чего их удалить(через указатели)
6. Уничтожить список, освободив выделенную под него память (вот здесь боюсь тоже что-то не так)
7.Создать меню, позволяющее многократно выбирать функции

Прога:

#include <iostream.h>
#include <conio.h>
#include <string.h>
#include <stdio.h>
#include <iomanip.h>
#include <fstream.h>

class TElem
{
	public:
		int a;
		TElem *next, *prev;//ykazateli na sledyuwii i preduiduwii elementi
		friend class TList;
		TElem();
};

TElem::TElem()
{prev=next;}

class TList
{
int count;
TElem *first, *last, *x;//ykazatel na pervii i posl.elementi; x-kuda pomewaem sozd.element
	public:
		TList();
		void sozd();
		void add();
		void read_r();//chtenie sprava nalevo
		void read_l();//chetinie sleva napravo
		void sum_ch();//symmirovanie chetnih chisel
		void two_list();//sozdanir dvux spiskov
		void del();
};

TList::TList()
	{
	count=0;
	first=last=x=NULL;
	}

void TList::sozd()
{
  do
  {
  x=last;
  last=new TElem;
  count++;
  cout << "Vvedite pologitelnii element" << endl;

    do
    {
    cout<< "Vvedite pologitelnoe chislo!" << endl;
    cin >> last->a;
    }
    while(last->a==0 || last->a<0);

  last->next=first;
  last->prev=x;

  if(x==first)
   first->next=last;
  else
   x->next=last;
   }
   while (last->a!=0);
}

void TList::add()
{
int p;
TElem *l, *r;
count=0;

cout <<"Vvedite poziciy"<<endl;
	do
	{
	cin>>p;
	}
	while(p<=1 || p>count);
l=first;
for(int i=1;i<p-1;i++)
	l=l->next;
r=l->next;
x=new TElem;
count++;

cout<<"Vvedite element"<<endl;
cin>>x->a;
x->next=r;
x->prev=l;
l->next=x;
r->prev=x;
}

void TList::read_r()
{
x=first;
while(x->next!=first)
 {
  cout << x->a;
  x=x->next;
 }
cout<<x->a;//posl.element spiska
}

void TList::read_l()
{
x=last;
while(x!=first)
 {
  cout << x->a;
  x=x->prev;
 }
cout<<x->a;
}

void TList::sum_ch()
{
int sum;
x=first;
	for (int i=0; i<=count; i++)
	{
	 if(x->a/2==0)
	 sum+=x->a;
	 x=x->next;
	}
cout << "Summa chetnix chisel = " << sum << endl;
}

void TList::two_list()
{
TList b, c;
x=first;
do
{
if(x->a/2==0)
  {
  b.x=b.last;
  b.last=x;
  b.count++;
  b.last->a=x->a;
  b.last->next=b.first;
  b.last->prev=b.x;

  if(b.x==b.first)
   b.first->next=b.last;
  else
   b.x->next=b.last;
   }
else
 {
  c.x=c.last;
  c.last=x;
  c.count++;
  c.last->a=x->a;
  c.last->next=c.first;
  c.last->prev=c.x;

  if(c.x==c.first)
   c.first->next=c.last;
  else
   c.x->next=c.last;
   }
x=x->next;
}while(x!=first);
}


void TList::del()
{
 x=first;
 while (x!=last)
  {
  x=first;
  first=first->next;
  first->prev=last;
  last->next=first;
  delete x;
  x=NULL;
  count--;
  }
 delete last;
 count--;
 cout<<"Dlina spiska: "<<count;
 }

void main()
{
clrscr();
TList a;
TList *y;
y=new TList;

int t;
do
 {
 cout << "Vvedite cifry:1-prochitat' file sprava; 2-prochitat` file sleva; 3-dobavit';4-sozd; 5-ydalit`"<< endl;
 cin>>t;
	switch(t)
	{
	case 1:a.read_r(); break;
	case 2:a.read_l(); break;
	case 3:a.add(); break;
	case 4:a.sozd(); break;
	case 5:a.del(); break;
	 }
 getch(); clrscr();
 }
while(t!=0);
//a.read();

getch();
delete y;
}

[sergey.d]

http://www.programmersforum.ru/showt...EF%E8%F1%EE%EA

Здесь похожая тема, есть реализация. Если очень надо, могу переделать ациклический в циклический.

[Purr]

Это платно? просто я просмотрела и понимаю, что не понимаю... Мы не так учились писать на С++ и мне трудно ориентироваться.

[sergey.d]

Ча сделаем.. Айн момент...

[sergey.d]

Момент несколько затянулся... Вот, сделал сам список, печать туда-сюда и разделение на четные/нечетные. Остальное уж сами, ок?

#include <iostream>
#include <assert.h>

    template<typename T>
    class List 
    {
    public:
        class Item 
        {
        public:
            const T &value() const { return _value; }
            const Item *prev() const { return _prev; }
            const Item *next() const { return _next; }

        private: 
            Item(const T &value, Item *prev =0, Item *next =0)
                : _value(value),
                _prev(prev), 
                _next(next) 
            {
                
                if(_prev) _prev->_next = this;
                if(_next) _next->_prev = this;
            }

            ~Item()
            {
                
                if(_prev) _prev->_next = _next; 
                if(_next) _next->_prev = _prev; 
            }

            T _value;           
            Item *_prev;
            Item *_next;

            friend class List;
        };

    public:
        List() :_head(0) { } // создаем пустой список

        ~List() { clear(); } // деструктор очищает список

        void clear() { while(!empty()) remove(_head); } // очистка списка -- удаляем головной элемент пока список не пуст

        bool empty() const { return !_head; } // проверка на отсутствие элементов

        // добавление элемента в хвост списка, возвращает указатель на созданный эл-т
        const Item *add_tail(const T &val)
        {
            return empty() ? (_head = new Item(val), _head->_prev = _head->_next = _head) : new Item(val, _head->_prev, _head);
        }

        // добавление элемента в голову списка, возвращает указатель на созданный эл-т
        const Item *add_head(const T &val)
        {
            return empty() ? (_head = new Item(val), _head->_prev = _head->_next = _head) : _head = new Item(val, _head->_prev, _head);
        }

        const Item *remove(const Item *item) // удаление эл-та, возвращает указатель на следующий за удаленным эл-т
        {
            assert(item); // отладочная проверка на ненулевой указатель
            // Локальный вспомогательный класс -- удаляет эл-т в деструкторе
            class Killer { const Item *_item; public: Killer(const Item *i): _item(i) { } ~Killer() { delete _item; } };
            Killer killer(item); // деструктор будет вызван при завершении функции
            if(_head == item) _head = item->_next == _head ? 0 : item->_next; // если удаляется первый эл-т списка, нужно скорректировать _head
            return item->_next; // возвращаем указатель на следующий за удаляемым эл-т
        }

        const Item *head() const { return _head; }

    private:
        Item *_head; // указатель на голову списка
    };

// Печать в прямом порядке
template<typename T>
void printListForward(const List<T> &list) // печать списка
{
    if(!list.empty())
    {
        const typename List<T>::Item *i = list.head();
        do
        {
            std::cout << i->value() << " ";
            i = i->next();
        }
        while(i != list.head());
    }
}

// Печать в обратном порядке
template<typename T>
void printListBackward(const List<T> &list) // печать списка
{
    if(!list.empty())
    {
        const typename List<T>::Item *i = list.head()->prev();
        do
        {
            std::cout << i->value() << " ";
            i = i->prev();
        }
        while(i != list.head()->prev());
    }
}

// Разделение исходного списка на четные и нечетные компоненты
void splitOddEven (const List<int> &src, List<int> *odds, List<int> *evens)
{
    odds->clear();
    evens->clear();
    if(!src.empty())
    {
        const typename List<int>::Item *i = src.head();
        do
        {
            ((i->value() & 1) ? odds : evens)->add_tail(i->value());
            i = i->next();
        }
        while(i != src.head());
    }
}


int main (void)
{
    List<int> l;
    std::cout << "Enter list of numbers, 0 terminates input:" << std::endl;
    while(true)
    {
        int n;
        std::cout << "? ";
        std::cin >> n;
        if(n) l.add_tail(n); else break;
    }

    std::cout << "List (forward): ";
    printListForward(l);
    std::cout << std::endl;
    std::cout << "List (backward): ";
    printListBackward(l);
    std::cout << std::endl;

    List<int> *l1 = new List<int>();
    List<int> *l2 = new List<int>();
    splitOddEven(l, l1, l2);
    std::cout << "Odds: ";
    printListForward(*l1);
    std::cout << std::endl;
    std::cout << "Evens: ";
    printListForward(*l2);
    std::cout << std::endl;
    delete l1;
    delete l2;
}

[Purr]

огромное спасибо!)))