lower_bound

Článek
03/26/2013

Vyhledá první prvek pozice v objednané rozsah, který má hodnotu větší než nebo rovna zadané hodnotě, kde lze zadat kritéria řazení binárního predikátu.

template<class ForwardIterator, class Type>
   ForwardIterator lower_bound(
      ForwardIterator _First, 
      ForwardIterator _Last,
      const Type& _Val
   );
template<class ForwardIterator, class Type, class BinaryPredicate>
   ForwardIterator lower_bound(
      ForwardIterator _First, 
      ForwardIterator _Last,
      const Type& _Val,
      BinaryPredicate _Comp
   );

Parametry

_First
Předávání iterační adresování pozici první prvek v rozsahu mají být prohledány.
_Last
Dopředu iterační adresování pozice jeden za poslední prvek v rozsahu mají být prohledány.
_Val
Hodnota, jehož první pozici nebo první poloze je vyhledáván v rozsahu objednané.
_Comp
Uživatelem definované funkce predikátu objektu, který definuje smysl, ve kterém jeden prvek je menší než jiné.Binárního predikátu trvá dva argumenty a vrátí true -li splněna a false Pokud nejsou splněny.

Vrácená hodnota

Iterační vpřed na pozici prvního prvku objednané oblasti s hodnotou, která je větší nebo rovna zadané hodnotě kde rovnocennost zadané pomocí binárního predikátu.

Poznámky

Seřazené zdrojové oblasti odkazuje, musí být platné; u iterátorů všechny musí být dereferenceable a v rámci sekvence musí být dostupná z první poslední pozice ve incrementation.

Seřazené oblasti je podmínkou pro použití lower_bound a pořadí je stejné jako určený pomocí binárního predikátu.

Rozsah není modifikován algoritmus lower_bound.

Nižší hodnoty typů dopředu u iterátorů třeba-než srovnatelné objednáno, tak, aby dané dva prvky, ji může stanovit nebo že jsou rovnocenné (v tom smyslu, že ani menší než ostatní), jeden je menší než ostatní.Výsledkem je pořadí mezi prvky nonequivalent

Složitost algoritmu je pro náhodný přístup u iterátorů logaritmické a jinak s počet kroků úměrné lineární (_Last1 – _First1).

Příklad

// alg_lower_bound.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>      // For greater<int>( )
#include <iostream>

// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser ( int elem1, int elem2 )
{
   if ( elem1 < 0 )
      elem1 = - elem1;
   if ( elem2 < 0 )
      elem2 = - elem2;
   return elem1 < elem2;
}

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter1, Result1;

   // Constructing vectors v1a & v1b with default less than ordering
   int i;
   for ( i = -1 ; i <= 4 ; i++ )
   {
      v1.push_back(  i );
   }

   int ii;
   for ( ii =-3 ; ii <= 0 ; ii++ )
   {
      v1.push_back(  ii  );
   }

   sort ( v1.begin ( ) , v1.end ( ) );
   cout << "Original vector v1 with range sorted by the\n "
        << "binary predicate less than is  v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")." << endl;

   // Constructing vectors v2 with range sorted by greater
   vector <int> v2 ( v1 );
   vector <int>::iterator Iter2, Result2;
   sort ( v2.begin ( ) , v2.end ( ) , greater<int> ( ) );

   cout << "Original vector v2 with range sorted by the\n "
        << "binary predicate greater is    v2 = ( " ;
   for ( Iter2 = v2.begin ( ) ; Iter2 != v2.end ( ) ; Iter2++ )
      cout << *Iter2 << " ";
   cout << ")." << endl;

   // Constructing vectors v3 with range sorted by mod_lesser
   vector <int> v3 ( v1 );
   vector <int>::iterator Iter3, Result3;
   sort ( v3.begin ( ) , v3.end ( ) , mod_lesser );

   cout << "Original vector v3 with range sorted by the\n "
        <<  "binary predicate mod_lesser is v3 = ( " ;
   for ( Iter3 = v3.begin ( ) ; Iter3 != v3.end ( ) ; Iter3++ )
      cout << *Iter3 << " ";
   cout << ")." << endl;

   // lower_bound of 3 in v1 with default binary predicate less <int> ( )
   Result1 = lower_bound ( v1.begin ( ) , v1.end ( ) , 3 );
   cout << "The lower_bound in v2 for the element with a value of 3 is: "
        << *Result1 << "." << endl;

   // lower_bound of 3 in v2 with the binary predicate greater <int> ( )
   Result2 = lower_bound ( v2.begin ( ) , v2.end ( ) , 3, greater <int> ( ) );
   cout << "The lower_bound in v2 for the element with a value of 3 is: "
        << *Result2 << "." << endl;

   // lower_bound of 3 in v3 with the binary predicate  mod_lesser
   Result3 = lower_bound ( v3.begin ( ) , v3.end ( ) , 3,  mod_lesser  );
   cout << "The lower_bound in v3 for the element with a value of 3 is: "
        << *Result3 << "." << endl;
}

Požadavky

Záhlaví: <algorithm>

Obor názvů: std

Viz také

Referenční dokumentace

lower_bound (STL Samples)

Predicate Version of lower_bound

Standardní šablona knihovny

Sdílet prostřednictvím