std::regex equivalent to Qt's QRegularExpression::isValid() without triggering exceptions

Question

I'm trying to migrate some regex tools from Qt to the std. In Qt, I can test if a regex is valid before using it with isValid()

In the std's <regex>, I don't see a way to do this. So for now, I have try/catch blocks that makes the regex with a user-provided regex and then tries to match it against a 1-char string to quickly trigger the std::regex_error exception without loading the actual search string(s) so I can quit out early. This is a dirty hack IMO, but I'm not sure if there's a better way to test them efficiently with std::regex. I'm basically trying to avoid performance hitches from catching and handling exceptions while using automated input with the tool.

try
{
    const std::regex regex_exception_trigger(regex_string);
    std::smatch stability_match;
    const std::string test_string = "0";
    if (std::regex_search(test_string.begin(), test_string.end(), stability_match, regex_exception_trigger)) {}
}
catch (std::regex_error &re) { std::cerr << re.what() << std::endl; print_help(); return exit_enum::BAD_REGEX;  }

Answer 1

C++ libraries (especially the standard library) generally subscribes to the philosophy that if you have an instance of an class, then that instance is valid. So if you try to construct a class with a bad input, it will throw an exception when you construct it, not when you try to use it.

This is generally good, because it makes it clear where you went wrong: if I try to parse a string with a mis-constructed regex and I get an exception, the natural thought is that there is something wrong with the string, not with the regex.

Your use case doesn't fit well with this mold, since the C++ standard library assumes a poorly constructed regex to be exceptional (hence the exception).

Exceptions are cheap when they aren't thrown (i.e. there is little overhead to a try-catch block if you don't need to catch anything), but actually catching an exception can be expensive. If you expect to receive a lot of incorrectly constructed regular expressions and you think catching the exception will noticeable affect performance (despite the cost of catching an exception, you still might be OK, so you should do some tests), you will need to consider a different tool to validate the regular expressions before constructing them.

Boost also provides a regular expression library that the standard library's version is based on. The syntax will be very similar. Boost's version has a no_except flag that can be passed to the regex constructor and will suppress any exceptions from an invalid string. The reason I gave above is presumably why this flag was not included in the standard library version. If you need this behavior, you could consider using the Boost version instead.

Answer 2

If you want to catch all errors, do it all in a try{}catch{}catch{}catch{} sequence.

I'd split up the construction from the usage.

pseudo code

std::regex Rx;
bool bIsConstructError = false;

////////////////////////////////////////
bool SetRx( std::string& strRx )
{
   bIsConstructError = false;
   try 
   {
      Rx.assign( "", 0);
      Rx.assign( strRx, 0 );
   }
   catch ( std::regex_error & e )
   {
      bIsConstructError = true;
      return false;
   }
   catch ( std::out_of_range & e )
   {
      bIsConstructError = true;
      return false;
   }
   catch ( std::runtime_error & e )
   {
      bIsConstructError = true;
      return false;
   }
   return true;
}

////////////////////////////////////////
bool  findText( std::string& strTarget )
{
   if ( bIsConstructError )
      return false;

   bool bRet = true;

   std::smatch _M;
   std::string::const_iterator start = strTarget.begin();
   std::string::const_iterator end = strTarget.end();

   try
   {
      if ( regex_search( start, end, _M, Rx, 0 ) )
      {
          // do something
      }
   }
   catch ( std::out_of_range & e )
   {
      bRet = false;
   }
   catch ( std::runtime_error & e )
   {
      bRet = false;
   }
   return bRet;
}