fstream вывод из файла в собственный класс List

#include <iostream>
#include <fstream>
#include <string>
 
template<typename T>
class List {
private:
    template<typename T>
    class Node {
    public:
        Node* pNext;
        T data;
 
        Node(T data = T(), Node* pNext = nullptr) {
            this->data = data;
            this->pNext = pNext;
        }
    };
    Node<T>* head;
    int size;
public:
    List();
    ~List();
    void push_front(T data);
    void insert(T value, int index);
    void removeAt(int index);
    void pop_back();
    void clear();
    void pop_front();
    void push_back(T data);
    int getSize() { return size; }
    T& operator[] (const int index);
};
 
template<typename T>
List<T>::List() {
    size = 0;
    head = nullptr;
}
 
template<typename T>
List<T>::~List() {
    clear();
}
 
template<typename T>
void List<T>::push_front(T data) {
    head = new(std::nothrow) Node<T>(data, head);
    size++;
 
}
 
template<typename T>
void List<T>::insert(T value, int index) {
    if (true) {
        push_front(value);
    }
    else {
        Node<T>* previous = this->head;
        for (int i = 0; i < index - 1; i++) {
            previous = previous->pNext;
        }
        Node<T>* newNode = new (std::nothrow) Node<T>(value, previous->pNext);
        previous->pNext = newNode;
        size++;
    }
}
 
template<typename T>
void List<T>::removeAt(int index) {
    if (index == 0) {
        pop_front;
    }
    else {
        Node<T>* previous = this->head;
        for (int i = 0; i < index - 1; i++) {
            previous = previous->pNext;
        }
        Node<T>* toDelete = previous->pNext;
        previous->pNext = toDelete->pNext;
        delete toDelete;
        size--;
    }
}
 
template<typename T>
void List<T>::pop_back() {
    removeAt(size - 1);
}
 
template<typename T>
void List<T>::clear() {
    while (size) {
        pop_front();
    }
}
 
template<typename T>
void List<T>::pop_front() {
    Node<T>* temp = head;
    head = head->pNext;
    delete temp;
    size--;
}
 
template<typename T>
void List<T>::push_back(T data) {
    if (head == nullptr) {
        head = new (std::nothrow) Node<T>(data);
    }
    else {
        Node<T>* current = this->head;
        while (current->pNext != nullptr) {
            current = current->pNext;
        }
        current->pNext = new (std::nothrow) Node<T>(data);
    }
    size++;
}
 
template<typename T>
T& List<T>::operator[](const int index) {
    int counter = 0;
    Node<T>* current = this->head;
    while (current != nullptr) {
        if (counter == index) {
            return current->data;
        }
        current = current->pNext;
        counter++;
    }
}
 
int main() {
    List <int> list;
    std::fstream fs;
    fs.open("myFile.txt", std::fstream::out, std::fstream::in);
    if (!fs.is_open()){
        std::cout << "Error open File!";
    }
    else {
        std::cout << "Open File!";
        int i = 0;
        while (!fs.eof()) {
            fs << list[i];
        }
    }
    
    return 0;
}

    if (true) {
        push_front(value);

string z;
        while (!fs.eof()) {
            z = "";
            getline(fs, z);

    fs.open("myFile.txt", std::fstream::out, std::fstream::in);
    if (!fs.is_open()){
        std::cout << "Error open File!";
    }
    else {
        std::cout << "Open File!";
        int i = 0;
        while (fs >> i) {
            list.push_back(i);
        }
    }

#include <iostream>
 
template<typename T>
class ForwardList {
public:
    struct Node {
        Node *next;
        Node() : next(this) {}
        Node(Node *prev) : next(prev->next) {
            prev->next = this;
        }
        void remove(Node *prev) {
            prev->next = next;
        }
        virtual ~Node() {}
    };
    struct ValueNode : Node {
        T value;
        ValueNode(const T &value, Node *prev) : value(value), Node(prev) {}
    };
 
    ForwardList() : base() {}
    ForwardList(const ForwardList<T> &) = delete;
    ForwardList<T> &operator=(const ForwardList<T> &) = delete;
    ~ForwardList() {
        clear();
    }
 
    bool isEmpty() const {
        return &base == base.next;
    }
 
    void clear() {
        while (!isEmpty()) {
            Node *next = base.next;
            base.next->remove(&base);
            delete next;
        }
    }
 
    Node *beforeBegin() {
        return &base;
    }
    Node *begin() {
        return base.next;
    }
    Node *end() {
        return &base;
    }
    Node *insert(const T &value, Node *after) {
        return new ValueNode(value, after);
    }
private:
    Node base;
};
 
int main() {
 
    ForwardList<int> digits;
 
    std::istream &in = std::cin;
    // для файлов:
    //std::ifstream in("myfile.txt");
 
    ForwardList<int>::Node *last = digits.beforeBegin();
    for (char c; in >> c;) {
        if (c >= '0' && c <= '9') {
            last = digits.insert(c - '0', last);
        }
    }
 
    for (ForwardList<int>::Node *i = digits.begin(); i != digits.end(); i = i->next) {
        std::cout << dynamic_cast<ForwardList<int>::ValueNode*>(i)->value << std::endl;
    }
 
    return 0;
}