Varianti

    std::upper_bound

    Da cppreference.com.
    See More

    Questa pagina è stata tradotta in modo automatico dalla versione in ineglese della wiki usando Google Translate.

    La traduzione potrebbe contenere errori e termini strani. Muovi il puntatore sopra al testo per vedere la versione originale. Puoi aiutarci a correggere gli gli errori. Per ulteriori istruzioni clicca qui.

    Click here for the English version of this page

    <metanoindex/>

     
    C++
     
    Algoritmo libreria
    Funzioni
    Original:
    Functions
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Non modifica le operazioni di sequenza
    Original:
    Non-modifying sequence operations
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Modifica delle operazioni di sequenza
    Original:
    Modifying sequence operations
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Partizionamento operazioni
    Original:
    Partitioning operations
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Ordinamento delle operazioni (su intervalli ordinati)
    Original:
    Sorting operations (on sorted ranges)
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Binarie (le operazioni di ricerca sui campi ordinati)
    Original:
    Binary search operations (on sorted ranges)
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Impostare le operazioni (su intervalli ordinati)
    Original:
    Set operations (on sorted ranges)
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Heap operazioni
    Original:
    Heap operations
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Minimo / massimo le operazioni
    Original:
    Minimum/maximum operations
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Operazioni numeriche
    Original:
    Numeric operations
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Libreria C
    Original:
    C library
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
     
    <tbody> </tbody>
    Elemento definito nell'header <algorithm>
    template< class ForwardIt, class T > ForwardIt upper_bound( ForwardIt first, ForwardIt last, const T& value );
    		 (1)
    template< class ForwardIt, class T, class Compare > ForwardIt upper_bound( ForwardIt first, ForwardIt last, const T& value, Compare comp );
    		 (2)
    Restituisce un iteratore che punta al primo elemento della [first, last) gamma che è superiore rispetto value. La prima versione utilizza operator< di confrontare gli elementi, la seconda versione utilizza la funzione di confronto dato comp.
    Original:
    Returns an iterator pointing to the first element in the range [first, last) that is greater than value. The first version uses operator< to compare the elements, the second version uses the given comparison function comp.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    Parametri

    first, last -
    la gamma di elementi da esaminare
    Original:
    the range of elements to examine
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    value -
    valore per confrontare gli elementi
    Original:
    value to compare the elements to
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    comp - comparison function which returns ​true if the first argument is less than the second.

    The signature of the comparison function should be equivalent to the following:

    bool cmp(const Type1 &a, const Type2 &b);

    The signature does not need to have const &, but the function must not modify the objects passed to it.
    The type Type1 must be such that an object of type T can be implicitly converted to Type1. The type Type2 must be such that an object of type ForwardIt can be dereferenced and then implicitly converted to Type2. ​

    Type requirements
    -
    ForwardIt must meet the requirements of ForwardIterator.

    Valore di ritorno

    iteratore che punta al primo elemento che è superiore di value, o last se tale elemento non viene trovato.
    Original:
    iterator pointing to the first element that is greater than value, or last if no such element is found.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    Possibile implementazione

    First version 
    template<class ForwardIt, class T>
ForwardIt upper_bound(ForwardIt first, ForwardIt last,
                            const T& value)
{
    ForwardIt it;
    std::iterator_traits<ForwardIt>::distance_type count, step;
    count = std::distance(first,last);

    while (count > 0) {
        it = first; 
        step = count / 2; 
        std::advance(it, step);
        if (!(value < *it)) {
            first = ++it;
            count -= step + 1;
        } else count = step;
    }
    return first;
}
    Second version 
    template<class ForwardIt, class T, class Compare>
ForwardIt upper_bound(ForwardIt first, ForwardIt last,
                            const T& value, Compare comp)
{
    ForwardIt it;
    std::iterator_traits<ForwardIt>::distance_type count, step;
    count = std::distance(first,last);

    while (count > 0) {
        it = first; 
        step = count / 2;
        std::advance(it, step);
        if (!comp(value, *it)),
            first = ++it;
            count -= step + 1
        } else count = step;
    }
    return first;
}

    Esempio

    #include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>

int main()
{
    std::vector<int> data = { 1, 1, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6 };
    
    auto lower = std::lower_bound(data.begin(), data.end(), 4);
    auto upper = std::upper_bound(data.begin(), data.end(), 4);
    
    std::copy(lower, upper, std::ostream_iterator<int>(std::cout, " "));
}

    Output: 

    4 4 4

    Complessità

    logaritmica della distanza tra first e last
    Original:
    logarithmic in the distance between first and last
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    Vedi anche
    torna gamma di elementi che corrispondono un tasto specifico
    Original:
    returns range of elements matching a specific key
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (funzione di modello) [modifica]
    restituisce un iteratore al primo elemento' non inferiore al valore dato
    Original:
    returns an iterator to the first element not less than the given value
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (funzione di modello) [modifica]