Структура данных "очередь". максимально доступно. и очень подробно объяснить функции с очередью!!!на с++ с указателями

#ifndef __QUEUE_H
#define __QUEUE_H
#define MaxQueue 100 // максимальное количество элементов в очереди
#include<iostream.h>
#include<stdlib.h>

template < class T >
class Queue
{
protected:
int Len; // Длина очереди
T* P; // Указатель на массив, представляющий собой очередь указателей на T
public:
Queue():Len(0),P(NULL) {} // конструктор по умолчанию
Queue(Queue< T >* a); // конструктор копирования
~Queue() {if(P) delete [] P; P=NULL;} // деструктор
int Delete(); // удаление первого элемента в очереди [last index]
void Destroy(); // удаление всех элементов в очереди
Queue< T >* object() { return this; } // вернуть адрес объекта
int len() { return Len; } // вернуть размер очереди
T operator[](int i); // вернуть указатель элемент с индексом i из очереди
T first() { return P[0]; } // вернуть указатель на первый элемент из очереди
int Insert(T elem); // постановка элемента в очередь по указателю
void print(); // вывод содержимого очереди
void p(); // вывод содержимого очереди
};

template < class T > // описание функции вывода содержимого очереди
void Queue< T >::print()
{ cout << "Queue элемент - Begin:\n";
cout << "this=" << this << "\nLen=" << Len << "\nP=" << P << endl;
if(P>0&&Len>0) for(int i=0;i<len;++i)> // описание функции вывода содержимого очереди
void Queue< T >::p()
{
if(P>0&&Len>0) for(int i=0;i < Len;++i) cout << P[ i ];
}

template < class T > // описание функции удаления первого элемента в очереди
int Queue< T >::Delete()
{
if(Len <= 0) return 1; // очереди нет!
T* temp=new T[--Len];
if(!temp) exit(1); // аварийный выход из-за нехватки памяти
for(int i=0;i < Len;i++) temp[ i ]=P[i+1];
if(P) delete [] P;
P=temp;
return 0;
}

template < class T > // описание функции удаления всех элементов в очереди
void Queue< T >::Destroy()
{
while(Len>0) Delete();
}

template < class T > // описание конструктора копирования
Queue< T >::Queue(Queue<t>* a)
{ int i;
if(a!=NULL)
{
Len=a->Len;
P=new T[Len];
if(!P) cerr << "Не хватило памяти при копировании AV!\n",exit(1);
for(i=0;i < Len;++i) P[ i ]=a->P[ i ];
}
else
Len=0,P=NULL;
}

template < class T >
T Queue< T >::operator[](int i)
{
if(i < 0||i >= Len) cerr << "Ошибка неверный индекс Queue\n",exit(1);
return P[ i ];
}

template < class T > // описание функции постановки элемента в очередь
int Queue< T >::Insert(T elem)
{ int i;
if(++Len > MaxQueue) { --Len; return 1; } // очередь переполнена!
T* temp=new T[Len];
if(!temp) { --Len; return 2; } // для нового элемента не хватило памяти!
for(i=0;i < Len-1;i++) temp[ i ]=P[ i ];
if(P) delete [] P;
P=temp; P[ i ]=elem;
return 0;
}

#endif /* __QUEUE_H */

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

Что значит "доступно"? Структура "очередь" означает: первый пришёл - первым ушёл. Не путать со структурой стека: первым пришёл - последним ушёл. Это похоже на детскую пирамидку (последний вставленый элемент уйдёт первым) . Что конкретно-то надо?

Нужно больше конкретных вопросов.