C++ 使用链表c++；

我只是简单地创建一个工资系统，其中包含员工姓名和该员工的工作时间。。数据应该存储在链表数据结构中，但我无法将链表连接到类employee的对象，我尝试将工资表链表（即Employist）作为静态成员，以便类的所有对象都可以使用相同的列表对象，并且可以存储数据，但一旦我编译代码，我会得到一个错误“对employee:：Employer的未定义引用“在构造器的最后一行第130行，第150行出现相同的错误，这是一个打印付款卷函数。”。。当我试图调用employee类中任何payRollLinkedList类的函数时，它都会给出错误。。底线是，我只想将数据存储在一个双链接的员工列表中，而我无法访问该列表

    #include <iostream>
    using namespace std;
    class payRollLinkedList;
    class node
    {
    private:
        node* previousPointer;
        string name;
        int hoursWorked;
    node* nextPointer;
    friend class payRollLinkedList;
    public:
        explicit node(const string argName, const int argHoursWorked)
        : previousPointer{nullptr}, name{argName}, hoursWorked{argHoursWorked}, nextPointer{nullptr}
        {}
    };
    class payRollLinkedList
    {
    private:
        node* headPointer{nullptr};
        node* tailPointer{nullptr};
        node* getNewNode(const string argName, const int argHoursWorked)
        {
            return new node(argName, argHoursWorked);
        }
    public:
        void addAtBack(const string argName, const int argHoursWorked)
        {
            node* newNode{getNewNode(argName, argHoursWorked)};
            if(isEmpty())
            {
                headPointer = tailPointer = *newNode;
            }
            else
            {
                tailPointer->nextPointer = newNode;
                newNode->previousPointer = tailPointer;
                tailPointer = newNode;
                newNode = nullptr;
                delete newNode;
            }
        }
        bool deleteNode(string argName)
        {
            node* currentPointer{headPointer};
            if(isEmpty())
            {
                cout <<"the list is already empty\n";
                return false;
            }
            else
            {
                while(currentPointer != nullptr)
                {
                    if(currentPointer->name == argName)
                    {
                        if(currentPointer == headPointer)
                        {
                            node* tempPointer{headPointer};
                            headPointer = headPointer->nextPointer;
                            tempPointer->nextPointer = nullptr;
                            headPointer->previousPointer = nullptr;
                            delete tempPointer;
                            break;
                        }
                        if(currentPointer == tailPointer)
                        {
                            node*tempPointer{tailPointer};
                            tailPointer = tailPointer->previousPointer;
                            tempPointer->previousPointer = nullptr;
                            tailPointer->nextPointer = nullptr;
                            delete tempPointer;
                            break;
                        }
                        node* tempPointer{currentPointer};
                        node* nextPtr{tempPointer->nextPointer};
                        currentPointer = currentPointer->previousPointer;
                        currentPointer->nextPointer = nextPtr;
                        nextPtr->previousPointer = currentPointer;
                        tempPointer->nextPointer = nullptr;
                        tempPointer->previousPointer = nullptr;
                        currentPointer = nullptr;
                        nextPtr = nullptr;
                        delete tempPointer;
                        delete currentPointer;
                        delete nextPtr;
                    }
                    else
                        currentPointer = currentPointer->nextPointer;
                }
                return true;
            }
        }
        void print()
        {
            if(isEmpty())
            {
                cout <<"nothing to show\n";
                return;
            }
            else
            {
                node* currentPointer{headPointer};
                while(currentPointer != nullptr)
                {
                    cout <<currentPointer->name <<"\t";
                    currentPointer = currentPointer->nextPointer;
                }
            }
        }
        bool isEmpty()
        {
            return headPointer == nullptr? true : false;
        }
    };
    class employee
    {
    private:
        string name;
        int hoursWorked;
        static payRollLinkedList empList;
    public:
        employee()
        : name{""}, hoursWorked{0}
        {}
        employee(string argName, int argHoursWorked)
        {
            name = argName;
            hoursWorked = argHoursWorked;
            empList.addAtBack(name, hoursWorked);
        }
        void printPayRoll()
        {
            empList.print();
        }
    };
    int main()
    {
        employee emp("usman", 12);
        employee emp1("ali", 12);
        emp.printPayRoll();
    }

