C++ 指针 function class 在 class 中的实现

Question

My header file "DoublyLinkedLists" looks like this

class DoublyLinkedLists{
private:
    struct element{
        int key;
        struct element *prev, *next;
    };
    element* head = NULL;
    element* tail = NULL;
public:
    void insertToHead(int insert);
    element *find(int insert);
 
};

In the cpp file that includes "DoublyLinkedLists" header, I implemented my function(insert to head) like this:

void DoublyLinkedLists::insertToHead(int insert){
  //some code
}

I've tried, but doesnt work

DoublyLinkedLists::element* find(int insert){
//code
}

But how can I implement a function "element *find(int insert)" in a cpp file that returns a pointer? Where must I write "DoublyLinkedLists::" that specifies from where I am taking a function, or must I write something else.

I have absolutely no idea what I'm doing. I'm new to object oriented C++ programming and any help would be really appreciated.

Answer 1

Here is a sample implementation what you are supposed to do. I don't know if tail->next == head so I check tail seperately.

DoublyLinkedLists::element* DoublyLinkedLists::find(int insert)
{
    element* current = head; // Our current node we are checking.
    while(current != tail) // as long as we aren't at the end do
    {
        if (current->key == insert) // check if the current is the one we are looking for
            return current; // return it 
        current = current->next; // else go to the next element and repeat
    }
    if (tail->key == insert) // at least we check the tail
        return tail;
   return NULL; // if "insert" is not in our list we return NULL
}

You wrote element *find(int insert) I want to point out that the * is linked to element you return a pointer of element. It is more clear if you change the function signature to element* find(int insert)

Edit: Some pointer explanation. What is a pointer? Every pointer is either 4-bytes long (32 bit) or 8-bytes long. A pointer holds a memory address. The type of pointer (int*, double*, element*, ...) tells the compiler 1) how many bytes to read on the given address and 2) how to interpret them.

Example:

int i = 100; // Let's say i is on adress 0x00000004
int* pI = &i; // pI = 0x00000004 (!) pI is exacly only the address not the value

std::cout << pI; // output: "0x00000004"
std::cout << *pI; // output: 100;

*pI simply tells the compiler "go to adress 0x00000004, take sizeof(int) (4) bytes and trat them as integer." So the compiler takes bytes 0x00000004 to 0x00000008.

Answer 2

My question was poorly written, but all I've been looking was for a syntax of the function find.

DoublyLinkedLists::element *DoublyLinkedLists::find(int insert){
 //here is original code, but its quite long
  return nullptr;
}