c++ - 一个使用链表 C++ 的简单工资系统

Question

我只是创建一个工资单系统，其中包含员工姓名和该员工的工作时间。数据应该存储在链表数据结构中，但我无法将链表连接到类员工的对象，我尝试将工资单链表（即empList）作为静态成员，以便类的所有对象都可以使用相同的列表对象并且可以存储数据但是一旦我编译我的代码，我就会收到“未定义引用”的错误到第 130 行的employee::empList"，这是构造函数的最后一行，第 150 行的相同错误是打印工资单函数.. 无论我试图在员工类中调用任何 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();
    }

标签： c++data-structuresdoubly-linked-list

Answer 1

https://en.cppreference.com/w/cpp/language/static

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

payRollLinkedList employee::empList;