Почему вместо значения выводит мусор

#include <iostream>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <vector>
#include <utility>
using string = std::string;
using std::vector; using std::pair;
using boost::property_tree::ptree;
 
class ParserXLSX{
using row_t = vector<string>;
public:
    ParserXLSX(string sheetf, string stringsf){
        m_sheetf   = sheetf;
        m_stringsf = stringsf;
        is_data = false;
    }
    bool to_CSV(string filename){
        if (is_data){
            std::ofstream fout(filename);
            if (fout.is_open()){
                for(size_t r=0; r<rows.size(); ++r){
                    if (!rows[r].empty())
                        fout << rows[r][0];
                    for(size_t c=1; c<rows[r].size(); ++c)
                        fout << ',' << rows[r][c];
                    fout << std::endl;
                }
                return true;
            }
        }
        return false;
    }
    vector<row_t>& readData(){
        if (loadStrings(m_stringsf, m_strings) && loadSheet(m_sheetf, rows))
            is_data = true;
        return rows;
    }
 
private:
    vector<string> m_strings;
    vector<row_t> rows;
    string m_sheetf, m_stringsf;
    pair<int,int> start_cell, end_cell;
    bool is_data;
    bool loadStrings(string file, vector<string>& strings){
        ptree pt;
        try{
            read_xml(m_stringsf, pt);
            for ( auto [str, end] = pt.get_child("sst").equal_range("si"); str!=end; ++str)
                strings.push_back(str->second.get<string>("t"));
        }catch(std::exception& e){
            strings.clear();
            return false;
        }
        return true;
    }
    bool loadSheet(string file, vector<row_t>& data_rows){
        ptree pt;
        try{
            read_xml(m_sheetf, pt);
            auto dimm = pt.get<string>("worksheet.dimension.<xmlattr>.ref");
            auto delim = dimm.find(':');
            start_cell = cell_to_i(dimm.substr(0, delim));
            end_cell    = cell_to_i(dimm.substr(delim+1));
            int rows = end_cell.first  - start_cell.first + 1;
            int cols = end_cell.second - start_cell.second + 1;
            data_rows.reserve(rows);
            int last_row = start_cell.first, last_col = start_cell.second;
            int curr_row, curr_col;
            row_t empty_row(cols);
            for ( auto [row, end] = pt.get_child("worksheet.sheetData").equal_range("row"); row!=end; ++row){
                curr_row = row->second.get<int>("<xmlattr>.r");
                while(last_row < curr_row - 1){
                    data_rows.emplace_back(empty_row);
                    ++last_row;
                }
 
                row_t data_row(cols);
                last_col = start_cell.second;
                for ( auto [cell, end] = row->second.equal_range("c"); cell!=end; ++cell){
                    curr_col = cell_to_i(cell->second.get<string>("<xmlattr>.r")).second;
                    string v;
                    try{
                        v = cell->second.get<string>("v");
                    }catch(...){}
                    string type;
                    // с атрибутами нужно быть внимательными, их может и не быть
                    // как в случае с типом у ячеек. поэтому я обрабатываю исключение
                    if (!v.empty()){
                        try{
                            type = cell->second.get<string>("<xmlattr>.t");
                        }catch(...){}
                        if (!type.empty()){
                            // нужна функция экранирования спец символов
                            if (type == "s") // если строковой тип
                                data_row.at(curr_col) = m_strings.at(cell->second.get<int>("v"));
                        }
                        else
                            data_row.at(curr_col) = v;
                    }
                    last_col = curr_col;
                }
                data_rows.push_back(std::move(data_row));
                last_row = curr_row;
            }
        }catch(std::exception& e){
            data_rows.clear();
            std::cout << e.what();
            return false;
        }
        return true;
    }
 
    pair<int, int> cell_to_i(const string& str){
        pair<int, int> res{0,0};
        if (str.size()>1){
            res.second = str[0] - 'A';
            res.first  = std::atoi(&str[1])-1;
        }
        return res;
    }
};
 
 
int main(){
    std::system("chcp 65001");
    ParserXLSX parser("sheet1.xml", "sharedStrings.xml");
    std::cout << "pasred lines : " << parser.readData().size() << std::endl;
    if (parser.to_CSV("table.csv")){
        std::cout << "Export to csv - success.";
    }else
        std::cout << "Export to csv - error.";
 
    return 0;
}