Как я могу использовать регулярное выражение на обратной стороне строки?

Я хочу использовать regex на реверсе string.

Я могу сделать следующее, но все мои sub_matches перевернуты:

string foo("lorem ipsum");
match_results<string::reverse_iterator> sm;

if (regex_match(foo.rbegin(), foo.rend(), sm, regex("(\\w+)\\s+(\\w+)"))) {
    cout << sm[1] << ' ' << sm[2] << endl;
}
else {
    cout << "bad\n";
}

[Живой пример]

Я хочу выбраться:

ipsum lorem

Есть ли какое-либо положение для получения необратимых субматч? То есть любое положение, кроме отмены strings после того, как они совпадают следующим образом:

string first(sm[1]);
string second(sm[2]);

reverse(first.begin(), first.end());
reverse(second.begin(), second.end());

cout << first << ' ' << second << endl;

РЕДАКТИРОВАТЬ:

Это было предложено обновить вопрос, чтобы уточнить, чего я хочу:

Выполнение regex в обратном направлении на string не связано с изменением порядка, в котором находятся совпадения. regex - гораздо более сложный вариант, который было бы полезно опубликовать здесь, но его выполнение в обратном направлении избавляет меня от необходимости смотреть вперед. Этот вопрос об обработке подсовпадений, полученных из match_results<string::reverse_iterator>. Мне нужно получить их в том виде, в котором они были на входе, здесь foo. Я не хочу создавать временный string и запускать на нем reverse для каждого под-соответствия. Как мне этого избежать?


c++ string regex reverse reverse-iterator
person Jonathan Mee    schedule 04.08.2015    source источник
comment
Итак, вы хотите найти совпадение, затем поменять порядок слов в совпадающих фрагментах, а затем записать его в cout / где угодно?   -  person Michael McPherson    schedule 04.08.2015
comment
@MichaelMcPherson Ну, я хочу запустить regex на обратной стороне строки, да. Но я не хочу, чтобы мои совпадения были отменены ... если это возможно.   -  person Jonathan Mee    schedule 04.08.2015
comment
Итак, вы хотите запустить регулярное выражение для строки, в которой был перевернут символ для символа, а затем вывести обычные (необратимые) слова?   -  person Michael McPherson    schedule 04.08.2015
comment
@MichaelMcPherson Правильно, как я уже упоминал, здесь мы говорим о regex, который значительно сложнее, чем этот пример, но его можно упростить, работая в обратном порядке. Однако создание string и их реверсирование для каждого под-соответствия кажется ненужным бременем.   -  person Jonathan Mee    schedule 04.08.2015
comment
Какая ожидаемая нагрузка? Выполнение индивидуального реверсирования определенно является проблемой, но если ваш набор задач достаточно мал, он все равно может быть наиболее эффективным с точки зрения времени (вашего времени).   -  person Michael McPherson    schedule 04.08.2015
comment
@MichaelMcPherson Я не уверен, что вы имеете в виду под нагрузкой? Вы правы, что это, вероятно, не имеет большого значения. Я просто хотел сделать это лучше, если возможно.   -  person Jonathan Mee    schedule 04.08.2015
comment
Под нагрузкой я имел в виду, как часто это действие должно происходить на итерации программы. Если вы делаете это дважды, возможно, вам подойдет метод строкового и обратного преобразования. Если вы делаете это полмиллиона раз, то да, нужна какая-то оптимизация.   -  person Michael McPherson    schedule 04.08.2015
comment
В любом случае, это кажется связанной проблемой. Если бы было больше информации о регулярном выражении или целевой строке, возможно, люди могли бы дать вам лучший ответ. Но для данных, представленных здесь (строка была перевернута. У меня есть n совпадений в перевернутой форме. Как мне отменить их переворот?) Я думаю, что реверсирование - единственный реальный ответ.   -  person Michael McPherson    schedule 04.08.2015
comment
Если вы используете обратные итераторы для входной строки, вы получите обратные совпадения строк. На мой взгляд, у вас есть два варианта. а) поменять местами спички. б) используйте обратные итераторы из совпадений во всем, что вы хотите с ними делать.   -  person Galik    schedule 04.08.2015

Ответы (2)


arrow_upward
5
arrow_downward

Вы можете просто изменить порядок использования результатов:

#include <regex>
#include <string>
#include <iostream>

using namespace std;

int main()
{
    string foo("lorem ipsum");
    smatch sm;

    if (regex_match(foo, sm, regex("(\\w+)\\s+(\\w+)"))) {
        cout << sm[2] << ' ' << sm[1] << endl; // use second as first
    }
    else {
        cout << "bad\n";
    }
}

Вывод:

ipsum lorem
person Galik    schedule 04.08.2015
comment
Это не дает того, что я хочу. Регулярное выражение значительно сложнее, чем то, которое я разместил здесь в примере. На самом деле нет способа выполнить это регулярное выражение без поддержки упреждающего выражения в библиотеке регулярных выражений. Я могу обойти некоторые сложности, выполняя итерацию в обратном порядке, но я не хочу, чтобы затем создавали strings и reverse их для каждого под-совпадения. - person Jonathan Mee; 04.08.2015
comment
@JonathanMee Ну, может, вы могли бы попробовать опубликовать фактическое регулярное выражение? Или, по крайней мере, что-то такое же неразрешимое, как и ваша проблема? - person Galik; 04.08.2015

arrow_upward
0
arrow_downward

Это абсолютно возможно! Ключ в том, что a sub_match наследуется от _2 _ . Поскольку sub_matches будет получено из: match_results<string::reverse_iterator> sm, элементы pair a sub_match, наследуемые от, будут string::reverse_iterators.

Таким образом, для любого заданного sub_match из sm вы можете получить диапазон вперед от second.base() до first.base(). Вам не нужно создавать strings для диапазонов потоков, но вам нужно будет создать _13 _ :

ostream_iterator<char> output(cout);

copy(sm[1].second.base(), sm[1].first.base(), output);
output = ' ';
copy(sm[2].second.base(), sm[2].first.base(), output);

Мужайтесь, на горизонте есть лучшее решение! В этом ответе обсуждаются string_literals по состоянию на прямо сейчас к ним не было предпринято никаких действий, но они попали в« Подгруппу эволюции ».

person Jonathan Mee    schedule 05.08.2015