operator< <regex>

Less than comparison for various objects.

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);

Parameters

  • BidIt
    The iterator type.

  • IOtraits
    The string traits class.

  • Alloc
    The allocator class.

  • left
    The left object to compare.

  • right
    The right object to compare.

Remarks

Each template operator converts its arguments to a string type and returns true only if the converted value of left compares less than the converted value of right.

Example

 

// std_tr1__regex__operator_lt.cpp 
// compile with: /EHsc 
#include <regex> 
#include <iostream> 
 
typedef std::tr1::cmatch::string_type Mystr; 
int main() 
    { 
    std::tr1::regex rx("c(a*)|(b)"); 
    std::tr1::cmatch mr; 
 
    std::tr1::regex_search("xcaaay", mr, rx); 
 
    std::tr1::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

Requirements

Header: <regex>

Namespace: std::tr1

See Also

Reference

<regex>

operator== <regex>

operator!= <regex>

operator<= <regex>

operator> <regex>

operator>= <regex>