File output inconsistency between GCC and MSVC

Consider the following class which is a simple file loading class used for manipulating small text files by loading the data into memory during construction.

#include <fstream>
#include <ostream>
#include <stdexcept>
#include <string>
#include <vector>

class file_loader {
public:
    /**
     * brief Constructs a file_loader instance using a given filename. Caches the file contents
     *        into the internal cached storage container.
     *
     * param _filename Name/directory of file to load.
     * param _max_line_length Optional, approximate maximum length of file lines.
     */
    file_loader(const std::string& _filename, std::size_t _max_line_length = static_cast<std::size_t>(256)) : fs(_filename), filename(_filename) {
        cache_contents(_max_line_length);
    }
    /**
     * brief Deleted copy construction, copy constructing is forbidden.
     */
    file_loader(const file_loader& _other) = delete;
    /**
     * brief Move constructor, moves a given file_loader instance to this leaving the
     *        parameterised instance in a valid but unspecified state.
     *
     * param _other rvalue reference to a file_loader instance to move.
     */
    file_loader(file_loader&& _other) : fs(std::move(_other.fs)), filename(std::move(_other.filename)),
        cached_contents_vec(std::move(_other.cached_contents_vec)) { }

    /**
     * brief Writes all changes made to the internal cached storage to the 
     *        filestream, overwriting the current contents of the file.
     */
    void write_changes() {
        fs.close();
        fs.open(filename);
        fs.clear();
        write_cache();
    }
    /**
     * brief Reads a given line of the internal cached storage. This internal
     *        store is guaranteed to always be up to date, no call to write_changes
     *        is required to maintain consistency.
     *
     * param _n Line number to read.
     * return const reference to std::string instance given by _n'th line.
     * throws Throws std::out_of_range exception if _n exceeds lines in internal cached storage.
     */
    const std::string& read_line(std::size_t _n) const {
        if (_n >= cached_contents_vec.size())
            throw std::out_of_range("File: " + filename + " does not have " + std::to_string(_n) + " lines.");
        return cached_contents_vec[_n];
    }

    /**
     * brief Overwrites a given line of the internal cached storage such that
     *        the next call to write_changes will update the file contents.
     * 
     * param _n Line number to overwrite.
     * param _str std::string instance to overwrite current line contents with.
     * throws Throws std::out_of_range exception if _n exceeds lines in internal cached storage.
     */
    void overwrite_line(std::size_t _n, const std::string& _str) {
        if (_n >= cached_contents_vec.size())
            throw std::out_of_range("File: " + filename + " does not have " + std::to_string(_n) + " lines.");
        cached_contents_vec[_n] = _str;
    }
    /**
     * brief Erases a given line of the internal cached storage such that
     *        the next call to write_changes will update the file contents.
     *
     * param _n Line number to erase.
     * return Iterator to next valid position in internal cached storage container.
     */
    auto erase_line(std::size_t _n) {
        return cached_contents_vec.erase(cached_contents_vec.begin()+_n);
    }

    /**
     * brief Deleted copy assignment operator, copy assignment is forbidden.
     */
    file_loader& operator=(const file_loader& _other) = delete;
    /**
     * brief Move assignment operator, uses move-semantics to move the parameterised
     *        file_loader instance to this. Instance being moved is left in a
     *        valid but unspecified state.
     *
     * param _other rvalue reference to file_loader instance.
     */
    file_loader& operator=(file_loader&& _other) {
        // check for self-assignment
        if (this != &_other) {
            fs = std::move(_other.fs);
            filename = std::move(_other.filename);
            cached_contents_vec = std::move(_other.cached_contents_vec);
        }
        return *this;
    }
private:
    std::fstream fs;
    std::string filename;
    std::vector<std::string> cached_contents_vec;   // internal cached storage container

    /**
     * brief Caches contents of files into the internal cached storage container.
     *
     * param _max_line_length Approximate maximum line length of the file, used for performance improvements.
     */
    void cache_contents(std::size_t _max_line_length) {
        std::string line_str;
        // reserve space for performance
        line_str.reserve(_max_line_length);
        while (std::getline(fs, line_str)) {
            cached_contents_vec.push_back(line_str);
        }
    }

    /**
     * brief Convenience method for writing a std::vector<std::string> to an std::ostream instance.
     *
     * param _os Instance of std::ostream. 
     * param _vec Instance of std::vector<std::string> to write to _os.
     * return Reference to _os modified with data of _vec.
     */
    void write_cache() {
        for (const auto& x : cached_contents_vec) {
            fs << x << "n";
        }
    }

};

Using this class seems to yield different results when executing via GCC (6.1.0) and MSVC (2015). Say I have the following text file (test.txt):

cheese
ham
eggs
beef
bacon

and the following main:

int main(void) {
    file_loader fl("test.txt");
    fl.overwrite_line(3, "chicken");
    fl.write_changes();
}

In MSVC it yields the result I expected:

cheese
ham
eggs
chicken
bacon

However in GCC (6.1.0) I get:

cheese
ham
eggs
chickenbacon

In other words, the latter seems to "concatenate" the overwritten line and the line below into a single entry of the cached_contents_vec whereas the former keeps the entries separate (as they should be as far as I am aware in this case).

Any ideas what is happening here? I should also mention that in file_loader::write_changes() MSVC does not require the two initial lines in this method to overwrite the previous file contents whereas GCC does.