C++侵入式链表

C++标准模板库中的list是非侵入式的链表，当我们通过对象来删除容器中的对象时，需要从头到尾查找一次得到iterator，最后通过iterator来删除对象。这样删除容器中的对象时比较缓慢，所以就实现了一个侵入式链表。

intrusive_list.h

#ifndef _Intrusive_List_H_
#define _Intrusive_List_H_

// 侵入式链表
template<class T>
class intrusive_list {
public:
    struct Node;
    // 迭代器
    class iterator {
    public:
        iterator(Node* node) : m_node(node) {}

        iterator& operator ++() {
            if (m_node)
                m_node = m_node->m_next;
            return *this;
        }
        iterator& operator --() {
            if (m_node)
                m_node = m_node->m_prev;
            return *this;
        }

        bool operator == (const iterator& iter) { return m_node == iter.m_node; }
        bool operator != (const iterator& iter) { return !operator ==(iter); }

        T& operator *() { return *m_node; }
        T* operator ->() { return m_node; }

    private:
        Node* m_node;
    };

    intrusive_list() : m_head(nullptr), m_tail(nullptr) {}

    ~intrusive_list() {
        Node* node = m_head;
        while (node) {
            Node* next = node->m_next;
            delete node;
            node = next;
        }
    }

    // 添加对象
    template<class... Args>
    T* add(Args... args) {
        Node* node = new Node(args...);

        if (m_head && m_tail) {
            node->m_prev = m_tail;
            m_tail->m_next = node;
            m_tail = node;
        }
        else {
            m_head = node;
            m_tail = node;
        }
        return node;
    }

    // 移除对象
    void remove(T* ptr) {
        Node* node = (Node*)ptr;
        assert(node->m_valid);
        if (m_head == node) {
            m_head = m_head->m_next;
        }
        if (m_tail == node) {
            m_tail = m_tail->m_prev;
        }
        if (node->m_prev)
            node->m_prev->m_next = node->m_next;
        if (node->m_next)
            node->m_next->m_prev = node->m_prev;
        delete node;
    }

    iterator begin() { return iterator(m_head); }
    iterator end() { return iterator(nullptr); }

private:
    struct Node : public T {
        template<class... Args>
        Node(Args... args) : T(args...), m_valid(true), m_prev(nullptr), m_next(nullptr) {}

        bool m_valid;
        Node* m_prev;
        Node* m_next;
    };

    Node* m_head;
    Node* m_tail;
};

#endif

test.cpp

int _tmain(int argc, _TCHAR* argv[])
{
    struct Person {
        Person(const char* name) : m_name(name) {}

        std::string m_name;
        int m_age;
    };

    intrusive_list<Person> lst;

    Person* p0 = lst.add("11");
    lst.add("2");
    lst.add("3");
    lst.add("4");
    lst.add("5");
    Person* p1 = lst.add("6");

    lst.remove(p0);
    lst.remove(p1);
    
    for (auto iter = lst.begin(); iter != lst.end(); ++iter) {
        std::cout << iter->m_name << std::endl;
    }

    return 0;
}