Segmentation fault (iterator)

#include "app_headers/abstractconverter.h"
#include <iostream> // std::cerr
#include <boost/regex.hpp>
 
/*-> static <-*/ void AbstractConverter::filter_string(std::string &str) try {
    typedef std::string::iterator SIt_t;
    typedef std::string::const_iterator CSIt_t;
    typedef std::string::difference_type diff_t;
    bool withMinus;
    char* prevLocale = setlocale(LC_CTYPE, "C");
 
    // If the first non-whitespace character is '-'
    SIt_t mainIter = std::find_if_not(str.begin(), str.end(),
                                     [](char ch) -> bool {return isspace(ch);});
    // we consider, that the number is negative, otherwise - non negative.
    if(mainIter == str.end())
        throw prevLocale;
    if(*mainIter == '-')
    {
        withMinus = true;
        ++mainIter;
    }
    else withMinus = false;
 
    if(withMinus)
    {
        // Erase all unnecessary symbols between
        // '-' and first digit of the number.
        // This is requirement of GMP functions
        // mpf_set_str() and mpz_set_str().
        // See their documentation for details.
 
        // Find First Alpha-Numeric Symbol after minus.
        SIt_t fans = std::find_if(mainIter,
                                  str.end(),
                                  [](char ch) -> bool { return isalnum(ch); }
                                );
        if(fans == str.end())
            throw prevLocale;
        else str.erase(mainIter, fans);
    }
    // Here we at the position of the first meaning digit of the number.
 
    boost::regex reg(R"_([[:alnum:]]+\.[[:alnum:]]+)_", boost::regex_constants::extended);
    boost::smatch match;
    CSIt_t search_begin(mainIter);
 
    if ( boost::regex_search(search_begin, str.cend(), match, reg) )
    {
        diff_t capture_pos = match.position();
        for( ; mainIter != mainIter + capture_pos; ++mainIter)
            if(!isalnum(*mainIter))
                *mainIter = ' ';
        mainIter += match.length();
    }
 
 
    // Replace all unnecessary symbols in the number with spaces ' ';
    // If in the number presented multiple dots ('.'), only first dot
    // is accepted, while others replaced with spaces.
    // GMP funcs mpf_set_str() and mpz_set_str() are ignore spaces.
 
    for( ; mainIter != str.end(); ++mainIter)
        if(!isalnum(*mainIter))
            *mainIter = ' ';
 
    setlocale(LC_CTYPE, prevLocale);
}
 
catch (char* prevLoc)
{
    str.assign("0");
    std::cerr << "AbstractConverter::filter_string(std::string&): Exception: "
                 "No valid digits in the number\n";
    setlocale(LC_CTYPE, prevLoc);
    return;
}

#include <algorithm>
#include <cctype>    // isalnum(), ...
#include <iostream> // std::cerr
#include <string>
#include <boost/regex.hpp>
inline void filter_string(std::string &s) try {
    typedef std::string::iterator SIt_t;
    typedef SIt_t::value_type charT;
    typedef std::string::const_iterator CSIt_t;
    bool withMinus, withDot;
    auto alnum = [](charT c) -> charT {
        return isalnum(c) ? c : ' ';
    };
    char* prevLocale = setlocale(LC_CTYPE, "C");
 
    // If the first non-whitespace character is '-'
    SIt_t mainIter = std::find_if_not(s.begin(), s.end(),
                                     [](char ch) {return isspace(ch);});
    // we consider, that the number is negative, otherwise - non negative.
    if(mainIter == s.end())
        throw prevLocale;
    withMinus = *mainIter == '-' ? true : false;
    if(withMinus)
    {
        // Fill the range from '-' to first digit of the number with spaces and
        // preced this digit with '-'.
        // GMP functions mpf_set_str() and mpz_set_str() in current revision are
        // not allow spaces between minus and first digit of the number.
        // See their documentation for details on [url]https://gmplib.org/manual/[/url]
 
        // Find First Alpha-Numeric Symbol after minus.
        SIt_t fans = std::find_if(mainIter, s.end(),
                                  [](char ch) { return isalnum(ch); });
        if(fans == s.end())
            throw prevLocale;
        else
        {
            mainIter = std::fill_n(mainIter, std::distance(mainIter, fans), ' ');
            *(mainIter-1) = '-';
        }
    }
    // Here we at the position of the first meaning digit of the number.
 
    withDot = std::find(mainIter, s.end(), '.') == s.end() ? false : true;
 
    if(withDot)
    {
        // If in the number presented multiple dots ('.'), only first dot with
        // adjoined one or more alnums is accepted, while others replaced with
        // spaces. GMP funcs mpf_set_str() and mpz_set_str() are simply
        // ignore spaces.
        using namespace boost;
        regex e(R"_([[:alnum:]]+\.[[:alnum:]]+)_", regex_constants::extended);
        smatch what;
        CSIt_t search_begin(mainIter);
        if ( regex_search(search_begin, s.cend(), what, e) )
        {
            SIt_t last = mainIter + what.position();
            mainIter = std::transform(mainIter, last, mainIter, alnum);
            mainIter += what.length();
        }
    }
    std::transform(mainIter, s.end(), mainIter, alnum);
    setlocale(LC_CTYPE, prevLocale);
}
 
catch (const char* prevLoc)
{
    s.assign("0");
    std::cerr << "AbstractConverter::filter_string(std::string&): Exception: "
                 "No valid digits in the number\n";
    setlocale(LC_CTYPE, prevLoc);
    return;
}