Является gcc 4.8 или более ранней ошибкой регулярных выражений?

Я пытаюсь использовать std:: regex в коде С++ 11, но оказывается, что поддержка немного глючит. Пример:

#include <regex>
#include <iostream>

int main (int argc, const char * argv[]) {
    std::regex r("st|mt|tr");
    std::cerr << "st|mt|tr" << " matches st? " << std::regex_match("st", r) << std::endl;
    std::cerr << "st|mt|tr" << " matches mt? " << std::regex_match("mt", r) << std::endl;
    std::cerr << "st|mt|tr" << " matches tr? " << std::regex_match("tr", r) << std::endl;
}

выходы:

st|mt|tr matches st? 1
st|mt|tr matches mt? 1
st|mt|tr matches tr? 0

при компиляции с gcc (MacPorts gcc47 4.7.1_2) 4.7.1 либо с

g++ *.cc -o test -std=c++11
g++ *.cc -o test -std=c++0x

или

g++ *.cc -o test -std=gnu++0x

Кроме того, регулярное выражение работает хорошо, если у меня есть только два альтернативных шаблона, например. st|mt, поэтому похоже, что последнее не соответствует по некоторым причинам. Код хорошо работает с компилятором Apple LLVM.

Любые идеи о том, как решить проблему?

Обновить одно из возможных решений - использовать группы для реализации множества альтернатив, например. (st|mt)|tr.

ОТВЕТЫ

Ответ 1

<regex> был реализован и выпущен в GCC 4.9.0.

В вашей (более старой) версии GCC это не реализовано.

Этот прототип <regex> был добавлен, когда вся поддержка GCC С++ 0x была высоко экспериментальной, отслеживая ранние С++ 0x черновики и предоставляемые для людей, с которыми можно экспериментировать. Это позволяло людям находить проблемы и давать обратную связь стандартным комитетом до того, как стандарт был доработан. В то время многие люди были благодарны за то, что у него был доступ к деталям с эффектом кровотечения задолго до того, как С++ 11 был закончен и до того, как многие другие компиляторы предоставили какую-либо поддержку, и эта обратная связь действительно помогла улучшить С++ 11. Это была хорошая вещь TM.

Код <regex> никогда не был в полезном состоянии, но был добавлен как работа в процессе, как и многие другие биты кода в то время. Он был проверен и предоставлен для других, чтобы сотрудничать, если они захотят, с намерением, что он будет закончен в конце концов.

Часто, как работает open source: Релиз рано, выпуск часто - к сожалению, в случае <regex> мы получили только раннюю часть право, а не часто часть, которая завершила бы реализацию.

Большинство частей библиотеки были более полными и теперь почти полностью реализованы, но <regex> не было, поэтому он остался в том же незавершенном состоянии, поскольку он был добавлен.

Серьезно, однако, кто, хотя, что доставка реализации regex_search, которая только делает "return false", была хорошей идеей?

Это была не такая плохая идея несколько лет назад, когда С++ 0x все еще продолжал работу, и мы отправили множество частичных реализаций. Никто не думал, что он останется непригодным для использования так долго, поэтому, оглядываясь назад, возможно, он должен был быть отключен, и для его включения требуется макрос или встроенная опция. Но этот корабль давно отплыл. Есть экспортированные символы из libstdС++, поэтому библиотека, зависящая от кода регулярного выражения, поэтому простое удаление (в, скажем, GCC 4.8) не было бы тривиальным.

Ответ 2

Обнаружение функций

Это фрагмент, чтобы определить, реализована ли реализация libstdc++ с препроцессором C:

#include <regex>
#if __cplusplus >= 201103L &&                             \
    (!defined(__GLIBCXX__) || (__cplusplus >= 201402L) || \
        (defined(_GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT) || \
         defined(_GLIBCXX_REGEX_STATE_LIMIT)           || \
             (defined(_GLIBCXX_RELEASE)                && \
             _GLIBCXX_RELEASE > 4)))
#define HAVE_WORKING_REGEX 1
#else
#define HAVE_WORKING_REGEX 0
#endif

