Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/regex/regex match"

From cppreference.com
< cpp‎ | regex
m (Text replace - "{{cpp|" to "{{c|")
(added see also, example)
Line 61: Line 61:
 
2) Behaves as (1) above, omitting the match results.
 
2) Behaves as (1) above, omitting the match results.
  
3) Returns std::regex_match(str, str + std::char_traits<charT>::length(str), m, e, flags).
+
3) Returns {{c|std::regex_match(str, str + std::char_traits<charT>::length(str), m, e, flags)}}.
  
4) Returns std::regex_match(s.begin(), s.end(), m, e, flags).
+
4) Returns {{c|std::regex_match(s.begin(), s.end(), m, e, flags)}}.
  
5) Returns std::regex_match(str, str + std::char_traits<charT>::length(str), e, flags).
+
5) Returns {{c|std::regex_match(str, str + std::char_traits<charT>::length(str), e, flags)}}.
  
6) Returns std::regex_match(s.begin(), s.end(), e, flags).
+
6) Returns {{c|std::regex_match(s.begin(), s.end(), e, flags)}}.
  
 
===Parameters===
 
===Parameters===
 
{{param list begin}}
 
{{param list begin}}
{{param list item | first, last | the target character range}}
+
{{param list item | first, last | the target character range to apply the regex to, given as iterators}}
 
{{param list item | m | the match results}}
 
{{param list item | m | the match results}}
{{param list item | str | a target character null-terminated C-style string}}
+
{{param list item | str | a target string, given as a null-terminated C-style string}}
{{param list item | s | a target character std::basic_string}}
+
{{param list item | s | a target string, given as a {{c|std::basic_string}} }}
 
{{param list item | e | the std::regex}}
 
{{param list item | e | the std::regex}}
{{param list item | flags | the match flags}}
+
{{param list item | flags | flags used to determine how the match will be performed}}
 
{{param list end}}
 
{{param list end}}
  
 
===Return value===
 
===Return value===
 
Returns {{c|true}} if a match exists, {{c|false}} otherwise.
 
Returns {{c|true}} if a match exists, {{c|false}} otherwise.
 +
 +
===Example===
 +
{{example
 +
| code=
 +
#include <iostream>
 +
#include <string>
 +
#include <regex>
 +
 +
int main()
 +
{
 +
    std::string fnames[] = {"foo.txt", "bar.txt", "zoidberg"};
 +
 +
    std::regex txt_regex("[a-z]+\\.txt");
 +
    for (const auto &fname : fnames) {
 +
        std::cout << fname << ": " << std::regex_match("foo.txt", txt_regex) << '\n';
 +
    }
 +
}
 +
| output=
 +
foo.txt: 1
 +
bar.txt: 1
 +
zoidberg: 0
 +
}}
 +
 +
===See also===
 +
{{dcl list begin}}
 +
{{dcl list template | cpp/regex/dcl list basic_regex}}
 +
{{dcl list template | cpp/regex/dcl list match_results}}
 +
{{dcl list end}}

Revision as of 09:21, 8 May 2012

Template:cpp/regex/sidebar Template:ddcl list begin <tr class="t-dsc-header">

<td>
Defined in header <regex>
</td>

<td></td> <td></td> </tr> <tr class="t-dcl ">

<td >
template< class BidirectionalIterator,

          class Alloc, class CharT, class Traits >
bool regex_match( BidirectionalIterator first, BidirectionalIterator last,
                  std::match_results<BidirectionalIterator,Alloc>& m,
                  const std::basic_regex<CharT,Traits>& e,
                  std::regex_constants::match_flag_type flags =

                      std::regex_constants::match_default );
</td>

<td > (1) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
template< class BidirectionalIterator,

          class CharT, class Traits >
bool regex_match( BidirectionalIterator first, BidirectionalIterator last,
                  const std::basic_regex<CharT,Traits>& e,
                  std::regex_constants::match_flag_type flags =

                      std::regex_constants::match_default );
</td>

<td > (2) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
template< class CharT, class Alloc, class Traits >

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

                      std::regex_constants::match_default );
</td>

<td > (3) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
template< class STraits, class SAlloc,

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

                      std::regex_constants::match_default );
</td>

<td > (4) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
template< class CharT, class Traits >

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

                      std::regex_constants::match_default );
</td>

<td > (5) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
template< class STraits, class SAlloc,

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

                      std::regex_constants::match_default );
</td>

<td > (6) </td> <td > (since C++11) </td> </tr> Template:ddcl list end

1) Determines if there is a match between the regular express e and the target character sequence [first,last). Match results are returned in m.

2) Behaves as (1) above, omitting the match results.

3) Returns std::regex_match(str, str + std::char_traits<charT>::length(str), m, e, flags).

4) Returns std::regex_match(s.begin(), s.end(), m, e, flags).

5) Returns std::regex_match(str, str + std::char_traits<charT>::length(str), e, flags).

6) Returns std::regex_match(s.begin(), s.end(), e, flags).

Contents

Parameters

first, last - the target character range to apply the regex to, given as iterators
m - the match results
str - a target string, given as a null-terminated C-style string
s - a target string, given as a std::basic_string
e - the std::regex
flags - flags used to determine how the match will be performed

Return value

Returns true if a match exists, false otherwise.

Example

#include <iostream>
#include <string>
#include <regex>
 
int main()
{
    std::string fnames[] = {"foo.txt", "bar.txt", "zoidberg"};
 
    std::regex txt_regex("[a-z]+\\.txt");
    for (const auto &fname : fnames) {
        std::cout << fname << ": " << std::regex_match("foo.txt", txt_regex) << '\n';
    }
}

Output:

foo.txt: 1
bar.txt: 1
zoidberg: 0

See also

Template:cpp/regex/dcl list basic regexTemplate:cpp/regex/dcl list match results