C++ C++；创建每个节点包含2个以上字段的链接列表

所以我试图创建一个链表，可以为一个富有想象力的图书馆存储书籍。在链表中，每个节点都应该包含图书馆的分支机构、作者姓名、书名以及该书的份数

我很难创建每个节点都有多个字段的链表。我该如何处理它，以便每个节点可以存储3个单独的字符串和一个整数，最后是一个指向下一个节点的指针

这是我目前的代码

#ifndef LINKEDLIST_H
#define LINKEDLIST_H
#include <stdexcept>
using namespace std;

template<typename T>
class Node
{
public:
    T element;  
    Node<T>* next; 

    Node() 
    {
        next = nullptr;
    }

    Node(T element) // Constructor
    {
        this->element = element;
        next = nullptr;
    }
};

template<typename T>
class Iterator : public std::iterator<std::forward_iterator_tag, T>
{
public:
    Iterator(Node<T>* p)
    {
        current = p;
    }

    Iterator operator++() // Prefix ++
    {
        current = current->next;
        return *this;
    }

    Iterator operator++(int dummy) // Postfix ++
    {
        Iterator temp(current);
        current = current->next;
        return temp;
    }

    T& operator*()
    {
        return current->element;
    }

    bool operator==(const Iterator<T>& iterator)
    {
        return current == iterator.current;
    }

    bool operator!=(const Iterator<T>& iterator)
    {
        return current != iterator.current;
    }

private:
    Node<T>* current;
};

template<typename T>

class LinkedList
{
public:
    LinkedList();
    LinkedList(const LinkedList<T>& list);
    virtual ~LinkedList();
    void addFirst(T element);
    void addLast(T element);
    T getFirst() const;
    T getLast() const;
    T removeFirst() throw (runtime_error);
    T removeLast();
    void add(T element);
    void add(int index, T element);
    void clear();
    bool contains(T element) const;
    T get(int index) const;
    int indexOf(T element) const;
    bool isEmpty() const;
    int lastIndexOf(T element) const;
    void remove(T element);
    int getSize() const;
    T removeAt(int index);
    T set(int index, T element);

    Iterator<T> begin() const
    {
        return Iterator<T>(head);
    }

    Iterator<T> end() const
    {
        return Iterator<T>(tail->next);
    }

private:
    Node<T>* head;
    Node<T>* tail;
    int size;
};

template<typename T>
LinkedList<T>::LinkedList()
{
    head = tail = nullptr;
    size = 0;
}

template<typename T>
LinkedList<T>::LinkedList(const LinkedList<T>& list)
{
    head = tail = nullptr;
    size = 0;

    Node<T>* current = list.head;
    while (current != nullptr)
    {
        this->add(current->element);
        current = current->next;
    }
}

template<typename T>
LinkedList<T>::~LinkedList()
{
    clear();
}

template<typename T>
void LinkedList<T>::addFirst(T element)
{
    Node<T>* newNode = new Node<T>(element);
    newNode->next = head;
    head = newNode;
    size++;

    if (tail == nullptr)
        tail = head;
}

template<typename T>
void LinkedList<T>::addLast(T element)
{
    if (tail == nullptr)
    {
        head = tail = new Node<T>(element);
    }
    else
    {
        tail->next = new Node<T>(element);
        tail = tail->next;
    }

    size++;
}

template<typename T>
T LinkedList<T>::getFirst() const
{
    if (size == 0)
        throw runtime_error("Index out of range");
    else
        return head->element;
}

template<typename T>
T LinkedList<T>::getLast() const
{
    if (size == 0)
        throw runtime_error("Index out of range");
    else
        return tail->element;
}

template<typename T>
T LinkedList<T>::removeFirst() throw (runtime_error)
{
    if (size == 0)
        throw runtime_error("No elements in the list");
    else
    {
        Node<T>* temp = head;
        head = head->next;
        if (head == nullptr) tail = nullptr;
        size--;
        T element = temp->element;
        delete temp;
        return element;
    }
}

