Заменить регулярные выражения с обратным вызовом в C++11?

Есть ли функция замены регулярных выражений, которая отправит совпадения пользовательской функции, а затем подставит возвращаемое значение:

Я попробовал этот метод, но он явно не работает:

cout << regex_replace("my values are 9, 19", regex("\d+"), my_callback);

и функция:

std::string my_callback(std::string &m) {
  int int_m = atoi(m.c_str());
  return std::to_string(int_m + 1);
}

и результат должен быть: my values are 10, 20

Я имею в виду аналогичный режим работы, как PHP preg_replace_callback или питона re.sub(pattern, callback, subject)

И я имею в виду последние 4.9 gcc, которые способны к регулярному выражению без наддува.

Источник

3 ответа

Решение

Я хотел такую ​​функцию, и мне не понравился ответ "используй буст". Проблема с ответом Бенджамина в том, что он предоставляет все токены. Это означает, что вы не знаете, какой токен совпадает, и он не позволяет использовать группы захвата. Это делает:

// clang++ -std=c++11 -stdlib=libc++ -o test test.cpp
#include <cstdlib>
#include <iostream>
#include <string>
#include <regex>

namespace std
{

template<class BidirIt, class Traits, class CharT, class UnaryFunction>
std::basic_string<CharT> regex_replace(BidirIt first, BidirIt last,
    const std::basic_regex<CharT,Traits>& re, UnaryFunction f)
{
    std::basic_string<CharT> s;

    typename std::match_results<BidirIt>::difference_type
        positionOfLastMatch = 0;
    auto endOfLastMatch = first;

    auto callback = [&](const std::match_results<BidirIt>& match)
    {
        auto positionOfThisMatch = match.position(0);
        auto diff = positionOfThisMatch - positionOfLastMatch;

        auto startOfThisMatch = endOfLastMatch;
        std::advance(startOfThisMatch, diff);

        s.append(endOfLastMatch, startOfThisMatch);
        s.append(f(match));

        auto lengthOfMatch = match.length(0);

        positionOfLastMatch = positionOfThisMatch + lengthOfMatch;

        endOfLastMatch = startOfThisMatch;
        std::advance(endOfLastMatch, lengthOfMatch);
    };

    std::regex_iterator<BidirIt> begin(first, last, re), end;
    std::for_each(begin, end, callback);

    s.append(endOfLastMatch, last);

    return s;
}

template<class Traits, class CharT, class UnaryFunction>
std::string regex_replace(const std::string& s,
    const std::basic_regex<CharT,Traits>& re, UnaryFunction f)
{
    return regex_replace(s.cbegin(), s.cend(), re, f);
}

} // namespace std

using namespace std;

std::string my_callback(const std::smatch& m) {
  int int_m = atoi(m.str(0).c_str());
  return std::to_string(int_m + 1);
}

int main(int argc, char *argv[])
{
    cout << regex_replace("my values are 9, 19", regex("\\d+"),
        my_callback) << endl;

    cout << regex_replace("my values are 9, 19", regex("\\d+"),
        [](const std::smatch& m){
            int int_m = atoi(m.str(0).c_str());
            return std::to_string(int_m + 1);
        }
    ) << endl;

    return 0;
}
Источник

Вы могли бы использовать regex_token_iterator

#include <iostream>
#include <algorithm>
#include <regex>
#include <string>
#include <sstream>

int main()
{
    std::string input_text = "my values are 9, 19";
    std::string output_text;
    auto callback = [&](std::string const& m){
        std::istringstream iss(m);
        int n;
        if(iss >> n)
        {
            output_text += std::to_string(n+1);
        }
        else
        {
            output_text += m;
        }
    };

    std::regex re("\\d+");
    std::sregex_token_iterator
        begin(input_text.begin(), input_text.end(), re, {-1,0}),
        end;
    std::for_each(begin,end,callback);

    std::cout << output_text;
}

Обратите внимание, что {-1,0} в списке аргументов конструктора итератора находится список, определяющий подспаривания, по которым мы хотим выполнить итерацию. -1 для несоответствующих разделов, а 0 для первого субматча.

Также обратите внимание, что я не использовал функциональность регулярных выражений C++11 и не являюсь экспертом в этом. Так что могут быть проблемы с этим кодом. Но для вашего конкретного вклада я проверил его, и он, кажется, дает ожидаемые результаты. Если вы найдете какой-либо входной набор, для которого он не работает, пожалуйста, дайте мне знать.

Источник

Может быть, я пришел на эту вечеринку слишком поздно (думал около 5 лет), но мне не понравился ответ "используйте ускорение", следующая функция имеет меньше обобщений (говоря о строковых типах), но, видимо, работает. Однако я не знаю, использую лиstd::ostringstream Это лучше чем std::string::append:

std::string regex_replace(
    const std::string& input,
    const std::regex& regex, 
    std::function<std::string(std::smatch const& match)> format) {

    std::ostringstream output;
    std::sregex_iterator begin(input.begin(), input.end(), regex), end;
    for(; begin != end; begin++){
        output << begin->prefix() << format(*begin);
    }
    output << input.substr(input.size() - begin->position());
    return output.str();
}

Итак, как видите, я использовал std::sregex_iterator вместо того std::sregex_token_iterator.

Источник

Такая функциональность существует только в версии regex_replace библиотеки Boost, которая может иметь пользовательский форматировщик. К сожалению, стандартная реализация C++11 требует, чтобы аргумент формата замены должен быть строкой.

Вот документация по regex_replace: http://www.cplusplus.com/reference/regex/match_replace/

Источник
Другие вопросы по тегам