Макросы

  • _GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT определен в bits/regex.tcc в 4.9.x
  • _GLIBCXX_REGEX_STATE_LIMIT определяется в bits/regex_automatron.h в 5+
  • _GLIBCXX_RELEASE был добавлен в 7+ в результате этот ответ и является основной версией GCC

Тестирование

Вы можете протестировать его с помощью GCC следующим образом:

cat << EOF | g++ --std=c++11 -x c++ - && ./a.out
#include <regex>

#if __cplusplus >= 201103L &&                             \
    (!defined(__GLIBCXX__) || (__cplusplus >= 201402L) || \
        (defined(_GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT) || \
         defined(_GLIBCXX_REGEX_STATE_LIMIT)           || \
             (defined(_GLIBCXX_RELEASE)                && \
             _GLIBCXX_RELEASE > 4)))
#define HAVE_WORKING_REGEX 1
#else
#define HAVE_WORKING_REGEX 0
#endif

#include <iostream>

int main() {
  const std::regex regex(".*");
  const std::string string = "This should match!";
  const auto result = std::regex_search(string, regex);
#if HAVE_WORKING_REGEX
  std::cerr << "<regex> works, look: " << std::boolalpha << result << std::endl;
#else
  std::cerr << "<regex> doesn't work, look: " << std::boolalpha << result << std::endl;
#endif
  return result ? EXIT_SUCCESS : EXIT_FAILURE;
}
EOF

Результаты

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

$ gcc --version
gcc (GCC) 4.8.5 20150623 (Red Hat 4.8.5-11)
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

$ ./a.out
<regex> doesn't work, look: false

$ gcc --version
gcc (GCC) 6.2.1 20160830
Copyright (C) 2016 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

$ ./a.out
<regex> works, look: true

$ gcc --version
gcc (Debian 4.9.2-10) 4.9.2
Copyright (C) 2014 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

$ ./a.out
<regex> works, look: true

$ gcc --version
gcc (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005
Copyright (C) 2016 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

$ ./a.out
<regex> works, look: true

$ gcc --version
gcc (Ubuntu 5.4.0-6ubuntu1~16.04.4) 5.4.0 20160609
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

$ ./a.out
<regex> works, look: true

$ gcc --version
gcc (GCC) 6.2.1 20160830
Copyright (C) 2016 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

$ clang --version
clang version 3.9.0 (tags/RELEASE_390/final)
Target: x86_64-unknown-linux-gnu
Thread model: posix
InstalledDir: /usr/bin
$ ./a.out  # compiled with 'clang -lstdc++'
<regex> works, look: true

Здесь будут Dragons

Это полностью неподдерживается и зависит от обнаружения частных макросов, которые разработчики GCC помещают в заголовки bits/regex*. Они могут меняться и уходить в любое время. Надеюсь, они не будут удалены в текущих версиях 4.9.x, 5.x, 6.x, но они могут исчезнуть в релизах 7.x.

Если разработчики GCC добавили #define _GLIBCXX_HAVE_WORKING_REGEX 1 (или что-то, hint hint nudge nudge) в релиз 7.x, который сохранился, этот фрагмент можно было бы обновить, включив его, а последующие выпуски GCC будут работать с вышеприведенным фрагментом.

Насколько я знаю, все остальные компиляторы имеют рабочий <regex>, когда __cplusplus >= 201103L, но YMMV.

Очевидно, это полностью нарушится, если кто-то определит макросы _GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT или _GLIBCXX_REGEX_STATE_LIMIT вне заголовков stdc++-v3.

Ответ 3

В этот момент (с использованием std = С++ 14 в g++ (GCC) 4.9.2) все еще не принимается regex_match.

Вот подход, который работает как regex_match, но вместо этого использует sregex_token_iterator. И он работает с g++.

string line="1a2b3c";
std::regex re("(\\d)");
std::vector<std::string> inVector{
    std::sregex_token_iterator(line.begin(), line.end(), re, 1), {}
};

//prints all matches
for(int i=0; i<inVector.size(); ++i)
    std::cout << i << ":" << inVector[i] << endl;

он напечатает 1 2 3

вы можете прочитать ссылку sregex_token_iterator в: http://en.cppreference.com/w/cpp/regex/regex_token_iterator