Конвертирование из vector<string> в map

#include <fstream>
#include <map>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <istream>
#include <string>
using namespace std;
 
int main()
{
    map<int,string> mymap;
    ifstream f("example.txt");
    string line;
    vector<string> lines;
    while (!f.eof())
    {
        while(getline(f,line))
        {
            lines.push_back(line);
        }
    }
for(vector<string>::iterator it = lines.begin(); it != lines.end(); ++it)
    {
        string tmpstr;
        while((*it)!= "Nodes:")
        {
            if((*it)!="Objects:")
            {
                int num;
                while((*it) != " ")// проверка на пробел 
                {
                      tmpstr+=(*it); //1
                      *it++;// пробел
            }
                      num = stoi(tmpstr);// эта строчка должна конвертировать 1 в int, но меня это смущает
                      tmpstr="";
                      *it++;
                      while((*it)!=" ")
                {
                      tmpstr+=(*it);
                      *it++;
            }
                      if(tmpstr!="")
                          mymap[num] = tmpstr; // как мне кажется, проблема в этой строчке
            }
 
        }
    }
    for(map<int, string>::iterator it = mymap.begin(); it != coll.end(); ++it)
    {
        cout << (*it).first << (*it).second << endl;
    }
    return 0;
}

    ifstream f("example.txt");
    if (!f)
    {
        cout << "Error!" << endl;
        system("pause");
        return 0;
    }
 
    map<int, string> mymap;
    int num;
    string tmpstr;
    f.ignore(255, '\n'); // пропускаем первую строку
    while (f >> num >> tmpstr) // на Nodes поток сломается и будет выход из чтения
    {
        mymap[num] = tmpstr;
    }
   
    for(map<int, string>::iterator it = mymap.begin(); it != mymap.end(); ++it)
    {
        cout << (*it).first << ' ' << (*it).second << endl;
    }

    ifstream f("example.txt");
    if (!f)
    {
        cout << "Error!" << endl;
        system("pause");
        return 0;
    }
 
    map<int, string> mymap;
    vector <string> vstr;
    int num;
    string tmpstr;
    while (getline(f, tmpstr))
        vstr.push_back(tmpstr);
    
    stringstream ss;
    for (int i = 0; i < vstr.size(); ++i)
    {
        if (vstr[i] != "Objects:" && vstr[i] != "Nodes:")
        {
            ss << vstr[i];
            ss >> num >> tmpstr;
            ss.clear();
            ss.str("");
            mymap[num] = tmpstr;
        }
    }
    
    for(map<int, string>::iterator it = mymap.begin(); it != mymap.end(); ++it)
    {
        cout << (*it).first << ' ' << (*it).second << endl;
    }

// --- закомментируйте эту строчку для релиза
#define DEBUG
 
 
// ========================================================================================
// ===================================== trim =============================================
 
// обрезает пробельные символы в начале и в конце строки
 
// TODO:
// функции ltrim и rtrim
// работают без учета локали
// по хорошему это нужно исправить
 
#include <algorithm>
#include<functional>
#include <cctype>
#include <locale>
 
// удаляет пробелы слева от текста
inline std::string& ltrim(std::string& s)
{
    s.erase(s.begin(),  
        std::find_if(s.begin(), s.end(), std::ptr_fun<int, int>(std::isgraph))
    );
    return s;
}
 
// удаляет пробелы справа от текста
inline std::string& rtrim(std::string& s)
{
    s.erase(
        std::find_if(s.rbegin(), s.rend(), std::ptr_fun<int, int>(std::isgraph)).base(), 
        s.end() 
    );
    return s;
}
 
// удаляет пробелы слева и справа от текста
inline std::string& trim(std::string& s) { return ltrim(rtrim(s)); }
 
// удаляет все пробельные символы из строки
inline std::string& remove_spc(std::string& s) 
{ 
    const auto lambda = [](const char ch)
    {
        static std::locale loc("");
        return std::isspace(ch, loc);
    };
    s.erase(
        std::remove_if(s.begin(), s.end(), lambda),
        s.end()
    );
    return s;
}
 