#包括
使用名称空间std；
类payRollLinkedList；
类节点
{
私人：
节点*上一个指针；
字符串名；
工作时间；
节点*nextPointer；
朋友类薪资列表；
公众：
显式节点（常量字符串argName，常量int argHoursWorked）
：上一个指针{nullptr}，名称{argName}，工作时间{argHoursWorked}，下一个指针{nullptr}
{}
};
类payRollLinkedList
{
私人：
节点*头指针{nullptr}；
节点*tailPointer{nullptr}；
节点*getNewNode（常量字符串argName，常量int argHoursWorked）
{
返回新节点（argName，argHoursWorked）；
}
公众：
void addAtBack（常量字符串argName，常量int argHoursWorked）
{
node*newNode{getNewNode（argName，argHoursWorked）}；
if（isEmpty（））
{
头指针=尾指针=*新节点；
}
其他的
{
tailPointer->nextPointer=newNode；
newNode->previousPointer=tailPointer；
tailPointer=newNode；
newNode=nullptr；
删除新节点；
}
}
bool deleteNode（字符串argName）
{
节点*当前指针{headPointer}；
if（isEmpty（））
{
cout下一点；
tempPointer->nextPointer=nullptr；
headPointer->previousPointer=nullptr；
删除临时指针；
打破
}
如果（currentPointer==尾指针）
{
节点*tempPointer{tailPointer}；
tailPointer=tailPointer->previousPointer；
tempPointer->previousPointer=nullptr；
tailPointer->nextPointer=nullptr；
删除临时指针；
打破
}
节点*临时指针{currentPointer}；
节点*nextPtr{tempPointer->nextPointer}；
currentPointer=currentPointer->previousPointer；
currentPointer->nextPointer=nextPtr；
nextPtr->previousPointer=currentPointer；
tempPointer->nextPointer=nullptr；
tempPointer->previousPointer=nullptr；
currentPointer=nullptr；
nextPtr=nullptr；
删除临时指针；
删除当前指针；
删除nextPtr；
}
其他的
currentPointer=currentPointer->nextPointer；
}
返回true；
}
}
作废打印（）
{
if（isEmpty（））
{
cout

您需要在全局范围（类外）定义类的静态成员。
我建议您拆分code.h和.cpp文件，并在.cpp文件中定义成员

payRollLinkedList employee::empList;

为什么要将员工列表作为employee类的成员？我假设我会将姓名和工作时间作为参数从employee类发送到payRollList成员函数add和delete..要访问employee类中payRollList的这些函数，我需要一个payRollList对象，即员工列表。
deletetempPointer；delete currentPointer；delete nextPtr；
--为什么在
delete
节点中要删除3个节点？使用框作为节点，线作为链接，在纸上绘制一个节点的删除。唯一应该做的是将要删除的节点之前的节点与要删除的节点的下一个节点链接。然后是single删除现在未链接的节点。请注意，使用指针时，不能保证代码“正常”运行因为你没有看到错误。你看到你写的
delete
代码有多复杂吗？我提到的描述中的什么很难理解？如果你得到任何关于链表删除的教程，你会看到一个节点被删除，而被删除的节点从列表中移除，而不是三个单独的节点被删除。看起来你没有遵循如何绘制视觉平面图（*即在纸上绘制链表）--如果你这样做了，你将很难想出你想出的代码。尽量严肃，不要苛刻。我要说的是，除了头指针和尾指针的特殊情况外，删除应该是1）将前一个节点连接到要删除的下一个节点，然后2）删除要删除的节点。仅此而已.