链表实现C ++

Question

I am trying to store data by ID using convening structs and pointers, but I am only able to store the first value. This is my first time trying to use this kind of method for store data dynamically, so I am not sure I am using node->p_next and node->p_prev in the right way.

Can someone give a look and tell me if I am doing something wrong in my implementation?

List.h

class list
{
public:

    // Construction /destruction
    list();
    virtual ~list();

    void DeleteAll();
    void DeleteID(uint16_t ID);
    uint8_t add(uint16_t ID, uint8_t data);
    void printf(uint16_t ID);

    struct node
    {
        uint16_t ID;
        uint8_t  data;
        node * p_prev;
        node * p_next;
    };  
protected:
    node * LookingforRecord(uint16_t id, bool add = false);
    node * m_p_node;
};

List.cpp

#include "list.h"

uint16_t ID = 0;
// Construction
list::list()
{
    m_p_node = 0;
}

// Destruction
list::~list()
{
    DeleteAll();
}

void list::printf(uint16_t ID)

    node * p_node = LookingforRecord(ID, false);

    if (p_node != 0)
    {
        printf("p_node->ID %d \r\n", p_node->ID);
        printf("p_node->data %d \r\n", p_node->data);
    }
}
uint8_t list::add(uint16_t ID, uint8_t data)
{
    uint8_t batch_size = 0;
    // Find the ID, creating one if necessary
    node * p_node = LookingforRecord(ID, true);
    if (p_node != 0)
    {
        //store ID and data
        p_node->ID= ID;
        p_node->data = data;

        batch_size = ID;
    }
    return batch_size;
}

list::Node * list::LookingforRecord(uint16_t ID, bool add)// Finds a ID
{
    node * p_node= m_p_node;

    while (p_node != NULL)
    {
        // Find by ID
        if(p_node->ID == ID)        
            return p_node;  

        p_node = p_node->p_next; // Move on to the next one
    }       

    if(add)
    {
        if ((p_node = new node) != 0)
        {
            memset(p_node, 0, sizeof(node));
            p_node->ID = ID;
            p_node->data = m_p_node;
            **p_node->p_next = m_p_node;**

            if (m_p_node != 0)  
                m_p_node->p_prev = p_node;          
            else
                m_p_node = p_node;
        }
    }
    return p_node;
}

void list::DeleteAll() // Deletes everything
{
    while (m_p_node != 0)
    {
        DeleteID(m_p_node->ID);
    }
}

void list::DeleteID(uint16_t ID) // Deletes ID
{ 
    // Find by ID
    node * p_node = LookingforRecord(ID, false);
    if (p_node != 0)
    {
        // Unlink it from the list
        if(p_node->p_prev != 0)
            p_node->p_prev->p_next = p_node->p_next;
        if (p_node->p_next != 0)
            p_node->p_next->p_prev = p_node->p_prev;
        if (m_p_node == p_node)
            m_p_node = p_node->p_next;

        delete p_node;
    }
}

My main concern is at LookingforRecord . It is not entering into if(p_node->ID == ID) , and it is not updating p_node from m_p_node , which is supposed to be updated each time the code enters lookingforRecord .

Answer 1

Here are some things that are definitely wrong.

1) You have an add method uint8_t add(uint16_t ID, uint8_t data) in your header, but you don't implement it. You use add a new element to your module in LookingforRecord method. I suggest you to separate those two and call one from another(if you really need it, which I believe you don't)

2) You use your uint8_t batch_size variable to store ID, which is type uint16_t. I believe you know why it is bad :D

3) Your DeleteID is not entirely correct. If you want to delete the first element, you should null the next element's prev pointer, otherwise it'll point to garbage.

4) Use both first and last pointers in your protected(why not private) section. And call them accordingly. It is very confusing. It would be much easier to add a new node if you have the last pointer.

5) You adding it wrong. When you add a new node you do this

if (m_p_node != 0)  
   m_p_node->p_prev = p_node; 

But you need your LAST element's p_next point to a new element you just added.

6) If it is a forward list, you only need p_next, but if it is a doubly linked list(where you need both p_prev and p_next) you should be able to add elements from both sides.

I hope you fix it ^_^