std::regex_iterator::regex_iterator(3)

NAME
std::regex_iterator::regex_iterator - std::regex_iterator::regex_iterator

Synopsis
   regex_iterator(); (1) (since C++11)
   regex_iterator( BidirIt a, BidirIt b,
                   const regex_type& re, (2) (since C++11)
                   std::regex_constants::match_flag_type m =
                       std::regex_constants::match_default );
   regex_iterator( const regex_iterator& ); (3) (since C++11)
   regex_iterator( BidirIt, BidirIt,
                   const regex_type&&,
                   std::regex_constants::match_flag_type = (4) (since C++11)
                       std::regex_constants::match_default ) =
   delete;
   Constructs a new regex_iterator:
   1) Default constructor. Constructs an end-of-sequence iterator.
   2) Constructs a regex_iterator from the sequence of characters [a, b), the regular
   expression re, and a flag m that governs matching behavior. This constructor
   performs an initial call to std::regex_search with this data. If the result of this
   initial call is false, *this is set to an end-of-sequence iterator.
   3) Copies a regex_iterator.
   4) The overload (2) is not allowed to be called with a temporary regex, since the
   returned iterator would be immediately invalidated.

Parameters
   a - LegacyBidirectionalIterator to the beginning of the target character sequence
   b - LegacyBidirectionalIterator to the end of the target character sequence
   re - regular expression used to search the target character sequence
   m - flags that govern the behavior of re

Example
// Run this code
 #include <iostream>
 #include <regex>
 #include <string_view>
 int main()
 {
     constexpr std::string_view str{R"(
         #ONE: *p = &Mass;
         #Two: MOV %rd, 42
     )"};
     const std::regex re("[a-w]");
     // create regex_iterator, overload (2)
     auto it = std::regex_iterator<std::string_view::iterator>
     {
         str.cbegin(), str.cend(),
         re // re is lvalue; if an immediate expression was used
            // instead, e.g. std::regex{"[a-z]"}, this would
            // produce an error since overload (4) is deleted
     };
     for (decltype(it) last /* overload (1) */; it != last; ++it)
         std::cout << (*it).str();
     std::cout << '\n';
 }

Output:
 password
   Defect reports
   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.
      DR Applied to Behavior as published Correct behavior
                       a regex_iterator constructed
   LWG 2332 C++11 from a temporary such construction is disallowed via
                       basic_regex became invalid a deleted overload
                       immediately