Работа со списком и запись его в файл

Наподобие такого наверное (правда Вам это не поможет скорее всего, написал за два часа - куча багов, разве что примерно как делать) :

#include <iostream>
#include <memory>
#include <exception>
#include <iterator>
#include <fstream>

template<typename T>
class ListIterator;
template <typename T>
class List{
public:

    using iterator = ListIterator<T>;
    using const_iterator = ListIterator<T>;

    iterator begin(){
        return iterator(m_head.get());
    }
    const_iterator begin() const{
        return const_iterator(m_head.get());
    }
    const_iterator cbegin() const{
        return const_iterator{m_head.get()};
    }
    iterator end(){
        return iterator(nullptr);
    }
    const_iterator end() const{
        return const_iterator(nullptr);
    }
    const_iterator cend() const{
        return const_iterator(nullptr);
    }
    List():
        m_head{},
        m_size{0}
    {}
    List(const std::initializer_list<T>& list):
        m_head{},
        m_size{0}
    {
        for (const auto& e: list){
            push_front(e);
        }
    }
    List(const List& other):
        m_head{},
        m_size{0}
    {
        for (const auto& e: other){
            push_front(e);
        }
    }
    List& operator=(const List& other){
        if (this != & other){
            clear();
            for (const auto& e: other){
                push_front(other);
            }
        }
        return *this;
    }
    virtual ~List(){
        clear();
    }
    void push_front(const T& data){
        std::shared_ptr<ListItem> newItem{new ListItem(data, m_head)};
        m_head = newItem;
        ++m_size;
    }
    void clear(){
        while (!empty()){
            pop_front();
        }
    }
    iterator insert_after(const_iterator pos, const T& value){
        std::shared_ptr<ListItem> newItem{new ListItem(value, m_head)};
        newItem->next() = pos.m_p->next();
        pos.m_p->next() = newItem;
        ++m_size;
        return iterator(newItem.get());
    }
    const T& front() const{
        if (!empty())
            return m_head->data();
        else
            return m_emptyData; // Если список пуст - вернём пустые данные
    }
    void pop_front(){
        if (empty()){
            return;
        }
        m_head = m_head->next();
        --m_size;
    }
    std::size_t size() const{
        return m_size;
    }
    bool empty() const{
        return m_size == 0;
    }
    class ListItem{
    public:
        ListItem(const T& data, std::shared_ptr<ListItem> next = nullptr):
            m_data{data},
            m_next{next}
        {}
        ListItem() = default;
        ListItem(const ListItem& other) = default;
        ListItem& operator=(const ListItem& other) = default;
        const T& data() const{
            return m_data;
        }
        T& data(){
            return m_data;
        }
        const std::shared_ptr<ListItem>& next() const{
            return m_next;
        }
        std::shared_ptr<ListItem>& next(){
            return m_next;
        }
    private:
        T m_data;
        std::shared_ptr<ListItem> m_next;
    };
private:

    std::shared_ptr<ListItem> m_head;
    std::size_t               m_size;
    static const T            m_emptyData = T();
};

template<typename T>
class ListIterator: public std::iterator<std::forward_iterator_tag, T>
{
    friend class List<T>;
public:
    ListIterator(const ListIterator& it):
        m_p{it.m_p}
    {}
    typename ListIterator::reference operator* (){
        return m_p->data();
    }
    const  typename ListIterator::reference operator* () const{
        return m_p->data();
    }
    bool operator !=(const ListIterator& other) const{
        return m_p != other.m_p;
    }
    bool operator ==(const ListIterator& other) const{
        return m_p == other.m_p;
    }
    ListIterator& operator++(){
        m_p = m_p->next().get();
        return *this;
    }
    ListIterator operator++(int){
        ListIterator ret = *this;
        ++(*this);
        return ret;
    }

    typename List<T>::ListItem* m_p;
    ListIterator(typename List<T>::ListItem* p):
        m_p{p}
    {}


};
template<typename T>
void saveToFile(const List<T>& c, const std::string& fileName){
    std::ofstream f(fileName);
    for (const auto& e: c){
        f << e  << " ";
    }
    f.close();
    return;
}
template<typename T>
void readFromFile(List<T>& c, const std::string& fileName){
    std::ifstream f(fileName);
    T t;
    c.clear();
    while (f >> t){
        c.push_front(t);
    }
    f.close();
    return;
}

int main()
{
    List<int> l{1,2,3,4,5};
    for (const auto& e: l){
         std::cout << e << " ";
    }
    std::cout << std::endl;
    saveToFile(l, "out.txt");
    l.clear();
    readFromFile(l, "out.txt");
    auto it = l.cbegin();
    for (; it != l.cend(); it++){
        if (*it == 3){
            l.insert_after(it, 10);
        }
    }
    for (const auto& e: l){
         std::cout << e << " ";
    }
    std::cout << std::endl;
    saveToFile(l, "out.txt");
    List<int> newList;
    readFromFile(newList, "out.txt");
    std::cout << "after read from file" << std::endl;
    for (const auto& e: newList){
         std::cout << e << " ";
    }
    std::cout << std::endl;
    return 0;
}

Вывод в консоль:

5 4 3 2 1 
1 2 3 10 4 5 
after read from file
5 4 10 3 2 1