有人可以帮我解答这个问题吗？为了提供背景信息，我有三个类，`Account.h` 和 `Account.cpp`，`Node.h` 和 `Node.cpp`，`LinkedList.h` 和 `Linkedlist.cpp`，以及包含 `int main()` 的 `demo.cpp`。所有当前的函数都能正常工作，只有打印出链表的功能还没实现，这也是我的问题所在。
问题明确要求：
> 实现一个非成员重载的 `operator <<` 函数，使用 `Account` 中的 `operator <<`，允许你执行如下操作：
> `cout << MyLinkedList << endl;`
我从 `LinkedList.cpp` 和 `Account.cpp` 中复制了与这个问题相关的特定部分，因为如果我把所有代码都粘贴在这里，会太长了。
在 `LinkedList.cpp` 中，有一个未能正常工作的重载的 `operator <<` 函数，代码如下所示：请注意 `value_type` 是 `Account` 的 typedef。
```c++
#include "LinkedList.h"
    
LinkedList::value_type LinkedList::getCurrent() const {
    if (current != NULL) {
    	return current->getData();
    } else {
    	return value_type();
    }
}
    
ostream& operator << (ostream& out, const LinkedList& list) { // not working, compile error!
    value_type current = getCurrent();
    while (current != NULL) {
        out << "(" << acc.getName() << "," << acc.balance() << ")" << endl;
    }
    return out;
}

ostream& operator << (ostream& out, const Account& acc)
{
    out << "(" << acc.getName() << "," << acc.balance() << ")" << endl;
    return out;
}

#ifndef TEKAAI_NODE
#define TEKAAI_NODE
#include "Account.h"
class Node
{
	public:
		// 外部可见的成员
		
		// 以下是成员函数
		
		// 使用 typedef 将 value_type 指定为 Account
		typedef Account value_type;
		
		// 默认构造函数
		
		Node();		
		
		// 参数构造函数
		
		Node(const value_type& initial_data, Node* initial_link);
		
		~Node();	// 析构函数
		
		void setNext(Node* n);
		
		void setPrevious(Node* p);
		
		Node* getNext() const;
		
		Node* getPrevious() const;
		
		// 数据的获取和设置
		// 前提条件：Current 已初始化
		// 后置条件：设置数据
		void setData(const value_type& i);
		
		// 前提条件：数据已初始化
		// 后置条件：返回存储的数据
		value_type getData() const;
		
	private:
		value_type data;	// 节点保存的数据
		Node* next; 		// 指向下一个节点的指针
		Node* previous;		// 指向前一个节点的指针
};
#endif

#ifndef TEKAAI_LINKEDLIST_H
#define TEKAAI_LINKEDLIST_H
#include "Account.h"
#include "Node.h"
#include <iostream>
class LinkedList
{
    public:
		typedef Account value_type;
		// 外部可见的成员
		
		// 这些是成员函数
		
		// 构造函数
		    
		LinkedList();	
		
		// 析构函数
		
		~LinkedList();
		
		void addToHead(const value_type& account); 
		
		void addToTail(const value_type& account);
		
		void addCurrent(const value_type& account);
		
		value_type removeFromHead();
		
		value_type removeFromTail();
		
        value_type removeFromCurrent();
		
	    // 前提条件：链表包含节点
		// 后置条件：将当前节点移到头部 
	    void start();  
	    // 前提条件：链表包含节点
	    // 后置条件：将当前节点移到尾部
	    void end();
		
	    // 前提条件：链表包含节点
	    // 后置条件：将当前节点向右移动一个节点
	    void forward();  
		
	    // 前提条件：链表包含节点
	    // 后置条件：将当前节点向左移动一个节点
	    void back(); 
		
	    // 前提条件：链表包含节点
	    // 后置条件：返回当前节点存储的数据帐户的值
	    value_type getCurrent() const;
		
	    // 前提条件：链表已初始化，包含节点
	    // 后置条件：返回链表的长度
	    int length();
	
	private:
	    Node* head;
	    Node* tail;
	    Node* current;
};	
ostream& operator << (ostream& out, const LinkedList& list);
#endif	

<details>
<summary>英文:</summary>
Can anyone help me with this question please? For background information, I have three classes, `Account.h` with `Account.cpp`, `Node.h` with `Node.cpp`, `LinkedList.h` with `Linkedlist.cpp`, and `demo.cpp` that contains `int main()`. All of the current functions are working except for printing out the linkedlist, which is the basis of my question.
The question specifically says:
&gt; Implement a non-member overloaded `operator &lt;&lt;` function, that uses the `operator &lt;&lt;` from `Account`, to allow you to perform an operation like:
&gt;
&gt; `cout &lt;&lt; MyLinkedList &lt;&lt; endl;`
I copied specific parts of my code related to this question from `LinkedList.cpp` and `Account.cpp` because it will be too long if I paste it all here.
Code from `LinkedList.cpp` with overloaded `operator &lt;&lt;` function &quot;not yet working&quot; is as shown below: Please note `value_type` is typedef for `Account`.
```c++
#include &quot;LinkedList.h&quot;
LinkedList::value_type LinkedList::getCurrent() const {
if (current != NULL) {
return current-&gt;getData();
} else {
return value_type();
}
}
ostream&amp; operator &lt;&lt; (ostream&amp; out, const LinkedList&amp; list) { // not working, compile error!
value_type current = getCurrent();
while (current != NULL) {
out &lt;&lt; &quot;(&quot; &lt;&lt; acc.getName() &lt;&lt; &quot;,&quot; &lt;&lt; acc.balance() &lt;&lt; &quot;)&quot; &lt;&lt; endl;
}
return out;
}

