TList<>

[Fla]

Вот было нечего делать накропал вот такую штуку(когда нечего делать всегда пишу шаблонную гадость). Вдруг кому-нибудь пригодится как пример или как простой класс листа.
Если вы собираетесь хранить указатели на дату(только так осуществляется наследование), то вместо del() rem() и clear() нужно использовать delp() remp() и clearp() соответственно.
Отстутствие утечки памяти не гарантирую.

Собственно код:
TList.h

#pragma once
#include <stdio.h>
#include <assert.h>

template <class T>
struct TListData {
    T data;
    TListData *next, *prev;
};

template <class T>
class TList {
    TListData<T> *head;
    int fcount;
public:
    TList(void);
    ~TList(void);

    void add(T);
    void ins(T, int);
    void del(int);
    void rem(T);
    void clear();

    void delp(int);
    void remp(T);
    void clearp();

    int find(T);
    TListData<T> *getp(int);

    int count();
    T& operator[](int);
};

#include "TList.inl"

TList.inl ДАДА ИМЕННО INL!!!

#include "StdAfx.h"
#include "TList.h"

template <class T> 
TList<T>::TList(void) {
    this->head = NULL;
    this->fcount = 0;
}

template <class T> 
void TList<T>::add(T data) {
    if (!fcount) {
        this->head = new TListData<T>;
        this->head->data = data;
        this->head->next = this->head;
        this->head->prev = this->head;
    } else {
        TListData<T> *nData = new TListData<T>;
        nData->data = data;
        nData->next = this->head;
        nData->prev = this->head->prev;
        this->head->prev = nData;
        nData->prev->next = nData;
    }
    this->fcount++;
}

template <class T> 
void TList<T>::ins(T data, int pos) {
    if (!fcount) {
        this->head = new TListData<T>;
        this->head->data = data;
        this->head->next = this->head;
        this->head->prev = this->head;
    } else {
        TListData<T> *p = this->getp(pos);
        TListData<T> *nData = new TListData<T>;
        nData->data = data;
        nData->next = p;
        nData->prev = p->prev;
        p->prev = nData;
        nData->prev->next = nData;
    }
    this->fcount++;
}

template <class T> 
T& TList<T>::operator [](int id) {
    assert(id<0 || id>=this->fcount || "Incorrect id in TList::operator[]!");
    TListData<T> *p = this->head;
    for (int i = 1; i <= id; i++)
        p = p->next;
    return p->data;
}

template <class T> 
int TList<T>::find(T data) {
    TListData<T> *p = this->head;
    for (int i = 0; i < this->count(); i++) {
        if (p->data == data)
            return i;
        p = p->next;
    }
    return -1;
}

template <class T> 
TListData<T> *TList<T>::getp(int id) {
    assert(id<0 || id>=this->fcount || "Incorrect id in TList::find(int)!");
    TListData<T> *p = this->head;
    for (int i=0; i<id; i++)
        p = p->next;
    return p;
}

template <class T>
void TList<T>::del(int id) {
    assert(id<0 || id>=this->fcount || "Incorrect id in TList::del!");
    TListData<T> *p = this->getp(id);
    p->prev->next = p->next;
    p->next->prev = p->prev;
    if (p == this->head)
        if (this->fcount)
            this->head = p->next;
        else
            this->head = NULL;
    delete p;
    this->fcount--;
}

template <class T>
void TList<T>::rem(T t) {
    TListData<T> *p = this->getp(this->find(t));
    p->prev->next = p->next;
    p->next->prev = p->prev;
    if (p == this->head)
        if (this->fcount)
            this->head = p->next;
        else
            this->head = NULL;
    delete p;
    this->fcount--;
}

template <class T> 
void TList<T>::clear() {
    while(this->fcount)
        this->del(0);
}

template <class T>
void TList<T>::delp(int id) {
    assert(id<0 || id>=this->fcount || "Incorrect id in TList::del!");
    TListData<T> *p = this->getp(id);
    p->prev->next = p->next;
    p->next->prev = p->prev;
    if (p == this->head)
        if (this->fcount)
            this->head = p->next;
        else
            this->head = NULL;
    delete p->data;
    delete p;
    this->fcount--;
}

template <class T>
void TList<T>::remp(T t) {
    TListData<T> *p = this->getp(this->find(t));
    p->prev->next = p->next;
    p->next->prev = p->prev;
    if (p == this->head)
        if (this->fcount)
            this->head = p->next;
        else
            this->head = NULL;
    delete p->data;
    delete p;
    this->fcount--;
}

template <class T> 
void TList<T>::clearp() {
    while(this->fcount)
        this->delp(0);
}

template <class T> 
int TList<T>::count() {
    return this->fcount;
}

template <class T> 
TList<T>::~TList(void) {
    
}

[Fla]

Неужто никому не пригодилось?

[dimanche13]

поздравляю! ты изобрел велосипед.

[Horror]

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

[Fla]

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

Короче читайте то, что написано перед листингом.

*Что тут можно попонятней написать?

[HolyDel]

где ForEach<T>?

[Fla]

Пишите запросы, сделаю до понедельника =)

[HolyDel]

кстати, еще неплохо быдло бы обзавестись
ForEachSafe<T>(...)
чтобы вызываемя ф-ия могда удалить текущий элемент.