Question

与迭代器和容器相处，我偶然发现了一个我试图实现的小实验。但是，我很早就陷入了困境。

我们的想法是创建一个链表，其中包含两种不同类型的条目，即out和in项。所有项目都链接在一起，而同类项目也包含对彼此的引用。

接下来，我希望能够通过迭代器以三种不同的方式循环数据结构：

任何遍历整个数据结构的文件。
In，其中只有穿过的物品。
Out，其中只有遍历项目。

因此，在调用上面列出的任何类型时，只将begin（）和end（）迭代器传递给请求者。

我已经设置了以下数据结构，我能够以上面提到的方式循环它，虽然我无法设置迭代器。

template <class T>
struct dual_node {
    /*
     * Constructors
     */
    dual_node(T data): data(data) {};

    /*
     * Operators
     */
    bool operator ==(const dual_node<T> &rhs) const {
        return this->data == rhs.data;
    }

    /*
     * Members
     */
    T data;
    dual_node *type_next = nullptr;
    dual_node *type_prev = nullptr;
};

包装类：

using namespace std;

template <class T>
class DualLinkedList {
public:
    /*
     * Mutators
     */
    template <class Direction>
    void push_front(T element){
        elements.push_front(dual_node<T>(element));
        Direction::template set_ptr<T>(elements.front(), &last_in, &last_out);
    }

    void remove(T element){
        auto it = find(elements.begin(), elements.end(), element);

        // Element found
        if(it != elements.end()){
            // If it has a previous
            if(it->type_prev) {
                it->type_prev->type_next = it->type_next;
            }else{
                // No previous, so last_in or last_out should match.
                if(*last_in == *it){
                    last_in = it->type_next;
                }

                if(*last_out == *it){
                    last_out = it->type_next;
                }
            }

            // Remove from forward_list
            elements.remove(*it);
        }


    }
//private:
    forward_list<dual_node<T>> elements;
    dual_node<T> *last_in;
    dual_node<T> *last_out;
};

方向类：

struct in {
        static edge_list& get_list(pair<edge_list, edge_list> &a) {
            return a.first;
        }
        // conceptual
        static pair<iterator, iterator> get_it_pair(dual_node<T>** last_in){
            // Return iterator starting at last_in, following type_next pointers
        }

        template <class T>
        static void set_ptr(dual_node<T> &element, dual_node<T>** last_in, dual_node<T>** last_out){
            // If last incoming exists.
            if(*last_in) {
                (**last_in).type_prev = &element;
            }
            element.type_next = *last_in;
            *last_in = &element;
        }
    };

    struct out {
        static edge_list& get_list(pair<edge_list, edge_list> &a) {
            return a.second;
        }

        // conceptual
        static pair<iterator, iterator> get_it_pair(dual_node<T>** last_out){
            // Return iterator starting at last_out, following type_next ptrs
        }

        template <class T>
        static void set_ptr(dual_node<T> &element, dual_node<T>** last_in, dual_node<T>** last_out) {
            // If last outgoing exists.
            if(*last_out) {
                (**last_out).type_prev = &element;
            }
            element.type_next = *last_out;
            *last_out = &element;
        }
    };

    struct any {
        // conceptual
        static pair<iterator, iterator> get_it_pair(dual_node<T>** last_out){
            // Returning iterator starting at last out following forward_list
        }
    };

Answer 1

我对迭代器不太熟悉，但您是否尝试浏览其中一些教程？

https://www.cs.northwestern.edu/~riesbeck/programming/c++/stl-iterator-define.html

How to correctly implement custom iterators and const_iterators?

Creating my own Iterators

自定义数据结构的迭代器

1 个答案: