Регулярное выражение boost::regex

"([a-z]+)=[\\w,]+#([a-z]+)=[\\w,]+#([a-z]+)=[\\w,]+"

if( boost::regex_match(parameters, results, regex) )
        for(const auto& x : results)
            std::cout << x;
// out
g=p1,p2
s=p1,p2
t=p1,p2,p3
k=p1

multimap<std::string, std::string> m;
//.. 
if( boost::regex_...(x, results2, regex2) )
//..
for(const auto& i : results2)
//..
m.insert(pair<string, std::string>("g", p1));
m.insert(pair<string, std::string>("g", p2));
 
m.insert(pair<string, std::string>("s", p1));
m.insert(pair<string, std::string>("s", p2));
 
m.insert(pair<string, std::string>("t", p1));
m.insert(pair<string, std::string>("t", p2));
m.insert(pair<string, std::string>("t", p3));
 
m.insert(pair<string, std::string>("k", p1));
}

#include <iostream>
#include <string>
#include <vector>
#include <boost/algorithm/string/regex.hpp>
 
int main() {
    const std::string parameters = "g=p1#s=p1,p2#t=p1";
    std::vector<std::string> matches;
    boost::find_all_regex(matches, parameters, boost::regex("\\w+\\s*=\\w+\\s*(,\\w+\\s*)*(?=#)*"));
    for (auto& str : matches)
        std::cout << str << "\n";
}

    std::multimap<std::string, std::string> m;
    std::string s = "g=p1#s=p1,p2#t=p1#z=p3,p4,p10";
 
    std::regex r("#*([a-z]+)=([\\w,]+)");
    std::regex r1(",*(\\w+)");
 
    for (auto it = std::regex_iterator<std::string::iterator>(s.begin(), s.end(), r); it != std::regex_iterator<std::string::iterator>(); ++it)
    {
        std::string p = (*it)[2];
 
        for (auto it1 = std::regex_iterator<std::string::iterator>(p.begin(), p.end(), r1); it1 != std::regex_iterator<std::string::iterator>(); ++it1)
        {
            std::cout << (*it)[1] << " " << (*it1)[1] << std::endl;
            m.insert(std::make_pair((*it)[1], (*it1)[1]));
        }
    }

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <utility>
#include <boost/phoenix/phoenix.hpp>
#include <boost/spirit/include/qi.hpp>
 
namespace qi = boost::spirit::qi;
namespace phx = boost::phoenix;
namespace ascii = boost::spirit::ascii;
 
using map_t = std::multimap<std::string, std::string>;
using pair_t = std::pair<std::string, std::string>;
 
// g=p1#s=p1,p2#t=p1#z=p3,p4,p10
 
template <typename Iterator>
struct my_grammar : qi::grammar<Iterator, ascii::space_type>
{
   my_grammar(map_t& map) : my_grammar::base_type(pairs)
   {
      using qi::_1;
      using qi::_a;
      using qi::char_;
      using qi::alnum;
      using qi::alpha;
      using phx::construct;
      using phx::insert;
 
      pairs = pair % '#';
      pair  = string_[_a = _1] >> '=' >> string_[insert(phx::ref(map), construct<pair_t>(_a, _1))] % ',';
      string_ = (alpha | char_('_')) >> *(alnum | char_('_'));
   }
 
   qi::rule<Iterator, ascii::space_type> pairs;
   qi::rule<Iterator, qi::locals<std::string>, ascii::space_type> pair;
   qi::rule<Iterator, std::string()> string_;
};
 
int main()
{
   std::string expr;
   map_t map;
 
   using ascii::space;
   while (true)
   {
      std::cout << "Enter expr: ";
      std::getline(std::cin, expr);
      std::string::iterator  begin = expr.begin(), end   = expr.end();
      my_grammar<std::string::iterator> gr(map);
      qi::phrase_parse(begin, end, gr, space);
 
      for (const auto& p : map)
         std::cout << p.first << " " << p.second << "\n";
   }
}