less (struct)

Predicado binario que realiza la operación menor que (operator<) sobre sus argumentos.

Sintaxis

template <class Type = void>
struct less : public binary_function <Type, Type, bool>
{
    bool operator()(const Type& Left, const Type& Right) const;
};

// specialized transparent functor for operator<
template <>
struct less<void>
{
    template <class T, class U>
    auto operator()(T&& Left, U&& Right) const
        -> decltype(std::forward<T>(Left) <std::forward<U>(Right));
};

Parámetros

Type, T, U
Cualquier tipo que admite un operator< que toma operandos de los tipos especificados o deducidos.

Izquierdo
Operando izquierdo de la operación menor que. La plantilla no especializada toma un argumento de referencia de valor L de tipo Type. La plantilla especializada realiza el reenvío directo de los argumentos de referencia de valor L y valor R del tipo deducido T.

Right
Operando derecho de la operación menor que. La plantilla no especializada toma un argumento de referencia de valor L de tipo Type. La plantilla especializada realiza el reenvío directo de los argumentos de referencia de valor L y valor R del tipo deducido U.

Valor devuelto

Resultado de Left < Right. La plantilla especializada realiza el reenvío directo del resultado, que tiene el tipo devuelto por operator<.

Comentarios

El predicado binario less<Type> proporciona una ordenación débil estricta de un conjunto de valores de elementos de tipo Type en clases de equivalencia, si y solo si este tipo satisface los requisitos matemáticos estándar para que se pueda ordenar de esa forma. Las especializaciones para cualquier tipo de puntero producen una ordenación total de los elementos, en la que todos los elementos de valores distintos están ordenados unos con respecto a otros.

Ejemplo

// functional_less.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>

struct MyStruct {
   MyStruct(int i) : m_i(i){}

   bool operator < (const MyStruct & rhs) const {
      return m_i < rhs.m_i;
   }

   int m_i;
};

int main() {
   using namespace std;
   vector <MyStruct> v1;
   vector <MyStruct>::iterator Iter1;
   vector <MyStruct>::reverse_iterator rIter1;

   int i;
   for ( i = 0 ; i < 7 ; i++ )
       v1.push_back( MyStruct(rand()));

   cout << "Original vector v1 = ( " ;
   for ( Iter1 = v1.begin() ; Iter1 != v1.end() ; Iter1++ )
cout << Iter1->m_i << " ";
   cout << ")" << endl;

   // To sort in ascending order,
   sort( v1.begin( ), v1.end( ), less<MyStruct>());

   cout << "Sorted vector v1 = ( " ;
   for ( Iter1 = v1.begin() ; Iter1 != v1.end() ; Iter1++ )
cout << Iter1->m_i << " ";
   cout << ")" << endl;
}

Original vector v1 = (41 18467 6334 26500 19169 15724 11478)
Sorted vector v1 = (41 6334 11478 15724 18467 19169 26500)