template<typename T>
T LinkedList<T>::removeLast()
{
    if (size == 0)
        throw runtime_error("No elements in the list");
    else if (size == 1)
    {
        Node<T>* temp = head;
        head = tail = nullptr;
        size = 0;
        T element = temp->element;
        delete temp;
        return element;
    }
    else
    {
        Node<T>* current = head;

        for (int i = 0; i < size - 2; i++)
            current = current->next;

        Node<T>* temp = tail;
        tail = current;
        tail->next = nullptr;
        size--;
        T element = temp->element;
        delete temp;
        return element;
    }
}

template<typename T>
void LinkedList<T>::add(T element)
{
    addLast(element);
}

template<typename T>
void LinkedList<T>::add(int index, T element)
{
    if (index == 0)
        addFirst(element);
    else if (index >= size)
        addLast(element);
    else
    {
        Node<T>* current = head;
        for (int i = 1; i < index; i++)
            current = current->next;
        Node<T>* temp = current->next;
        current->next = new Node<T>(element);
        (current->next)->next = temp;
        size++;
    }
}

template<typename T>
void LinkedList<T>::clear()
{
    while (head != nullptr)
    {
        Node<T>* temp = head;
        head = head->next;
        delete temp;
    }

    tail = nullptr;
    size = 0;
}

template<typename T>
T LinkedList<T>::get(int index) const
{
    if (index < 0 || index > size - 1)
        throw runtime_error("Index out of range");

    Node<T>* current = head;
    for (int i = 0; i < index; i++)
        current = current->next;

    return current->element;
}

template<typename T>
int LinkedList<T>::indexOf(T element) const
{
    // Implement it in this exercise
    Node<T>* current = head;
    for (int i = 0; i < size; i++)
    {
        if (current->element == element)
            return i;
        current = current->next;
    }

    return -1;
}

template<typename T>
bool LinkedList<T>::isEmpty() const
{
    return head == nullptr;
}

template<typename T>
int LinkedList<T>::getSize() const
{
    return size;
}

template<typename T>
T LinkedList<T>::removeAt(int index)
{
    if (index < 0 || index >= size)
        throw runtime_error("Index out of range");
    else if (index == 0)
        return removeFirst();
    else if (index == size - 1)
        return removeLast();
    else
    {
        Node<T>* previous = head;

        for (int i = 1; i < index; i++)
        {
            previous = previous->next;
        }

        Node<T>* current = previous->next;
        previous->next = current->next;
        size--;
        T element = current->element;
        delete current;
        return element;
    }
}

// The functions remove(T element), lastIndexOf(T element),
// contains(T element), and set(int index, T element) are
// left as an exercise

#endif

