Utilizzo e esempio di upper_bound() di C++ set

Set (insieme) STL C++

C ++ set upper_bound()La funzione restituisce un iteratore che punta al valore nel contenitore set, maggiore del valore passato come parametro.

sintassi

　　　　　　iterator upper_bound(const value_type& val) const; // Prima di C++ 11
　　　　　　iterator upper_bound(const value_type& val); // Dopo C++ 11
const_iterator upper_bound(const value_type& val) const; // Dopo C++ 11

parametro

valValore da cercare nel contenitore di set.

Restituzione del valore

Restituisce un iteratore che puntà alla valore nel contenitore set, che è maggiore del valore passato come parametro. Se non esiste tale elemento, restituisce end().

Complessa

La dimensione è logaritmica.

Validità degli iteratori

Nessuna modifica.

Conflitto di dati

Il contenitore viene acceduto (versioni const e non const non possono modificare il contenitore).

L'accesso simultaneo agli elementi della集合 è sicuro.

Eccezioni

Se si verifica un'eccezione, il contenitore non subisce modifiche.

Esempio 1

Vediamo un esempio semplice per ottenere l'upper bound di un valore dato:

Esempio

#include <iostream>
#include <set>
using namespace std;
int main(void) {
　　　set<char> m = {'a', 'b', 'c', 'd'};
　　　　　　　　　　　
　　　auto it = m.upper_bound('b');
　　　cout << "L'upper bound di b è (>): " << *it << endl;
　　　return 0;
}

Output:

L'upper bound di b è (>): c

Nell'esempio precedente, quando cerchiamo di trovare l'upper bound dell'elemento b, restituirà il valore maggiore di b, ossia c

Esempio 2

Vediamo un esempio semplice, eliminare gli elementi di un set dal limite inferiore al limite superiore:

Esempio

#include <iostream>
#include <set>
using namespace std;
int main()
{
　　set<int> myset;
　　set<int>::iterator itlow,itup;
　　for (int i=1; i<10; i++) myset.insert(i*10); // 10 20 30 40 50 60 70 80 90
　　itlow=myset.lower_bound(30); // ^
　　itup=myset.upper_bound(60); // ^
　　myset.erase(itlow,itup); // 10 20 70 80 90
　　std::cout << "myset contiene:";
　　for (set<int>::iterator it=myset.begin(); it!=myset.end(); ++it)
　　　　cout << ' ' << *it;
　　cout << '\n';
　　return 0;
}

Output:

myset contiene: 10 20 70 80 90

Nell'esempio precedente, la funzione erase() rimuove gli elementi dal limite inferiore (=) al limite superiore (>), e stampa il contenuto rimanente.

Esempio 3

Guardiamo un esempio semplice:

Esempio

#include<iostream>
#include<set>
using namespace std;
　
int main()
{
　　　　//Inizializza il contenitore
　　　　set<int> mp;
　
　　　　//Inserisci elementi in ordine casuale
　　　　mp.insert( 12 );
　　　　mp.insert( 11 );
　　　　mp.insert( 15 );
　　　　mp.insert( 14 );
　
　　　　//Quando 11 esiste
　　　　auto it = mp.upper_bound(11);
　　　　cout << "Il limite superiore della chiave 11 è ";
　　　　cout << (*it) << endl;
　
　　　　//Quando 13 non esiste
　　　　it = mp.upper_bound(13);
　　　　cout << "Il limite superiore della chiave 13 è ";
　　　　cout << (*it) << endl;
　
　　　　//Quando 17 è maggiore del valore massimo della chiave, per dimensione
　　　　//Il valore di ritorno di mp è la chiave, il valore è 0.
　　　　it = mp.upper_bound(17);
　　　　cout << "Il limite superiore della chiave 17 è ";
　　　　cout << (*it);
　　　　return 0;
}

Output:

Il limite superiore della chiave 11 è 12
Il limite superiore della chiave 13 è 14
Il limite superiore della chiave 17 è 4

Nel esempio sopra, quando cerchiamo di trovare il valore superiore al massimo della collezione container che non esiste, restituisce un valore maggiore, quindi quando cerchiamo il limite superiore di 13, restituisce 14, e quando cerchiamo il limite superiore di un valore che non esiste nella collezione e supera il valore massimo del container, restituisce end().

Esempio 4

Guardiamo un esempio semplice:

Esempio

#include <set>　　
#include <iostream>　　
　　
int main( )　　
{　　
　　　using namespace std;　　　　　
　　　set<int> s1;　　
　　　set<int> :: const_iterator s1_AcIter, s1_RcIter;　　
　　
　　　s1.insert( 10 );　　
　　　s1.insert( 20 );　　
　　　s1.insert( 30 );　　
　　
　　　s1_RcIter = s1.upper_bound( 20 );　　
　　　cout << "Il primo elemento della chiave della collezione s1 maggiore di 20 è: " << *s1_RcIter << "." << endl;　　
　　
　　　s1_RcIter = s1.upper_bound( 30 );　　
　　
　　　//Se non trovi una chiave corrispondente, restituisci end()　　
　　　if ( s1_RcIter == s1.end( ) )　　
　　　　　　cout << "La collezione s1 non ha chiavi superiori all'elemento 30." << endl;　　
　　　else　　
　　　　　　cout << "chiave> 40 degli elementi della collezione s1 sono: "　　
　　　　　　　　　　　<< *s1_RcIter << "." << endl;　　
　　
　　　　//Puoi trovare l'elemento specifico nella posizione della collezione
　　　　//Ricerca della posizione utilizzando l'iteratore de-referenziato
　　　s1_AcIter = s1.begin();　　
　　　s1_RcIter = s1.upper_bound(*s1_AcIter);　　
　　　cout << "La chiave del primo elemento di s1 è maggiore di"　　
　　　　　　　　<< endl << "L'elemento iniziale di s1 è: "　　
　　　　　　　　<< *s1_RcIter << "." << endl;　　
　　　　　　　　
　　　　　　　　return 0;
}

Output:

Il primo elemento con chiave maggiore di 20 dell'insieme s1 è: 30.
L'insieme s1 non ha chiavi valori maggiori dell'elemento 30.
La chiave del primo elemento di s1 è maggiore di
L'elemento iniziale di s1 è: 20.

Set (insieme) STL C++