Operadores <regex>
operator!=
operator>
operator>=
operator<
operator<<
operator<=
operator==
operator!=
Comparação de diferença para vários objetos.
template <class BidIt>
bool operator!=(const sub_match<BidIt>& left,
const sub_match<BidIt>& right);
template <class BidIt, class IOtraits, class Alloc>
bool operator!=(
const basic_string<typename iterator_traits<BidIt>::value_type, IOtraits, Alloc>& left,
const sub_match<BidIt>& right);
template <class BidIt, class IOtraits, class Alloc>
bool operator!=(const sub_match<BidIt>& left,
const basic_string<typename iterator_traits<BidIt>::value_type, IOtraits, Alloc>& right);
template <class BidIt>
bool operator!=(const typename iterator_traits<BidIt>::value_type *left,
const sub_match<BidIt>& right);
template <class BidIt>
bool operator!=(const sub_match<BidIt>& left,
const typename iterator_traits<BidIt>::value_type *right);
template <class BidIt>
bool operator!=(const typename iterator_traits<BidIt>::value_type& left,
const sub_match<BidIt>& right);
template <class BidIt>
bool operator!=(const sub_match<BidIt>& left,
const typename iterator_traits<BidIt>::value_type& right);
template <class BidIt, class Alloc>
bool operator!=(const match_results<BidIt, Alloc>& left,
const match_results<BidIt, Alloc>& right);
Parâmetros
BidIt
O tipo de iterador.
IOtraits
A classe de característica da cadeia de caracteres.
Alloc
A classe do alocador.
esquerda
O objeto à esquerda a ser comparado.
direita
O objeto à direita a ser comparado.
Comentários
Cada operador de modelo retorna !(left == right).
Exemplo
// std__regex__operator_ne.cpp
// compile with: /EHsc
#include <regex>
#include <iostream>
typedef std::cmatch::string_type Mystr;
int main()
{
std::regex rx("c(a*)|(b)");
std::cmatch mr;
std::regex_search("xcaaay", mr, rx);
std::csub_match sub = mr[1];
std::cout << "match == " << mr.str() << std::endl;
std::cout << "sub == " << sub << std::endl;
std::cout << std::endl;
std::cout << "match != match == " << std::boolalpha
<< (mr != mr) << std::endl;
std::cout << "sub != sub == " << std::boolalpha
<< (sub != sub) << std::endl;
std::cout << "string(\"aab\") != sub == " << std::boolalpha
<< (Mystr("aab") != sub) << std::endl;
std::cout << "sub != string(\"aab\") == " << std::boolalpha
<< (sub != Mystr("aab")) << std::endl;
std::cout << "\"aab\" != sub == " << std::boolalpha
<< ("aab" != sub) << std::endl;
std::cout << "sub != \"aab\" == " << std::boolalpha
<< (sub != "aab") << std::endl;
std::cout << "'a' != sub == " << std::boolalpha
<< ('a' != sub) << std::endl;
std::cout << "sub != 'a' == " << std::boolalpha
<< (sub != 'a') << std::endl;
return (0);
}
match == caaa
sub == aaa
match != match == false
sub != sub == false
string("aab") != sub == true
sub != string("aab") == true
"aab" != sub == true
sub != "aab" == true
'a' != sub == true
sub != 'a' == true
operator<
Comparação de menor que para vários objetos.
template <class BidIt>
bool operator<(const sub_match<BidIt>& left,
const sub_match<BidIt>& right);
template <class BidIt, class IOtraits, class Alloc>
bool operator<(
const basic_string<typename iterator_traits<BidIt>::value_type, IOtraits, Alloc>& left,
const sub_match<BidIt>& right);
template <class BidIt, class IOtraits, class Alloc>
bool operator<(const sub_match<BidIt>& left,
const basic_string<typename iterator_traits<BidIt>::value_type, IOtraits, Alloc>& right);
template <class BidIt>
bool operator<(const typename iterator_traits<BidIt>::value_type *left,
const sub_match<BidIt>& right);
template <class BidIt>
bool operator<(const sub_match<BidIt>& left,
const typename iterator_traits<BidIt>::value_type *right);
template <class BidIt>
bool operator<(const typename iterator_traits<BidIt>::value_type& left,
const sub_match<BidIt>& right);
template <class BidIt>
bool operator<(const sub_match<BidIt>& left,
const typename iterator_traits<BidIt>::value_type& right);
Parâmetros
BidIt
O tipo de iterador.
IOtraits
A classe de característica da cadeia de caracteres.
Alloc
A classe do alocador.
esquerda
O objeto à esquerda a ser comparado.
direita
O objeto à direita a ser comparado.
Comentários
Cada operador de modelo converte seu argumento em um tipo de cadeia de caracteres e retorna true somente se o valor convertido de left for menor em comparação ao valor convertido de right.
Exemplo
// std__regex__operator_lt.cpp
// compile with: /EHsc
#include <regex>
#include <iostream>
typedef std::cmatch::string_type Mystr;
int main()
{
std::regex rx("c(a*)|(b)");
std::cmatch mr;
std::regex_search("xcaaay", mr, rx);
std::csub_match sub = mr[1];
std::cout << "sub == " << sub << std::endl;
std::cout << std::endl;
std::cout << "sub < sub == " << std::boolalpha
<< (sub < sub) << std::endl;
std::cout << "string(\"aab\") < sub == " << std::boolalpha
<< (Mystr("aab") < sub) << std::endl;
std::cout << "sub < string(\"aab\") == " << std::boolalpha
<< (sub < Mystr("aab")) << std::endl;
std::cout << "\"aab\" < sub == " << std::boolalpha
<< ("aab" < sub) << std::endl;
std::cout << "sub < \"aab\" == " << std::boolalpha
<< (sub < "aab") << std::endl;
std::cout << "'a' < sub == " << std::boolalpha
<< ('a' < sub) << std::endl;
std::cout << "sub < 'a' == " << std::boolalpha
<< (sub < 'a') << std::endl;
return (0);
}
sub == aaa
sub < sub == false
string("aab") < sub == false
sub < string("aab") == true
"aab" < sub == false
sub < "aab" == true
'a' < sub == true
sub < 'a' == false
operator<<
Insere um sub_match em um fluxo.
template <class Elem, class IOtraits, class Alloc, class BidIt>
basic_ostream<Elem, IOtraits>& operator<<(basic_ostream<Elem, IOtraits>& os,
const sub_match<BidIt>& right);
Parâmetros
Elem
O tipo de elemento.
IOtraits
A classe de característica da cadeia de caracteres.
Alloc
A classe do alocador.
BidIt
O tipo de iterador.
os
O fluxo de saída.
direita
O objeto a ser inserido.
Comentários
O operador de modelo retorna os << right.str().
Exemplo
// std__regex__operator_ins.cpp
// compile with: /EHsc
#include <regex>
#include <iostream>
int main()
{
std::regex rx("c(a*)|(b)");
std::cmatch mr;
std::regex_search("xcaaay", mr, rx);
std::csub_match sub = mr[0];
std::cout << "whole match: " << sub << std::endl;
return (0);
}
whole match: caaa
operator<=
Comparação de menor ou igual para vários objetos.
template <class BidIt>
bool operator<=(const sub_match<BidIt>& left,
const sub_match<BidIt>& right);
template <class BidIt, class IOtraits, class Alloc>
bool operator<=(
const basic_string<typename iterator_traits<BidIt>::value_type, IOtraits, Alloc>& left,
const sub_match<BidIt>& right);
template <class BidIt, class IOtraits, class Alloc>
bool operator<=(const sub_match<BidIt>& left,
const basic_string<typename iterator_traits<BidIt>::value_type, IOtraits, Alloc>& right);
template <class BidIt>
bool operator<=(const typename iterator_traits<BidIt>::value_type *left,
const sub_match<BidIt>& right);
template <class BidIt>
bool operator<=(const sub_match<BidIt>& left,
const typename iterator_traits<BidIt>::value_type *right);
template <class BidIt>
bool operator<=(const typename iterator_traits<BidIt>::value_type& left,
const sub_match<BidIt>& right);
template <class BidIt>
bool operator<=(const sub_match<BidIt>& left,
const typename iterator_traits<BidIt>::value_type& right);
Parâmetros
BidIt
O tipo de iterador.
IOtraits
A classe de característica da cadeia de caracteres.
Alloc
A classe do alocador.
esquerda
O objeto à esquerda a ser comparado.
direita
O objeto à direita a ser comparado.
Comentários
Cada operador de modelo retorna !(right < left).
Exemplo
// std__regex__operator_le.cpp
// compile with: /EHsc
#include <regex>
#include <iostream>
typedef std::cmatch::string_type Mystr;
int main()
{
std::regex rx("c(a*)|(b)");
std::cmatch mr;
std::regex_search("xcaaay", mr, rx);
std::csub_match sub = mr[1];
std::cout << "sub == " << sub << std::endl;
std::cout << std::endl;
std::cout << "sub <= sub == " << std::boolalpha
<< (sub <= sub) << std::endl;
std::cout << "string(\"aab\") <= sub == " << std::boolalpha
<< (Mystr("aab") <= sub) << std::endl;
std::cout << "sub <= string(\"aab\") == " << std::boolalpha
<< (sub <= Mystr("aab")) << std::endl;
std::cout << "\"aab\" <= sub == " << std::boolalpha
<< ("aab" <= sub) << std::endl;
std::cout << "sub <= \"aab\" == " << std::boolalpha
<< (sub <= "aab") << std::endl;
std::cout << "'a' <= sub == " << std::boolalpha
<< ('a' <= sub) << std::endl;
std::cout << "sub <= 'a' == " << std::boolalpha
<< (sub <= 'a') << std::endl;
return (0);
}
sub == aaa
sub <= sub == true
string("aab") <= sub == false
sub <= string("aab") == true
"aab" <= sub == false
sub <= "aab" == true
'a' <= sub == true
sub <= 'a' == false
operator==
Comparação de igualdade para vários objetos.
template <class BidIt>
bool operator==(const sub_match<BidIt>& left,
const sub_match<BidIt>& right);
template <class BidIt, class IOtraits, class Alloc>
bool operator==(
const basic_string<typename iterator_traits<BidIt>::value_type, IOtraits, Alloc>& left,
const sub_match<BidIt>& right);
template <class BidIt, class IOtraits, class Alloc>
bool operator==(const sub_match<BidIt>& left,
const basic_string<typename iterator_traits<BidIt>::value_type, IOtraits, Alloc>& right);
template <class BidIt>
bool operator==(const typename iterator_traits<BidIt>::value_type* left,
const sub_match<BidIt>& right);
template <class BidIt>
bool operator==(const sub_match<BidIt>& left,
const typename iterator_traits<BidIt>::value_type* right);
template <class BidIt>
bool operator==(const typename iterator_traits<BidIt>::value_type& left,
const sub_match<BidIt>& right);
template <class BidIt>
bool operator==(const sub_match<BidIt>& left,
const typename iterator_traits<BidIt>::value_type& right);
template <class BidIt, class Alloc>
bool operator==(const match_results<BidIt, Alloc>& left,
const match_results<BidIt, Alloc>& right);
Parâmetros
BidIt
O tipo de iterador.
IOtraits
A classe de característica da cadeia de caracteres.
Alloc
A classe do alocador.
esquerda
O objeto à esquerda a ser comparado.
direita
O objeto à direita a ser comparado.
Comentários
Cada operador de modelo converte cada um de seus argumentos em um tipo de cadeia de caracteres e retorna o resultado da comparação da igualdade dos objetos convertidos.
Quando um operador de modelo converte seus argumentos em um tipo de cadeia de caracteres, ele usa a primeira das seguintes transformações aplicáveis:
argumentos cujos tipos são uma especialização do modelo de classe match_results ou sub_match são convertidos chamando a função membro str;
argumentos cujos tipos são uma especialização do modelo de classe basic_string permanecem inalterados;
todos os outros tipos de argumento são convertidos passando o valor do argumento para o construtor para uma especialização apropriada do modelo de classe basic_string.
Exemplo
// std__regex__operator_eq.cpp
// compile with: /EHsc
#include <regex>
#include <iostream>
typedef std::cmatch::string_type Mystr;
int main()
{
std::regex rx("c(a*)|(b)");
std::cmatch mr;
std::regex_search("xcaaay", mr, rx);
std::csub_match sub = mr[1];
std::cout << "match == " << mr.str() << std::endl;
std::cout << "sub == " << sub << std::endl;
std::cout << std::endl;
std::cout << "match == match == " << std::boolalpha
<< (mr == mr) << std::endl;
std::cout << "sub == sub == " << std::boolalpha
<< (sub == sub) << std::endl;
std::cout << "string(\"aab\") == sub == " << std::boolalpha
<< (Mystr("aab") == sub) << std::endl;
std::cout << "sub == string(\"aab\") == " << std::boolalpha
<< (sub == Mystr("aab")) << std::endl;
std::cout << "\"aab\" == sub == " << std::boolalpha
<< ("aab" == sub) << std::endl;
std::cout << "sub == \"aab\" == " << std::boolalpha
<< (sub == "aab") << std::endl;
std::cout << "'a' == sub == " << std::boolalpha
<< ('a' == sub) << std::endl;
std::cout << "sub == 'a' == " << std::boolalpha
<< (sub == 'a') << std::endl;
return (0);
}
match == caaa
sub == aaa
match == match == true
sub == sub == true
string("aab") == sub == false
sub == string("aab") == false
"aab" == sub == false
sub == "aab" == false
'a' == sub == false
sub == 'a' == false
operator>
Comparação de maior que para vários objetos.
template <class BidIt>
bool operator>(const sub_match<BidIt>& left,
const sub_match<BidIt>& right);
template <class BidIt, class IOtraits, class Alloc>
bool operator>(
const basic_string<typename iterator_traits<BidIt>::value_type, IOtraits, Alloc>& left,
const sub_match<BidIt>& right);
template <class BidIt, class IOtraits, class Alloc>
bool operator>(const sub_match<BidIt>& left,
const basic_string<typename iterator_traits<BidIt>::value_type, IOtraits, Alloc>& right);
template <class BidIt>
bool operator>(const typename iterator_traits<BidIt>::value_type *left,
const sub_match<BidIt>& right);
template <class BidIt>
bool operator>(const sub_match<BidIt>& left,
const typename iterator_traits<BidIt>::value_type *right);
template <class BidIt>
bool operator>(const typename iterator_traits<BidIt>::value_type& left,
const sub_match<BidIt>& right);
template <class BidIt>
bool operator>(const sub_match<BidIt>& left,
const typename iterator_traits<BidIt>::value_type& right);
Parâmetros
BidIt
O tipo de iterador.
IOtraits
A classe de característica da cadeia de caracteres.
Alloc
A classe do alocador.
esquerda
O objeto à esquerda a ser comparado.
direita
O objeto à direita a ser comparado.
Comentários
Cada operador de modelo retorna right < left.
Exemplo
// std__regex__operator_gt.cpp
// compile with: /EHsc
#include <regex>
#include <iostream>
typedef std::cmatch::string_type Mystr;
int main()
{
std::regex rx("c(a*)|(b)");
std::cmatch mr;
std::regex_search("xcaaay", mr, rx);
std::csub_match sub = mr[1];
std::cout << "sub == " << sub << std::endl;
std::cout << std::endl;
std::cout << "sub > sub == " << std::boolalpha
<< (sub > sub) << std::endl;
std::cout << "string(\"aab\") > sub == " << std::boolalpha
<< (Mystr("aab") > sub) << std::endl;
std::cout << "sub > string(\"aab\") == " << std::boolalpha
<< (sub > Mystr("aab")) << std::endl;
std::cout << "\"aab\" > sub == " << std::boolalpha
<< ("aab" > sub) << std::endl;
std::cout << "sub > \"aab\" == " << std::boolalpha
<< (sub > "aab") << std::endl;
std::cout << "'a' > sub == " << std::boolalpha
<< ('a' > sub) << std::endl;
std::cout << "sub > 'a' == " << std::boolalpha
<< (sub > 'a') << std::endl;
return (0);
}
sub == aaa
sub > sub == false
string("aab") > sub == true
sub > string("aab") == false
"aab" > sub == true
sub > "aab" == false
'a' > sub == false
sub > 'a' == true
operator>=
Comparação de maior ou igual para vários objetos.
template <class BidIt>
bool operator>=(const sub_match<BidIt>& left,
const sub_match<BidIt>& right);
template <class BidIt, class IOtraits, class Alloc>
bool operator>=(
const basic_string<typename iterator_traits<BidIt>::value_type, IOtraits, Alloc>& left,
const sub_match<BidIt>& right);
template <class BidIt, class IOtraits, class Alloc>
bool operator>=(const sub_match<BidIt>& left,
const basic_string<typename iterator_traits<BidIt>::value_type, IOtraits, Alloc>& right);
template <class BidIt>
bool operator>=(const typename iterator_traits<BidIt>::value_type *left,
const sub_match<BidIt>& right);
template <class BidIt>
bool operator>=(const sub_match<BidIt>& left,
const typename iterator_traits<BidIt>::value_type *right);
template <class BidIt>
bool operator>=(const typename iterator_traits<BidIt>::value_type& left,
const sub_match<BidIt>& right);
template <class BidIt>
bool operator>=(const sub_match<BidIt>& left,
const typename iterator_traits<BidIt>::value_type& right);
Parâmetros
BidIt
O tipo de iterador.
IOtraits
A classe de característica da cadeia de caracteres.
Alloc
A classe do alocador.
esquerda
O objeto à esquerda a ser comparado.
direita
O objeto à direita a ser comparado.
Comentários
Cada operador de modelo retorna !(left < right).
Exemplo
// std__regex__operator_ge.cpp
// compile with: /EHsc
#include <regex>
#include <iostream>
typedef std::cmatch::string_type Mystr;
int main()
{
std::regex rx("c(a*)|(b)");
std::cmatch mr;
std::regex_search("xcaaay", mr, rx);
std::csub_match sub = mr[1];
std::cout << "sub == " << sub << std::endl;
std::cout << std::endl;
std::cout << "sub >= sub == " << std::boolalpha
<< (sub >= sub) << std::endl;
std::cout << "string(\"aab\") >= sub == " << std::boolalpha
<< (Mystr("aab") >= sub) << std::endl;
std::cout << "sub >= string(\"aab\") == " << std::boolalpha
<< (sub >= Mystr("aab")) << std::endl;
std::cout << "\"aab\" >= sub == " << std::boolalpha
<< ("aab" >= sub) << std::endl;
std::cout << "sub >= \"aab\" == " << std::boolalpha
<< (sub >= "aab") << std::endl;
std::cout << "'a' >= sub == " << std::boolalpha
<< ('a' >= sub) << std::endl;
std::cout << "sub >= 'a' == " << std::boolalpha
<< (sub >= 'a') << std::endl;
return (0);
}
sub == aaa
sub >= sub == true
string("aab") >= sub == true
sub >= string("aab") == false
"aab" >= sub == true
sub >= "aab" == false
'a' >= sub == false
sub >= 'a' == true
Confira também
<regex>
Classe regex_constants
Classe regex_error
Funções <regex>
Classe regex_iterator
Classe regex_token_iterator
Classe regex_traits
<regex> typedefs
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de