help pls

#include <iostream>

using namespace std;

// Class that defines the node object
class Node {
private:
    int item;
    Node* nextPtr;
    Node* prevPtr;

public:
    //constructors
    Node();
    Node(int);
    Node(int, Node*);
    Node(int, Node*, Node*);

    //Accessor Methods
    void setItem(int);
    int getItem();
    void setNextPtr(Node*);
    Node* getNextPtr();
    void setPrevPtr(Node*);
    Node* getPrevPtr();

};

//regular c-type function for printing the Linked List
void printIntList(Node* beginningNodePtr);
void printIntListReverse(Node* beginningNodePtr);
void deleteLastNode(Node* argPtr);
void deleteNode(Node* argPtr);
void insertNode(Node* argPtr);


int main(void) {

    Node* headPtr = nullptr;
    Node* curNodePtr = nullptr;
    Node* tempPtr = nullptr;


    curNodePtr = new Node(1);   //head
    headPtr = curNodePtr;

    for (int i = 2; i < 6;i++) {    //new nodes filled with ints 2-5
        tempPtr = new Node(i);
        tempPtr->setPrevPtr(curNodePtr);    //attach temp's prevPtr to head
        curNodePtr->setNextPtr(tempPtr);    //attach head's nextPtr to temp
        curNodePtr = curNodePtr->getNextPtr();  //step forward and temp becomes curNode
    }

    printIntList(headPtr);
    printIntListReverse(headPtr);

    deleteLastNode (headPtr);

    return (0);
}

void printIntList(Node* beginningNodePtr) {

    Node* tempNodePtr = beginningNodePtr;

    cout << "Forward ******************" << endl;
    if (tempNodePtr == nullptr) {
        cout << "List Empty" << endl;
    }
    else {
        while (tempNodePtr->getNextPtr() != nullptr) {
            cout << tempNodePtr->getItem() << endl;
            tempNodePtr = tempNodePtr->getNextPtr();

        };
        cout << tempNodePtr->getItem() << endl;
    }
    cout << "******************" << endl;

}

void printIntListReverse(Node* beginningNodePtr) {

    Node* tempNodePtr = beginningNodePtr;

    if (tempNodePtr == nullptr) {
        cout << "List Empty" << endl;
    }
    else {
        while (tempNodePtr->getNextPtr() != nullptr) {
            tempNodePtr = tempNodePtr->getNextPtr();
        };

        // now tempNodePtr is at the end;
        cout << "Reverse ******************" << endl;
        while (tempNodePtr->getPrevPtr() != nullptr) {
            cout << tempNodePtr->getItem() << endl;
            tempNodePtr = tempNodePtr->getPrevPtr();
        };
        cout << tempNodePtr->getItem() << endl;
        cout << "******************" << endl;
    }

}

void deleteLastNode(Node* headPtr){

    Node* tempNodePtr = headPtr;

        //step to end
        while (tempNodePtr->getNextPtr() != nullptr) {
            tempNodePtr = tempNodePtr->getNextPtr();
        }

         tempNodePtr->setPrevPtr(tempNodePtr->getPrevPtr()); //steps back

        delete tempNodePtr->getNextPtr()->getItem();  //deallocate forward node's item(poly)
        delete tempNodePtr->getNextPtr();    //deallocate node container
        tempNodePtr->getNextPtr() = nullptr; //loses ref



        tempNodePtr->setItem(NULL);
        tempNodePtr->setNextPtr(nullptr);
        printIntList(headPtr);



}

void deleteNode(Node* argPtr){
}

void insertNode(Node* argPtr){
}

//Node Implementation
Node::Node(){
    setItem(0); //default to empty int
    setNextPtr(nullptr);
    setPrevPtr(nullptr);
}

Node::Node(int arg){
    setItem(arg);
    setNextPtr(nullptr);
    setPrevPtr(nullptr);
}

Node::Node(int arg, Node* argPtr){
    setItem(arg);
    setNextPtr(argPtr);
    setPrevPtr(nullptr);
}

Node::Node(int arg, Node* argNextPtr, Node* argPrevPtr){
    setItem(arg);
    setNextPtr(argNextPtr);
    setPrevPtr(argPrevPtr);
}

void Node::setItem(int arg){item = arg;}

int Node::getItem(){return item;}

void Node::setNextPtr(Node* argPtr) {nextPtr = argPtr; }

Node* Node::getNextPtr(){return nextPtr;}

void Node::setPrevPtr(Node* arg){prevPtr = arg;}

Node* Node::getPrevPtr(){return prevPtr;}