Quelques choses dans le modèle de liste doublement lié

Question

J'ai un code de liste doublement liée et il y a peu de lignes de ce code quelle idée n'est pas claire. Je demande des commentaires d'experts sur les lignes qui ont des commentaires dans ce qui suit. Cela depuis longtemps j'ai utilisé C ++. Il n'y a que deux lignes que j'ai indiquées ne sont pas compréhensibles pour moi.

template <typename T>
class double_linked
{
    struct node
    {
        T data;
        node* prev;
        node* next;
        node(T t, node* p, node* n) : data(t), prev(p), next(n) {}
    };
    node* head;
    node* tail;
public:
    double_linked() : head( NULL ), tail ( NULL ) {}
    template<int N>
    double_linked( T (&arr) [N]) : head( NULL ), tail ( NULL ) 
    {
        for( int i(0); i != N; ++i)
            push_back(arr[i]);
    }

    bool empty() const { return ( !head || !tail ); } // this doing? 
    operator bool() const { return !empty(); } // this doing? i know operators need in C++ but dont know the use of it here 
    void push_back(T);
    void push_front(T);
    T pop_back();
    T pop_front();

    ~double_linked()
    {
        while(head)
        {
            node* temp(head);
            head=head->next;
            delete temp;
        }
    }
};

Answer 1

operator bool() const est un opérateur de conversion. Si une instance de double_linked est utilisé dans un contexte où un bool est requis, cette fonction sera appelée pour effectuer la conversion. (Et évaluera à true Si la liste n'est pas vide dans votre cas.)

L'autre fonction est une ancienne fonction, qui reviendra true si l'un ou l'autre head ou tail est nul.

Pour en savoir plus sur les opérateurs de conversion, voir: Comment fonctionnent les opérateurs de conversion en C ++?

Answer 2

Le premier est une fonction pour déterminer si la liste est vide. Dans une liste doublement liée, si vous avez au moins un élément, le head et tail pointeurs (qui indiquent le début et la fin de la liste respectivement) devoir pointer vers un élément valide. Par conséquent, vous pouvez tester si la liste est vide en testant si ces deux pointeurs ne pointent pas vers un élément valide (c'est-à-dire null). C'est ce que l'expression !head || !tail fait - vérifie si l'un ou l'autre pointeur est null, et si c'est le cas, la liste est vide.

La operator bool() La chose est un opérateur de conversion. Cela signifie essentiellement, chaque fois que la liste est mise à bool, cette fonction est appelée et le résultat utilisé comme valeur du bool. La fonction renvoie si la liste n'est pas vide, donc une expression comme bool result = myList; fera result être true Si la liste n'est pas vide.

Answer 3

C'est un prédicat qui nous indique s'il est vide ou non, il vérifie si les pointeurs sont 0 (null).

bool empty() const { return ( !head || !tail ); } // this doing? 

Cela permet à l'utilisateur de traiter une instanciation du conteneur en tant que booléen, ce qui est vrai s'il n'est pas vide.

operator bool() const { return !empty(); } // this

Implémentation d'une liste liée est un bon exercice de programmation, mais si vous souhaitez utiliser une liste liée dans votre code réel, vous devez vraiment utiliser STD :: List (in).