Developing.ru

Код: Выделить всё

class TList
{
 public:
 class TItem;
 class itterator
 {
  private:
   friend class TList;
   friend class TItem;
   TItem *Pointer;
   itterator (TItem *Pointer)
   {
    this->Pointer=Pointer;
   }
  public:
   itterator ()
   {
    Pointer=nullptr;
   }
   itterator operator ++()
   {
    if (Pointer!=nullptr)
    {
     Pointer=Pointer->Next;
    }
   }
   int &operator * ()
   {
    return Pointer->Data;
   }
   bool operator != (const itterator &Right)
   {
    return (Pointer!=Right.Pointer);
   }
 };
 class TItem
 {
  friend class TList;
  friend class TItterator;
  private:
   TItem *Next;
  public:
   int Data;
 };
 private:
  TItem *Start;
  TItem *Last;
 public:
  TList()
  {
   Start=nullptr;
   Last =nullptr;
  }
  ~TList()
  {
   TItem *Next;
   for (Next=Start->Next; Next!=nullptr; Start=Next, Next=Start->Next)
   {
    delete Start;
   }
   Last=nullptr;
  }
  itterator Insert(const itterator &Itterator, const int &Data)
  {
   TItem *Item;
   Item=new TItem;
   Item->Data=Data;
   if (Itterator.Pointer==nullptr)
   {
    if (Start==nullptr)
    {
     Start=Item;
     Last =Item;
    }
    else
    {
     Last->Next=Item;
     Last=Item;
    }
    Item->Next=nullptr;
   }
   else
   {
    Item->Next=Itterator.Pointer->Next;
    Itterator.Pointer->Next=Item;
   }
   return itterator(Item->Next);
  }
  itterator Begin()
  {
   return itterator(Start);
  }
  itterator End ()
  {
   return itterator(nullptr);
  }
};

Код: Выделить всё

#include <exception>
#include <iostream>
#include <locale.h>

using namespace std;

template <typename T>
class TSimpleList
{
public:
	class TNode
	{
	public:
		TNode(): Prev(nullptr), Next(nullptr)
		{
		}
		TNode *Prev, *Next;
		T Data;
	};

	class Iterator
	{
	public:
		Iterator(TNode *n = nullptr, TSimpleList *pList = nullptr)
		{
			m_node = n;
			m_pList = pList;
		}
		void operator++()
		{
			if (m_node != nullptr)
			{
				m_node = m_node->Next;
			}
		}
		bool operator!=(const Iterator& it)
		{
			return (m_node != it.m_node);
		}
		T& operator *()
		{
			if (m_node == nullptr)
			{
				throw exception("Обращение к данным по нулевому указателю");
			} else
				if (m_pList != nullptr && m_node == &m_pList->m_end)
			{
				throw exception("Обращение к итератору завершения списка");
			}
			return m_node->Data;
		}

	private:
		TNode *m_node;
		TSimpleList *m_pList;
	};

	TSimpleList() : m_pFirst(&m_end)
	{
	}
	~TSimpleList()
	{
		// удаление элементов списка
		while (m_end.Prev != nullptr)
		{
			TNode *Last = m_end.Prev;
			m_end.Prev = Last->Prev;
			delete Last;
		}
	}
	Iterator Begin()
	{
		return Iterator(m_pFirst, this);
	}
	Iterator End()
	{
		return Iterator(&m_end, this);
	}
	void Add(const T& data)
	{
		TNode *node = new TNode();
		if (&m_end != m_pFirst)
		{
			TNode *Last = m_end.Prev;
			Last->Next = node;
		} else
		{
			m_pFirst = node;
		}
		node->Next = &m_end;
		node->Data = data;
		m_end.Prev = node;
	}
private:
	TNode m_end,	*m_pFirst;
};

int _tmain(int argc, _TCHAR* argv[])
{
	_tsetlocale(LC_ALL, _T("russian"));

	// Проверка исключения...
	try 
	{
		TSimpleList<long> sl;
		TSimpleList<long>::Iterator it = sl.End();
		cout << *it << ' ';
	}
	catch (exception& ex)
	{
		printf("%s\n", ex.what());
	}

	// Штатный режим работы
	TSimpleList<long> sl;
	TSimpleList<long>::Iterator it;
	sl.Add(10);
	sl.Add(20);
	sl.Add(50);
	sl.Add(100);
	sl.Add(250);

	for (it = sl.Begin(); it != sl.End(); ++it)
	{
		cout << *it << ' ';
	}

	_gettch();

	return 0;
}

Код: Выделить всё

int *operator *()
{
 if (Node==m_end)
 {
  return *nullptr;
 }
 return Node->Data;
}

Код: Выделить всё

struct TListItem
{
  TListItem *Next;
  int Data;
};
TListItem *First;
...
TListItem *p;
for (p=First; p!=nullptr; p=p->Next
{
 ...
}
(*p).Data=...

Код: Выделить всё

int *Data=new int [1024];
...
int *p;
for (p=Data; p<=Data+1023; ++p)
{
 ...
}
*p=...