ostream& operator << (ostream& out, const Account& acc)
{
    out << "(" << acc.getName() << "," << acc.balance() << ")" << endl;
    return out;
}

#ifndef TEKAAI_NODE
#define TEKAAI_NODE
#include "Account.h"
class Node
{
	public:
		// members that are externally visible 
		
		// Below are Member functions
		
		// specifying value_type to Account using typedef
		typedef Account value_type;
		
		// Default constructor
		
		Node();		
		
		// Parameter Constructors
		
		Node(const value_type& initial_data, Node* initial_link);
		
		~Node();	//destructor
		
		void setNext(Node* n);
		
		void setPrevious(Node* p);
		
		Node* getNext() const;
		
		Node* getPrevious() const;
		
		// the data getters and setters
		// Pre-condition: Current has been initialized 
		// Post-condition: set data
		void setData(const value_type& i);
		
		// Pre-condition: Data has been initialized
		// Post-condition: returns stored data
		value_type getData() const;
		
	private:
		value_type data;	//the data held by the node
		Node* next; 		//a pointer to the next node
		Node* previous;		//a pointer to the previous node
};
#endif

#ifndef TEKAAI_LINKEDLIST_H
#define TEKAAI_LINKEDLIST_H
#include "Account.h"
#include "Node.h"
#include <iostream>
class LinkedList
{
    public:
		typedef Account value_type;
		// Members that are externally visible
		
		// These are Member functions
		
		// Constructors
		    
		LinkedList();	
		
		// Destructor
		
		~LinkedList();
		
		void addToHead(const value_type& account); 
		
		void addToTail(const value_type& account);
		
		void addCurrent(const value_type& account);
		
		value_type removeFromHead();
		
		value_type removeFromTail();
		
        value_type removeFromCurrent();
		
	    // Pre-condition: LinkedList contains nodes
		// Post-condition: moves current to the head 
	    void start();  
	    // Pre-condition: LinkedList contains nodes
	    // Post-condition: moves current to the tail
	    void end();
		
	    // Pre-condition: LinkedList contains nodes
	    // Post-condition: moves current one node to the right
	    void forward();  
		
	    // Pre-condition: LinkedList contains nodes
	    // Post-condition: moves current one node to the left
	    void back(); 
		
	    // Pre-condition: LinkedList contains nodes
	    // Post-condition: returns the value of data account stored 
        // in current node
	    value_type getCurrent() const;
		
	    // Pre-condition: LinkedList is initialized, containing 
        // nodes
	    // Post-condition: returns the length of the list
	    int length();
	
	private:
	    Node* head;
	    Node* tail;
	    Node* current;
};	
ostream& operator << (ostream& out, const LinkedList& list);
#endif	

ostream& operator << (ostream& out, const Account& acc)
ostream& operator << (ostream& out, const LinkedList& list)

ostream& operator << (ostream& out, const LinkedList& list) {
    LinkedList::Node *cur = list.getFirst();
    while (cur != NULL) {
        out << cur->getData();
        cur = cur->getNext();
    }
    return out;
}

class LinkedList
{
    public:
        ...        
        bool hasCurrent() const;
        value_type getCurrent() const;        
        ...    
};  

bool LinkedList::hasCurrent() const {
return (current != NULL);
}
LinkedList::value_type LinkedList::getCurrent() const {
return current->getData();
}

ostream& operator << (ostream& out, LinkedList& list) {
list.start();
while (list.hasCurrent()) {
out << list.getCurrent();
list.forward();
}
return out;
}

class Node
{
    public:
        ...        
        value_type& getData();
        ...
};

LinkedList::value_type* LinkedList::getCurrent() {
    if (current != NULL) {
        return &(current->getData());
    } else {
        return NULL;
    }
}

ostream& operator << (ostream& out, LinkedList& list) {
    Account *cur;
    list.start();
    while ((cur = list.getCurrent()) != NULL) {
        out << *cur;
        list.forward();
    }
    return out;
}

class LinkedList
{
    public:
        ...
        friend ostream& operator << (ostream& out, const LinkedList& list);
        ...
    private:
        Node* head;
        ... 
};  
ostream& operator << (ostream& out, const LinkedList& list);

ostream& operator << (ostream& out, const LinkedList& list) {
    Node *cur = list.head;
    while (cur != NULL) {
        out << cur->getData();
        cur = cur->getNext();
    }
    return out;
}