Skip to content

Latest commit

 

History

History
211 lines (180 loc) · 14.5 KB

regex_search.md

File metadata and controls

211 lines (180 loc) · 14.5 KB

regex_search

  • regex[meta header]
  • std[meta namespace]
  • function template[meta id-type]
  • cpp11[meta cpp]
namespace std {
  template <class BidirectionalIterator, class Allocator, class charT, class traits>
  bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
                    match_results<BidirectionalIterator, Allocator>& m,
                    const basic_regex<charT, traits>& e,
                    regex_constants::match_flag_type flags = regex_constants::match_default);          // (1)

  template <class charT, class Allocator, class traits>
  bool regex_search(const charT* str,
                    match_results<const charT*, Allocator>& m,
                    const basic_regex<charT, traits>& e,
                    regex_constants::match_flag_type flags = regex_constants::match_default);          // (2)

  template <class ST, class SA, class Allocator, class charT, class traits>
  bool regex_search(const basic_string<charT, ST, SA>& s,
                    match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
                    const basic_regex<charT, traits>& e,
                    regex_constants::match_flag_type flags = regex_constants::match_default);          // (3)

  template <class ST, class SA, class Allocator, class charT, class traits>
  bool regex_search(basic_string<charT, ST, SA>&& s,
                    match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
                    const basic_regex<charT, traits>& e,
                    regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // (4) C++14 から

  template <class BidirectionalIterator, class charT, class traits>
  bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
                    const basic_regex<charT, traits>& e,
                    regex_constants::match_flag_type flags = regex_constants::match_default);          // (5)

  template <class charT, class traits>
  bool regex_search(const charT* str,
                    const basic_regex<charT, traits>& e,
                    regex_constants::match_flag_type flags = regex_constants::match_default);          // (6)

  template <class ST, class SA, class charT, class traits>
  bool regex_search(const basic_string<charT, ST, SA>& s,
                    const basic_regex<charT, traits>& e,
                    regex_constants::match_flag_type flags = regex_constants::match_default);          // (7)
}
  • match_results[link match_results.md]
  • basic_regex[link basic_regex.md]
  • regex_constants::match_flag_type[link regex_constants/match_flag_type.md]
  • regex_constants::match_default[link regex_constants/match_flag_type.md]
  • basic_string[link ../string/basic_string.md]

概要

指定された文字列中に、正規表現がマッチする部分が存在するか否かの判定を行う。
引数に match_results がある場合、当該オブジェクトにマッチの結果を格納する。
なお、同様の関数である regex_match と異なり、正規表現が文字列全体にマッチする必要はない。

要件

BidirectionalIterator は双方向イテレータの要件を満たすこと。

効果

  • (1) [first, last) で指定された文字列中に、e で指定された正規表現にマッチする部分が存在するか否かの判定を行う。
    flags は正規表現が文字列に対してどのようにマッチするかを指定する。
  • (2) return regex_search(str, str + char_traits::length(str), m, e, flags) と等価。
  • (3) return regex_search(s.begin(), s.end(), m, e, flags) と等価。
  • (4) deleted 宣言されているため、使用するとコンパイルエラーとなる。
  • (5) match_results<BidirectionalIterator> 型のダミーオブジェクト what を構築し、return regex_search(first, last, what, e, flags) としたものと等価。
  • (6) return regex_search(str, str + char_traits::length(str), e, flags) と等価。
  • (7) return regex_search(s.begin(), s.end(), e, flags) と等価。

事後条件

  • (1) 常に m.ready() == true となる。
    もし、戻り値が false の場合、m の ready() 以外の状態については、m.size() == 0 および m.empty() == true となる事以外は未規定である。
    もし、戻り値が true の場合、m の ready() 以外の状態は以下の表を満たす。

    要素 値
    m.size() 1 + e.mark_count()
    m.empty() false
    m.prefix().first first
    m.prefix().second m[0].first
    m.prefix().matched m.prefix().first != m.prefix().second
    m.suffix().first m[0].second
    m.suffix().second last
    m.suffix().matched m.suffix().first != m.suffix().second
    m.[0].first 正規表現がマッチした文字列の最初の文字を指すイテレータ
    m.[0].second 正規表現がマッチした文字列の最後の文字の次を指すイテレータ
    m.[0].matched true
    m.[n].first 0 < n < m.size() となるすべての整数 n について、正規表現内の n 番目のキャプチャグループがマッチした文字列の最初の文字を指すイテレータ。
    もし、n 番目のキャプチャグループがマッチに参加していない場合には、last。
    m.[n].second 0 < n < m.size() となるすべての整数 n について、正規表現内の n 番目のキャプチャグループがマッチした文字列の最後の文字の次を指すイテレータ。
    もし、n 番目のキャプチャグループがマッチに参加していない場合には、last。
    m.[n].matched 0 < n < m.size() となるすべての整数 n について、正規表現内の n 番目のキャプチャグループがマッチに参加していれば true。
    もし、n 番目のキャプチャグループがマッチに参加していない場合には、false。

