Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::regex_search

      From cppreference.com
      <cpp‎ |regex
       
       
       
      Regular expressions library
      Classes
      (C++11)
      Algorithms
      regex_search
      (C++11)
      Iterators
      Exceptions
      Traits
      Constants
      (C++11)
      Regex Grammar
       
      Defined in header<regex>
      template<class BidirIt,class Alloc,class CharT,class Traits>

      bool regex_search( BidirIt first, BidirIt last,
                         std::match_results<BidirIt, Alloc>& m,
                         conststd::basic_regex<CharT, Traits>& e,
                         std::regex_constants::match_flag_type flags=

                             std::regex_constants::match_default);
      (1)(since C++11)
      template<class BidirIt,class CharT,class Traits>

      bool regex_search( BidirIt first, BidirIt last,
                         conststd::basic_regex<CharT, Traits>& e,
                         std::regex_constants::match_flag_type flags=

                             std::regex_constants::match_default);
      (2)(since C++11)
      template<class CharT,class Alloc,class Traits>

      bool regex_search(const CharT* str,
                         std::match_results<const CharT*, Alloc>& m,
                         conststd::basic_regex<CharT, Traits>& e,
                         std::regex_constants::match_flag_type flags=

                             std::regex_constants::match_default);
      (3)(since C++11)
      template<class CharT,class Traits>

      bool regex_search(const CharT* str,conststd::basic_regex<CharT, Traits>& e,
                         std::regex_constants::match_flag_type flags=

                             std::regex_constants::match_default);
      (4)(since C++11)
      template<class STraits,class SAlloc,class Alloc,

               class CharT,class Traits>
      bool regex_search
         (conststd::basic_string<CharT, STraits, SAlloc>& s,
           std::match_results
               <typenamestd::basic_string<CharT, STraits, SAlloc>::const_iterator,
                 Alloc>& m,
           conststd::basic_regex<CharT, Traits>& e,
           std::regex_constants::match_flag_type flags=

               std::regex_constants::match_default);
      (5)(since C++11)
      template<class STraits,class SAlloc,class CharT,class Traits>

      bool regex_search(conststd::basic_string<CharT, STraits, SAlloc>& s,
                         conststd::basic_regex<CharT, Traits>& e,
                         std::regex_constants::match_flag_type flags=

                             std::regex_constants::match_default);
      (6)(since C++11)
      template<class STraits,class SAlloc,class Alloc,

               class CharT,class Traits>
      bool regex_search
         (conststd::basic_string<CharT, STraits, SAlloc>&&,
           std::match_results
               <typenamestd::basic_string<CharT, STraits, SAlloc>::const_iterator,
                 Alloc>&,
           conststd::basic_regex<CharT, Traits>&,
           std::regex_constants::match_flag_type flags=

               std::regex_constants::match_default)= delete;
      (7)(since C++11)

      Determines if there is a match between the regular expressione and some subsequence in the target character sequence. The detailed match result is stored inm (if present).

      1,2) The target character sequence is represented by the range[firstlast).

      IfBidirIt does not satisfy the requirements ofLegacyBidirectionalIterator, the behavior is undefined.

      (until C++23)

      IfBidirIt does not modelbidirectional_iterator, the behavior is undefined.

      (since C++23)
      3,4) The target character sequence is represented by the range[strstr+std::char_traits<CharT>::length(str)).
      5,6) The target character sequence is represented by the strings.
      7) The target character sequence cannot be represented by astd::string rvalue.

      If a match does not exist, the following expressions involvingm (if exists) should yield the specified values:

       Expression  Value 
      m.ready()true
      m.size()0
      m.empty()true

      If a match exists, given any integer in(0m.size()) asn, the following expressions involvingm should yield the specified values for each overload listed below:

            Expression      Value
                 Overload(1)                      Overload(3)                      Overload(5)           
      m.ready()true
      m.size()1+ e.mark_count()
      m.empty()false
      m.prefix().firstfirststrs.begin()
      m.prefix().secondm[0].first
      m.prefix().matchedm.prefix().first!= m.prefix().second
      m.suffix().firstm[0].second
      m.suffix().secondlaststd::char_traits<CharT>::
          length(str)+ str
      s.end()
      m.suffix().matchedm.suffix().first!= m.suffix().second
      m[0].firstthe start of the sequence that matchede
      m[0].secondthe end of the sequence that matchede
      m[0].matchedtrue
      m[n].first
      • last ifmarked sub-expressionn did not participate in the match
      • the start of the sequence otherwise matching sub-expressionn otherwise
      m[n].second
      • last ifmarked sub-expressionn did not participate in the match
      • the end of the sequence otherwise matching sub-expressionn otherwise
      m[n].matched

      Contents

      [edit]Parameters

      first, last - the target character range
      str - the target null-terminated C-style string
      s - the targetstd::basic_string
      m - the match results
      e - the regular expression
      flags - flags used to determine how the match will be performed

      [edit]Return value

      Returnstrue if a match exists,false otherwise.

      [edit]Notes

      In order to examine all matches within the target sequence,std::regex_search may be called in a loop, restarting each time fromm[0].second of the previous call.std::regex_iterator offers an easy interface to this iteration.

      [edit]Example

      Run this code
      #include <cstddef>#include <iostream>#include <regex>#include <string> int main(){std::string lines[]={"Roses are #ff0000","violets are #0000ff","all of my base are belong to you"}; std::regex color_regex("#([a-f0-9]{2})""([a-f0-9]{2})""([a-f0-9]{2})"); // simple matchfor(constauto& line: lines)std::cout<< line<<": "<<std::boolalpha<< std::regex_search(line, color_regex)<<'\n';std::cout<<'\n'; // show contents of marked subexpressions within each matchstd::smatch color_match;for(constauto& line: lines)if(std::regex_search(line, color_match, color_regex)){std::cout<<"matches for '"<< line<<"'\n";std::cout<<"Prefix: '"<< color_match.prefix()<<"'\n";for(std::size_t i=0; i< color_match.size();++i)std::cout<< i<<": "<< color_match[i]<<'\n';std::cout<<"Suffix: '"<< color_match.suffix()<<"\'\n\n";} // repeated search (see also std::regex_iterator)std::string log(R"(        Speed:366        Mass:35        Speed:378        Mass:32        Speed:400Mass:30)");std::regex r(R"(Speed:\t\d*)");for(std::smatch sm; regex_search(log, sm, r);){std::cout<< sm.str()<<'\n';        log= sm.suffix();} // C-style string demostd::cmatch cm;if(std::regex_search("this is a test", cm,std::regex("test")))std::cout<<"\nFound "<< cm[0]<<" at position "<< cm.prefix().length()<<'\n';}

      Output:

      Roses are #ff0000: trueviolets are #0000ff: trueall of my base are belong to you: false matches for 'Roses are #ff0000'Prefix: 'Roses are '0: #ff00001: ff2: 003: 00Suffix: '' matches for 'violets are #0000ff'Prefix: 'violets are '0: #0000ff1: 002: 003: ffSuffix: '' Speed:366Speed:378Speed:400 Found test at position 10

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DRApplied toBehavior as publishedCorrect behavior
      LWG 2205C++11n could be zero in the postconditioncan only be positive
      LWG 2329C++11overload(5) acceptedbasic_string rvalues,
      which could result in dangling iterators
      rejected via deleted overload(7)

      [edit]See also

      regular expression object
      (class template)[edit]
      identifies one regular expression match, including all sub-expression matches
      (class template)[edit]
      attempts to match a regular expression to an entire character sequence
      (function template)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/regex/regex_search&oldid=177667"

      [8]ページ先頭

      ©2009-2025 Movatter.jp