Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      std::experimental::ranges::less

      From cppreference.com
      <cpp‎ |experimental‎ |ranges
       
       
       
       
      General utilities library
      Utility components
      Function objects
      Metaprogramming and type traits
      Tagged pairs and tuples
                                
      tag specifiers
                                            
                                
       
      template<class T=void>

          requires StrictTotallyOrdered<T>||
                   Same<T,void>||
                   /* < on two const T lvalues invokes a built-in operator comparing pointers */

      struct less;
      		(ranges TS)
      template<>
      struct less<void>;
      		(ranges TS)

      Function object for performing comparisons. The primary template invokesoperator< on const lvalues of typeT. The specializationless<void> deduces the parameter types of the function call operator from the arguments (but not the return type).

      All specializations ofless areSemiregular.

      Contents

      [edit]Member types

      Member type Definition
      is_transparent(member only ofless<void> specialization) /* unspecified */

      [edit]Member functions

      operator()
      		 checks if the first argument isless than the second
      (public member function)

      std::experimental::ranges::less::operator()

      constexprbool operator()(const T& x,const T& y)const;
      		 (1)(member only of primaryless<T> template)
      template<class T,class U>

          requires StrictTotallyOrderedWith<T, U>||
                   /* std::declval<T>() < std::declval<U>() resolves to
                      a built-in operator comparing pointers */

      constexprbool operator()(T&& t, U&& u)const;
      		 (2)(member only ofless<void> specialization)
      1) Comparesx andy. Equivalent toreturnranges::less<>{}(x, y);.
      2) Comparest andu. Equivalent toreturnstd::forward<T>(t)<std::forward<U>(u);, except when that expression resolves to a call to a builtinoperator< comparing pointers.

      When a call to(1) or(2) would invoke a built-in operator comparing pointers of typeP, the result is instead determined as follows:

      • Returnstrue if the (possibly converted) value of the first argument precedes the (possibly converted) value of the second argument in the implementation-defined strict total ordering over all pointer values of typeP. This strict total ordering is consistent with the partial order imposed by the builtin operators<,>,<=, and>=.
      • Otherwise, returnsfalse.

      The behavior is undefined unless the conversion sequences from bothT andU toP are equality-preserving (see below).

      [edit] Equality preservation

      An expression isequality preserving if it results in equal outputs given equal inputs.

      • The inputs to an expression consist of its operands.
      • The outputs of an expression consist of its result and all operands modified by the expression (if any).

      Every expression required to be equality preserving is further required to bestable: two evaluations of such an expression with the same input objects must have equal outputs absent any explicit intervening modification of those input objects.

      [edit]Notes

      Unlikestd::less,ranges::less requires all six comparison operators<,<=,>,>=,== and!= to be valid (via theStrictTotallyOrdered andStrictTotallyOrderedWith constraints).

      [edit]Example

      This section is incomplete
      Reason: no example

      [edit]See also

      function object implementingx< y
      (class template)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/experimental/ranges/functional/less&oldid=155352"
      [8]ページ先頭
      ©2009-2026 Movatter.jp