戻り値

指定した文字列中に、正規表現にマッチする部分が存在した場合、true。存在しなかった場合は false。

例外

本関数は regex_error を送出する可能性がある。
もしそのような例外 e が送出された場合、 e.code() は regex_constants::error_complexity か regex_constants::error_stack のいずれかである。

備考

match_results オブジェクトを引数に取る形式の場合、そのオブジェクトは引数で指定した検索対象文字列へのイテレータを保持する。
このため、検索対象文字列は本関数を呼び出した後も match_results オブジェクトを使用し終わるまで破棄されないようにする必要がある。
従って、(3) の形式に渡す引数 s に一時オブジェクトを指定することはほぼ間違いなくプログラミング上のエラーを意味する。
(4) の形式が deleted として C++14 で追加された理由は、このような事態をコンパイル時に検出するためである。

例

#include <iostream>
#include <iterator>
#include <list>
#include <regex>
#include <string>

int main()
{
  std::cout << std::boolalpha;
  {
    // (1) の形式
    const std::list<char> s = { 'a', 'b', 'c', '1', '2', '3', 'd', 'e', 'f' };
    std::match_results<std::list<char>::const_iterator> m;
    std::cout << "(1) " << std::regex_search(std::begin(s), std::end(s), m, std::regex("\\d+")) << std::endl;
    std::cout << "str = '" << m.str() << "', position = " << m.position() << std::endl;
  }
  {
    // (2) の形式
    std::cmatch m;
    std::cout << "(2) " << std::regex_search("abc123def", m, std::regex("\\d+")) << std::endl;
    std::cout << "str = '" << m.str() << "', position = " << m.position() << std::endl;
  }
  {
    // (3) の形式
    const std::string s = "abc123def";
    std::smatch m;
    std::cout << "(3) " << std::regex_search(s, m, std::regex("\\d+")) << std::endl;
    std::cout << "str = '" << m.str() << "', position = " << m.position() << std::endl;
  }
  {
    // (4) の形式（コメントアウトを外すと C++14 ではエラーになる）
    //std::smatch m;
    //std::cout << "(4) " << std::regex_search(std::string("abc123def"), m, std::regex("\\d+")) << std::endl;
    //std::cout << "str = '" << m.str() << "', position = " << m.position() << std::endl;
  }
  {
    // (5) の形式
    const std::list<char> s = { 'a', 'b', 'c', '1', '2', '3', 'd', 'e', 'f' };
    std::cout << "(5) " << std::regex_search(std::begin(s), std::end(s), std::regex("\\d+")) << std::endl;
  }
  {
    // (6) の形式
    std::cout << "(6) " << std::regex_search("abc123def", std::regex("\\d+")) << std::endl;
  }
  {
    // (7) の形式、その１
    const std::string s = "abc123def";
    std::cout << "(7)-1 " << std::regex_search(s, std::regex("\\d+")) << std::endl;
  }
  {
    // (7) の形式、その２（C++14 でもエラーにならない）
    std::cout << "(7)-2 " << std::regex_search(std::string("abc123def"), std::regex("\\d+")) << std::endl;
  }
}
  • std::regex_search[color ff0000]
  • std::regex[link basic_regex.md]
  • std::match_results[link match_results.md]
  • std::cmatch[link match_results.md]
  • std::smatch[link match_results.md]
  • m.str()[link match_results/str.md]
  • m.position()[link match_results/position.md]

出力

(1) = true
str = '123', position = 3
(2) true
str = '123', position = 3
(3) true
str = '123', position = 3
(5) true
(6) true
(7)-1 true
(7)-2 true

バージョン

言語

  • C++11

処理系

  • Clang: 3.0 [mark verified], 3.1 [mark verified], 3.2 [mark verified], 3.3 [mark verified], 3.4 [mark verified], 3.5 [mark verified], 3.6 [mark verified]
  • GCC: 4.9.0 [mark verified], 4.9.1 [mark verified], 4.9.2 [mark verified], 5.0.0 [mark verified]
  • ICC: ??
  • Visual C++: ??

備考

Clang(libc++) では、3.4 までは (4) の形式は存在しない。
GCC(libstdc++) では、4.9.2 までは (4) の形式は存在しない。

参照