\ifndef LINKEDLIST\u H
#定义链接列表
#包括
使用名称空间std；
模板
类节点
{
公众：
T元素；
节点*下一步；
节点（）
{
next=nullptr；
}
Node（T元素）//构造函数
{
这个->元素=元素；
next=nullptr；
}
};
模板
类迭代器：public std:：Iterator
{
公众：
迭代器（节点*p）
{
电流=p；
}
迭代器运算符++（）//前缀++
{
当前=当前->下一步；
归还*这个；
}
迭代器运算符++（int-dummy）//后缀++
{
迭代器温度（当前）；
当前=当前->下一步；
返回温度；
}
T&运算符*（）
{
返回当前->元素；
}
布尔运算符==（常量迭代器和迭代器）
{
返回当前值==迭代器.current；
}
布尔运算符！=（常量迭代器和迭代器）
{
返回当前值！=iterator.current；
}
私人：
节点*电流；
};
模板
类链接列表
{
公众：
LinkedList（）；
LinkedList（常量LinkedList&list）；
虚拟~LinkedList（）；
第一个元素（T元素）；
void addLast（T元素）；
T getFirst（）常量；
T getLast（）常量；
T removeFirst（）抛出（运行时错误）；
T removeLast（）；
无效添加（T元素）；
void add（int索引，T元素）；
无效清除（）；
bool包含（T元素）常量；
T get（int index）const；
int indexOf（T元素）常量；
bool isEmpty（）常量；
int lastIndexOf（T元素）常量；
脱空（T元件）；
int getSize（）常量；
T removeAt（int索引）；
T集（int索引，T元素）；
迭代器begin（）常量
{
返回迭代器（head）；
}
迭代器end（）常量
{
返回迭代器（尾部->下一步）；
}
私人：
节点*头；
节点*尾部；
整数大小；
};
模板
LinkedList:：LinkedList（）
{
头=尾=空PTR；
尺寸=0；
}
模板
LinkedList:：LinkedList（常量LinkedList&list）
{
头=尾=空PTR；
尺寸=0；
节点*当前=list.head；
while（当前！=nullptr）
{
此->添加（当前->元素）；
当前=当前->下一步；
}
}
模板
LinkedList:：~LinkedList（）
{
清除（）；
}
模板
void LinkedList:：addFirst（T元素）
{
Node*newNode=新节点（元素）；
新建节点->下一步=头部；
头=新节点；
大小++；
if（tail==nullptr）
尾=头；
}
模板
void LinkedList:：addLast（T元素）
{
if（tail==nullptr）
{
头=尾=新节点（元素）；
}
其他的
{
tail->next=新节点（元素）；
tail=tail->next；
}
大小++；
}
模板
T LinkedList:：getFirst（）常量
{
如果（大小==0）
抛出运行时_错误（“索引超出范围”）；
其他的
返回头->元素；
}
模板
T LinkedList:：getLast（）常量
{
如果（大小==0）
抛出运行时_错误（“索引超出范围”）；
其他的
返回尾部->元素；
}
模板
T LinkedList:：removeFirst（）抛出（运行时错误）
{
如果（大小==0）
抛出运行时_错误（“列表中没有元素”）；
其他的
{
节点*温度=头部；
头部=头部->下一步；
如果（head==nullptr）tail=nullptr；
大小--；
T元件=温度->元件；
删除临时文件；
返回元素；
}
}
模板
T LinkedList:：removeLast（）
{
如果（大小==0）
抛出运行时_错误（“列表中没有元素”）；
否则如果（大小==1）
{
节点*温度=头部；
头=尾=空PTR；
尺寸=0；
T元件=温度->元件；
删除临时文件；
返回元素；
}
其他的
{
节点*电流=头部；
对于（int i=0；i下一步；
节点*温度=尾部；
尾=电流；
tail->next=nullptr；
大小--；
T元件=温度->元件；
删除临时文件；
返回元素；
}
}
模板
void LinkedList:：add（T元素）
{
addLast（元素）；
}
模板
void LinkedList:：add（int索引，T元素）
{
如果（索引==0）
addFirst（元素）；
否则如果（索引>=大小）
addLast（元素）；
其他的
{
节点*电流=头部；
对于（int i=1；i下一步；
节点*temp=当前->下一步；
当前->下一步=新节点（元素）；
（当前->下一步）->下一步=温度；
大小++；
}
}
模板
void LinkedList:：clear（）
{
while（head！=nullptr）
{
节点*温度=头部；
头部=头部->下一步；
删除临时文件；
}
tail=nullptr；
尺寸=0；
}
模板
T LinkedList:：get（int索引）常量
{
如果（索引<0 | |索引>大小-1）
抛出运行时_错误（“索引超出范围”）；
节点*电流=头部；
对于（int i=0；i下一步；
返回当前->元素；
}
模板
int LinkedList:：indexOf（T元素）常量
{
//在这个练习中实施它
节点*电流=头部；
对于（int i=0；i元素==元素）
返回i；
当前=当前->下一步；
}
返回-1；
}
模板
bool LinkedList:：isEmpty（）常量
{
返回压头==nullptr；
}
模板
int LinkedList:：getSize（）常量
{
返回大小；
}
模板
T LinkedList:：removeAt（int索引）
{
如果（索引<0 | |索引>=大小）
抛出运行时_错误（“索引超出范围”）；
else if（索引==0）
return removeFirst（）；
else if（索引==siz）
struct Book
{
    std::string branch;
    std::string author;
    std::string title;
    int copies;
};