// ========================================================================================
// ========================================================================================
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <map>
 
#ifdef DEBUG
    #define dENDL "\n"
#else
    #include <fstream>
#endif
 
// функция получает на входе список слов
// а на выходе дает map
std::map<int, std::string> to_map(const std::vector<std::string>& src);
 
 
// функция вернет true,
// если value совпадает с etalon
// при этом пробельные символы не учитываются
bool is_section(const std::string& etalon, const std::string& value);
 
 
int main()
{
 
#ifdef DEBUG
    // --- на этапе разработки 
    // будем брать исходные данные прямо из исходника
    // (так удобнее)
    const std::string content =
        "Objects: " dENDL
        "1 a"       dENDL
        "2 b"       dENDL
        "3 c"       dENDL
        "Nodes : "  dENDL;
 
    std::stringstream f(content);
#else
 
    // в релизе грузим данные с диска
    std::ifstream f("example.txt");
#endif
 
    // --- перегружаем данные из файла в контейнер строк
    // примечание: std::vector не самый лучший выбор для этой цели
    // лучше было бы использовать std::list
 
    std::vector<std::string>   
        lines;
 
    { // --- ограничиваем область видимости переменной line
        std::string line;
        while (std::getline(f, line))
            lines.push_back(line);
    }
 
#ifdef DEBUG
    // на этапе разработки
    // покажем содержимое файла
    // который нужно распарсить
    std::cout << "content of file:\n";
    for (const auto& s : lines)
        std::cout << "line: '" << s << "'\n";
    std::cout << '\n' << std::endl;
#endif
 
    // --- теперь на базе загруженных строк
    // по нашим правилам
    // формируем std::map
    const auto mymap = to_map(lines);
 
    // --- покажем результат работы
    std::cout << "map:\n";
    for (const auto& pair_ : mymap)
        std::cout << "key = '" << pair_.first 
        << " : value = '" << pair_.second << "'\n";
 
}
 
// ========================================================================================
// ========================================================================================
 
bool is_section(const std::string& etalon, const std::string& value)
{
    auto check = value;
    remove_spc(check);
    return check == etalon;
}
 
// ========================================================================================
// ========================================================================================
 
std::map<int, std::string> 
to_map(const std::vector<std::string>& src)
{
    std::map < int, std::string >
        result;
 
    for (const auto& line : src)
    {
        // --- сначала удаляем лишние пробелы
        auto cur = line;
        trim(cur);
 
        if (is_section("Nodes:", cur))
            break;
        if (is_section("Objects:", cur))
            continue; 
 
        // --- извлекаем ключ и значение:
        std::stringstream ss(cur);
        std::string key, value;
        ss >> key >> value;
        result[ std::stoi(key) ] = value;
 
        // TODO: по хорошему нужно добавить проверки:
        // проверка случая, когда такой ключ уже существует
        // проверить, что ss не поломался
    }
    return result;
}

//-------------------------------------------------------------------------        
//---------- кросс-платформенный макрос отображения имени функции ---------
//-------------------------------------------------------------------------        
 
#if defined(__GNUC__) || defined(__MINGW32__) || defined(__MINGW__)
    #define dFUNCTION __PRETTY_FUNCTION__
#else
    #ifdef _MSC_VER
        #define dFUNCTION __FUNCSIG__
    #else
        #define dFUNCTION __FUNCTION__
    #endif
#endif
 
//-------------------------------------------------------------------------         
//-------------------------------------------------------------------------        
//-------------------------------------------------------------------------        
 
#include <vector>
#include <iostream>
 
struct sample
{
    sample()              { std::cout << dFUNCTION << std::endl; } 
    sample(const sample&) { std::cout << dFUNCTION << std::endl; } 
    sample(sample&&)      { std::cout << dFUNCTION << std::endl; } 
};
 
int main()
{
    std::cout << "Hello, world!\n";
    
    std::vector<sample> vec;
    
    for(size_t n=0; n<10; ++n)
        vec.push_back( std::move(sample()) );
}

sample(sample&&)noexcept      { std::cout << dFUNCTION << std::endl; }