Classe `set`

Articolo
10/12/2023

La classe set contenitore libreria standard C++ viene usata per archiviare e recuperare dati da una raccolta. I valori degli elementi in set sono univoci e fungono da valori chiave in base ai quali i dati vengono ordinati automaticamente. Il valore di un elemento in un set oggetto potrebbe non essere modificato direttamente. È invece necessario eliminare i valori precedenti e inserire gli elementi che presentano nuovi valori.

Sintassi

template <class Key,
    class Traits=less<Key>,
    class Allocator=allocator<Key>>
class set

Parametri

Key
Tipo di dati degli elementi da archiviare nel set.

Traits
Tipo che fornisce un oggetto funzione in grado di confrontare i valori di due elementi come chiavi di ordinamento per determinarne l'ordine relativo nel set. Questo argomento è facoltativo e il predicato less <Key> binario è il valore predefinito.

In C++14 è possibile abilitare la ricerca eterogenea specificando il std::less<> predicato o std::greater<> senza parametri di tipo. Per altre informazioni, vedere Ricerca eterogenea nei contenitori associativi .

Allocator
Tipo che rappresenta l'oggetto allocatore archiviato che incapsula i dettagli relativi all'allocazione del set e alla deallocazione della memoria. Questo argomento è facoltativo e il valore predefinito è allocator<Key>.

Osservazioni:

La classe set della libreria standard C++ è:

Un contenitore associativo, che è un contenitore di dimensioni variabili che supporta il recupero efficiente dei valori degli elementi in base al valore di una chiave associata. Si tratta anche di un contenitore associativo semplice perché i relativi valori di elemento sono i valori chiave.
Reversibile, in quanto fornisce un iteratore bidirezionale per accedere ai relativi elementi.
Ordinato, poiché i relativi elementi sono ordinati in base ai valori delle chiavi all'interno del contenitore conformemente a una funzione di confronto specificata.
Univoco nel senso che ogni elemento deve disporre di una chiave univoca. Poiché il set è anche un contenitore associativo semplice, anche i relativi elementi sono univoci.

Un set viene descritto anche come modello di classe perché la funzionalità fornita è generica e indipendente dal tipo specifico di dati contenuti come elementi. I tipi di dati da utilizzare sono invece specificati come parametro nel modello di classe insieme alla funzione di confronto e all'allocatore.

La scelta del tipo di contenitore deve essere basata in genere sul tipo di ricerca e di inserimento richiesti dall'applicazione. I contenitori associativi sono ottimizzati per le operazioni di ricerca, inserimento e rimozione. Le funzioni membro che supportano in modo esplicito queste operazioni sono efficienti, eseguendole in un periodo medio proporzionale al logaritmo del numero di elementi nel contenitore. L'inserimento di elementi non invalida alcun iteratore e la rimozione di elementi invalida solo gli iteratori che puntano agli elementi rimossi.

Il set deve essere il contenitore associativo da preferire quando le condizioni che consentono di associare i valori alle relative chiavi vengono soddisfatte dall'applicazione. Gli elementi di un set sono univoci e vengono utilizzati come chiavi di ordinamento degli stessi. Un modello relativo a questo tipo di struttura è ad esempio un elenco ordinato di parole in cui ogni parola deve essere presente una sola volta. Se sono state consentite più occorrenze delle parole, la struttura di contenitore appropriata è il multiset. Se i valori devono essere associati a un elenco di parole chiave univoche, una mappa rappresenta la struttura appropriata per contenere questi dati. Se invece le chiavi non sono univoce, un multimap sarà il contenitore preferito.

Il set ordina la sequenza che controlla chiamando un oggetto funzione archiviato di tipo key_compare. Questo oggetto archiviato è una funzione di confronto accessibile chiamando la funzione key_compmembro . In generale, gli elementi devono essere semplicemente meno che confrontabili per stabilire questo ordine in modo che, dato qualsiasi due elementi, possa essere determinato che sono equivalenti (nel senso che nessuno è minore dell'altro) o che uno è minore dell'altro. Di conseguenza, l'ordinamento viene eseguito tra gli elementi non equivalenti. A un livello più tecnico, la funzione di confronto è un predicato binario che provoca un ordinamento di tipo "strict weak" nel senso matematico standard. Un predicato binario f(x,y) è un oggetto funzione con due oggetti argomento x e y e un valore restituito di true o false. Un ordinamento imposto a un set è un ordinamento debole rigoroso se il predicato binario è irreflessivo, antisymmetrico e transitivo e se l'equivalenza è transitiva, dove due oggetti x e y vengono definiti come equivalenti quando entrambi f x,y) e f(y,x) sono false. Se la condizione di uguaglianza più forte tra le chiavi sostituisce quella di equivalenza, l'ordinamento diventa totale, in quanto tutti gli elementi vengono ordinati l'uno rispetto all'altro e le chiavi accoppiate saranno indistinguibili l'una dall'altra.

L'iteratore fornito dalla classe set è un iteratore bidirezionale, ma le funzioni insert membro della classe e set hanno versioni che accettano come parametri di modello un iteratore di input più debole, i cui requisiti di funzionalità sono più minimi di quelli garantiti dalla classe di iteratori bidirezionali. I diversi concetti di iteratore formano una famiglia correlata dai perfezionamenti delle relative funzionalità. Ogni concetto di iteratore dispone di un proprio set di requisiti e gli algoritmi utilizzati con tali concetti devono limitare le proprie ipotesi ai requisiti forniti da tale tipo di iteratore. Si può presupporre che un iteratore di input possa essere dereferenziato per fare riferimento a un determinato oggetto e possa essere incrementato all'iteratore successivo nella sequenza. Si tratta di un set minimo di funzionalità, ma è sufficiente per poter parlare significativamente di un intervallo di iteratori [ First, Last) nel contesto delle funzioni membro della classe.

Costruttori

Nome	Descrizione
`set`	Costruisce un set vuoto o che rappresenta una copia totale o parziale di un altro set.

Typedef

Nome	Descrizione
`allocator_type`	Tipo che rappresenta la classe `allocator` per l'oggetto del set.
`const_iterator`	Tipo che fornisce un iteratore bidirezionale in grado di leggere un elemento `const` nel set.
`const_pointer`	Tipo che fornisce un puntatore a un elemento `const` di un set.
`const_reference`	Tipo che fornisce un riferimento a un elemento archiviato in un `const` set per la lettura e l'esecuzione di `const` operazioni.
`const_reverse_iterator`	Tipo che fornisce un iteratore bidirezionale in grado di leggere qualsiasi elemento `const` del set.
`difference_type`	Tipo Signed Integer che può essere utilizzato per rappresentare il numero di elementi di un set in un intervallo compreso tra gli elementi a cui puntano gli iteratori.
`iterator`	Tipo che fornisce un iteratore bidirezionale in grado di leggere o modificare qualsiasi elemento di un set.
`key_compare`	Tipo che fornisce un oggetto funzione in grado di confrontare due chiavi di ordinamento per determinare l'ordine relativo di due elementi nel set.
`key_type`	Tipo che descrive un oggetto archiviato come elemento di un set in virtù della sua funzione di chiave di ordinamento.
`pointer`	Tipo che fornisce un puntatore a un elemento di un set.
`reference`	Tipo che fornisce un riferimento a un elemento archiviato in un set.
`reverse_iterator`	Tipo che fornisce un iteratore bidirezionale in grado di leggere o modificare un elemento di un set invertito.
`size_type`	Tipo Unsigned Integer in grado di rappresentare il numero di elementi di un set.
`value_compare`	Tipo che fornisce un oggetto funzione in grado di confrontare due elementi per determinarne l'ordine relativo nel set.
`value_type`	Tipo che descrive un oggetto archiviato come elemento di un set in virtù della sua funzione di valore.

Funzioni

Nome	Descrizione
`begin`	Restituisce un iteratore che punta al primo elemento in `set`.
`cbegin`	Restituisce un iteratore const che punta al primo elemento del `set`.
`cend`	Restituisce un iteratore const che punta alla posizione successiva all'ultimo elemento di un `set`.
`clear`	Cancella tutti gli elementi di un `set`.
`contains`^C++20	Controllare se è presente un elemento con la chiave specificata in `set`.
`count`	Restituisce il numero di elementi di un `set` la cui chiave corrisponde a una chiave specificata dal parametro.
`crbegin`	Restituisce un iteratore const che punta al primo elemento di un `set` invertito.
`crend`	Restituisce un iteratore const che punta alla posizione successiva all'ultimo elemento di un set `set` invertito.
`emplace`	Inserisce un elemento costruito sul posto in un `set`.
`emplace_hint`	Inserisce un elemento costruito sul posto in un `set`, con un suggerimento sulla posizione.
`empty`	Verifica se un `set` è vuoto.
`end`	Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un `set`.
`equal_range`	Restituisce una coppia di iteratori rispettivamente al primo elemento di un `set` con una chiave maggiore di una chiave specificata e al primo elemento di `set` con una chiave uguale o maggiore di tale chiave.
`erase`	Rimuove un elemento o un intervallo di elementi in un set dalle posizioni specificate oppure rimuove gli elementi che corrispondono a una chiave specificata.
`find`	Restituisce un iteratore che punta alla posizione di un elemento in un `set` che dispone di una chiave equivalente a una chiave specificata.
`get_allocator`	Restituisce una copia dell'oggetto `allocator` utilizzato per costruire il `set`.
`insert`	Inserisce un elemento o un intervallo di elementi in un `set`.
`key_comp`	Recupera una copia dell'oggetto di confronto utilizzato per ordinare le chiavi di un `set`.
`lower_bound`	Restituisce un iteratore al primo elemento di un set con una chiave uguale o maggiore di una chiave specificata.
`max_size`	Restituisce la lunghezza massima del `set`.
`rbegin`	Restituisce un iteratore che punta al primo elemento di un `set` invertito.
`rend`	Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un `set` invertito.
`size`	Restituisce il numero di elementi nel `set`.
`swap`	Scambia gli elementi di due `set`.
`upper_bound`	Restituisce un iteratore al primo elemento di un `set` con una chiave maggiore di una chiave specificata.
`value_comp`	Recupera una copia dell'oggetto di confronto usato per ordinare i valori degli elementi di un `set`.

Operatori

Nome	Descrizione
`operator=`	Sostituisce gli elementi di un set con una copia di un altro set.

`allocator_type`

Tipo che rappresenta la classe allocator per l'oggetto set.

typedef Allocator allocator_type;

Osservazioni:

allocator_type è un sinonimo per il parametro di modello Allocator.

Oggetto funzione che viene usato da un oggetto multiset per ordinare gli elementi, corrispondente al parametro di modello Allocator.

Per altre informazioni su Allocator, vedere la sezione Osservazioni dell'argomento set Classe .

Esempio

Vedere l'esempio per get_allocator un esempio che usa allocator_type.

`begin`

Restituisce un iteratore che punta al primo elemento del set.

const_iterator begin() const;

iterator begin();

Valore restituito

Iteratore bidirezionale che punta al primo elemento dell'oggetto set o alla posizione successiva a un oggetto set vuoto.

Osservazioni:

Se il valore restituito di begin viene assegnato a un const_iteratoroggetto , gli elementi nell'oggetto set non possono essere modificati. Se il valore restituito di begin viene assegnato a un iteratoroggetto , è possibile modificare gli elementi nell'oggetto set.

Esempio

// set_begin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int>::iterator s1_Iter;
   set <int>::const_iterator s1_cIter;

   s1.insert( 1 );
   s1.insert( 2 );
   s1.insert( 3 );

   s1_Iter = s1.begin( );
   cout << "The first element of s1 is " << *s1_Iter << endl;

   s1_Iter = s1.begin( );
   s1.erase( s1_Iter );

   // The following 2 lines would err because the iterator is const
   // s1_cIter = s1.begin( );
   // s1.erase( s1_cIter );

   s1_cIter = s1.begin( );
   cout << "The first element of s1 is now " << *s1_cIter << endl;
}

The first element of s1 is 1
The first element of s1 is now 2

`cbegin`

Restituisce un iteratore const che punta al primo elemento dell'intervallo.

const_iterator cbegin() const;

Valore restituito

Iteratore di accesso bidirezionale const che punta al primo elemento dell'intervallo o alla posizione oltre la fine di un intervallo vuoto (per un intervallo vuoto, cbegin() == cend()).

Osservazioni:

Con il valore restituito di cbegin, gli elementi nell'intervallo non possono essere modificati.

È possibile usare questa funzione membro anziché la funzione membro begin() per garantire che il valore restituito sia const_iterator. In genere, viene usato insieme alla parola chiave di deduzione del auto tipo, come illustrato nell'esempio seguente. Nell'esempio, si consideri Container come un contenitore (non const) modificabile di qualsiasi tipo che supporta begin() e cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`cend`

Restituisce un iteratore const che punta alla posizione oltre l'ultimo elemento di un intervallo.

const_iterator cend() const;

Valore restituito

Iteratore di accesso bidirezionale const che punta oltre la fine dell'intervallo.

Osservazioni:

cend viene utilizzato per verificare se un iteratore ha superato la fine del relativo intervallo.

È possibile usare questa funzione membro anziché la funzione membro end() per garantire che il valore restituito sia const_iterator. In genere, viene usato insieme alla parola chiave di deduzione del auto tipo, come illustrato nell'esempio seguente. Nell'esempio, si consideri Container come un contenitore (non const) modificabile di qualsiasi tipo che supporta end() e cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

Il valore restituito da cend non deve essere dereferenziato.

`clear`

Cancella tutti gli elementi di un set.

void clear();

Esempio

// set_clear.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;

   s1.insert( 1 );
   s1.insert( 2 );

   cout << "The size of the set is initially " << s1.size( )
        << "." << endl;

   s1.clear( );
   cout << "The size of the set after clearing is "
        << s1.size( ) << "." << endl;
}

The size of the set is initially 2.
The size of the set after clearing is 0.

`const_iterator`

Tipo che fornisce un iteratore bidirezionale in grado di leggere un elemento const nel set.

typedef implementation-defined const_iterator;

Osservazioni:

Non è possibile usare un tipo const_iterator per modificare il valore di un elemento.

Esempio

Vedere l'esempio per begin un esempio che usa const_iterator.

`const_pointer`

Tipo che fornisce un puntatore a un elemento const di un set.

typedef typename allocator_type::const_pointer const_pointer;

Osservazioni:

Non è possibile usare un tipo const_pointer per modificare il valore di un elemento.

Nella maggior parte dei casi, un const_iterator oggetto deve essere utilizzato per accedere agli elementi in un oggetto const set.

`const_reference`

Tipo che fornisce un riferimento a un elemento archiviato in un const set per la lettura e l'esecuzione di const operazioni.

typedef typename allocator_type::const_reference const_reference;

Esempio

// set_const_ref.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;

   s1.insert( 10 );
   s1.insert( 20 );

   // Declare and initialize a const_reference &Ref1
   // to the 1st element
   const int &Ref1 = *s1.begin( );

   cout << "The first element in the set is "
        << Ref1 << "." << endl;

   // The following line would cause an error because the
   // const_reference can't be used to modify the set
   // Ref1 = Ref1 + 5;
}

The first element in the set is 10.

`const_reverse_iterator`

Tipo che fornisce un iteratore bidirezionale in grado di leggere qualsiasi elemento const del set.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Osservazioni:

Un tipo const_reverse_iterator non può modificare il valore di un elemento e viene usato per scorrere il set inverso.

Esempio

Vedere l'esempio per rend un esempio di come dichiarare e usare .const_reverse_iterator

`contains`

Controllare se è presente un elemento con la chiave specificata in set.

bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;

Parametri

K
Tipo di chiave.

key
Valore della chiave dell'elemento da cercare.

Valore restituito

truese l'elemento viene trovato in ; false in setcaso contrario.

Osservazioni:

contains() è una novità di C++20. Per usarlo, specificare l'opzione del /std:c++20 compilatore o versione successiva.

template<class K> bool contains(const K& key) const partecipa alla risoluzione dell'overload solo se key_compare è trasparente. Per altre informazioni, vedere Ricerca eterogenea nei contenitori associativi .

Esempio

// Requires /std:c++20 or /std:c++latest
#include <set>
#include <iostream>

int main()
{
    std::set<int> theSet = {1, 2};

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << theSet.contains(2) << '\n';
    std::cout << theSet.contains(3) << '\n';

    return 0;
}

true
false

`count`

Restituisce il numero di elementi di un set la cui chiave corrisponde a una chiave specificata dal parametro.

size_type count(const Key& key) const;

Parametri

key
La chiave degli elementi per cui trovare un corrispondenza nel set.

Valore restituito

1 se il set contiene un elemento la cui chiave di ordinamento corrisponde alla chiave del parametro. 0 se il set non contiene un elemento con una chiave corrispondente.

Osservazioni:

La funzione membro restituisce il numero di elementi nell'intervallo seguente:

[ lower_bound(key), upper_bound(key) ).

Esempio

Nell'esempio seguente viene illustrato l'uso della set::count funzione membro.

// set_count.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main()
{
    using namespace std;
    set<int> s1;
    set<int>::size_type i;

    s1.insert(1);
    s1.insert(1);

    // Keys must be unique in set, so duplicates are ignored
    i = s1.count(1);
    cout << "The number of elements in s1 with a sort key of 1 is: "
         << i << "." << endl;

    i = s1.count(2);
    cout << "The number of elements in s1 with a sort key of 2 is: "
         << i << "." << endl;
}

The number of elements in s1 with a sort key of 1 is: 1.
The number of elements in s1 with a sort key of 2 is: 0.

`crbegin`

Restituisce un iteratore const che punta al primo elemento di un set invertito.

const_reverse_iterator crbegin() const;

Valore restituito

Iteratore bidirezionale const inverso che punta al primo elemento di un oggetto set invertito o a quello che è stato l'ultimo elemento dell'oggetto set non invertito.

Osservazioni:

crbegin viene usato con un set invertito esattamente come begin viene usato con un set.

Con il valore restituito di crbegin, l'oggetto set non può essere modificato.

Esempio

// set_crbegin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int>::const_reverse_iterator s1_crIter;

   s1.insert( 10 );
   s1.insert( 20 );
   s1.insert( 30 );

   s1_crIter = s1.crbegin( );
   cout << "The first element in the reversed set is "
        << *s1_crIter << "." << endl;
}

The first element in the reversed set is 30.

`crend`

Restituisce un iteratore const che punta alla posizione successiva all'ultimo elemento di un set invertito.

const_reverse_iterator crend() const;

Valore restituito

Iteratore bidirezionale const inverso che punta alla posizione successiva all'ultimo elemento di un oggetto set invertito, ovvero la posizione che precedeva il primo elemento dell'oggetto set non invertito.

Osservazioni:

crend viene usato con un set invertito esattamente come end viene usato con un set.

Con il valore restituito di crend, l'oggetto set non può essere modificato. Il valore restituito da crend non deve essere dereferenziato.

crend può essere usato per verificare se un iteratore inverso ha raggiunto la fine del relativo oggetto set.

Esempio

// set_crend.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main() {
   using namespace std;
   set <int> s1;
   set <int>::const_reverse_iterator s1_crIter;

   s1.insert( 10 );
   s1.insert( 20 );
   s1.insert( 30 );

   s1_crIter = s1.crend( );
   s1_crIter--;
   cout << "The last element in the reversed set is "
        << *s1_crIter << "." << endl;
}

`difference_type`

Tipo Signed Integer che può essere utilizzato per rappresentare il numero di elementi di un set in un intervallo compreso tra gli elementi a cui puntano gli iteratori.

typedef typename allocator_type::difference_type difference_type;

Osservazioni:

difference_type è il tipo restituito quando si sottrae o si incrementa tramite gli iteratori del contenitore. difference_type viene in genere usato per rappresentare il numero di elementi nell'intervallo [ first, last) tra gli iteratori first e last, includendo l'elemento a cui punta first e l'intervallo di elementi fino all'elemento a cui punta last, escluso tale elemento.

Sebbene difference_type sia disponibile per tutti gli iteratori che soddisfano i requisiti di un iteratore di input, che include la classe di iteratori bidirezionali supportati da contenitori reversibili, ad esempio set, la sottrazione tra iteratori è supportata solo dagli iteratori ad accesso casuale forniti da un contenitore ad accesso casuale, ad esempio vector.

Esempio

// set_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <set>
#include <algorithm>

int main( )
{
   using namespace std;

   set <int> s1;
   set <int>::iterator s1_Iter, s1_bIter, s1_eIter;

   s1.insert( 20 );
   s1.insert( 10 );
   s1.insert( 20 );   // won't insert as set elements are unique

   s1_bIter = s1.begin( );
   s1_eIter = s1.end( );

   set <int>::difference_type   df_typ5, df_typ10, df_typ20;

   df_typ5 = count( s1_bIter, s1_eIter, 5 );
   df_typ10 = count( s1_bIter, s1_eIter, 10 );
   df_typ20 = count( s1_bIter, s1_eIter, 20 );

   // the keys, and hence the elements of a set are unique,
   // so there's at most one of a given value
   cout << "The number '5' occurs " << df_typ5
        << " times in set s1.\n";
   cout << "The number '10' occurs " << df_typ10
        << " times in set s1.\n";
   cout << "The number '20' occurs " << df_typ20
        << " times in set s1.\n";

   // count the number of elements in a set
   set <int>::difference_type  df_count = 0;
   s1_Iter = s1.begin( );
   while ( s1_Iter != s1_eIter)
   {
      df_count++;
      s1_Iter++;
   }

   cout << "The number of elements in the set s1 is: "
        << df_count << "." << endl;
}

The number '5' occurs 0 times in set s1.
The number '10' occurs 1 times in set s1.
The number '20' occurs 1 times in set s1.
The number of elements in the set s1 is: 2.

`emplace`

Inserisce un elemento costruito sul posto, senza che vengano eseguite operazioni di copia o spostamento.

template <class... Args>
pair<iterator, bool>
emplace(
    Args&&... args);

Parametri

args
Argomenti inoltrati per costruire un elemento da inserire nell'oggetto set a meno che quest'ultimo non contenga già un elemento il cui valore è ordinato in modo equivalente.

Valore restituito

Oggetto pair il cui componente bool restituisce true se è stato effettuato un inserimento e false se la mappa contiene già un elemento il cui valore ha un valore equivalente nell'ordinamento. Il componente iterator del valore restituito pair restituisce l'indirizzo in cui è stato inserito un nuovo elemento (se il componente bool è true) o in cui l'elemento è già disponibile (se il componente bool è false).

Osservazioni:

Questa funzione non invalida alcun iteratore né riferimento.

Durante l'inserimento, se viene generata un'eccezione, lo stato del contenitore non viene modificato.

Esempio

// set_emplace.cpp
// compile with: /EHsc
#include <set>
#include <string>
#include <iostream>

using namespace std;

template <typename S> void print(const S& s) {
    cout << s.size() << " elements: ";

    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{
    set<string> s1;

    auto ret = s1.emplace("ten");

    if (!ret.second){
        cout << "Emplace failed, element with value \"ten\" already exists."
            << endl << "  The existing element is (" << *ret.first << ")"
            << endl;
        cout << "set not modified" << endl;
    }
    else{
        cout << "set modified, now contains ";
        print(s1);
    }
    cout << endl;

    ret = s1.emplace("ten");

    if (!ret.second){
        cout << "Emplace failed, element with value \"ten\" already exists."
            << endl << "  The existing element is (" << *ret.first << ")"
            << endl;
    }
    else{
        cout << "set modified, now contains ";
        print(s1);
    }
    cout << endl;
}

`emplace_hint`

Inserisce un elemento costruito in locale (senza che vengano eseguite operazioni di copia o di spostamento), con un suggerimento sulla posizione.

template <class... Args>
iterator emplace_hint(
    const_iterator where,
    Args&&... args);

Parametri

args
Argomenti inoltrati per costruire un elemento da inserire nell'oggetto set a meno che quest'ultimo non contenga già tale elemento o, più in generale, un elemento il cui valore è ordinato in modo equivalente.

where
Posizione in cui iniziare a cercare il punto di inserimento corretto. Se tale punto è immediatamente seguito da where, l'inserimento può avvenire in tempo costante ammortizzato anziché in tempo logaritmico.

Valore restituito

Iteratore all'elemento appena inserito.

Se l'inserimento ha avuto esito negativo perché l'elemento esiste già, restituisce un iteratore all'elemento esistente.

Osservazioni:

Questa funzione non invalida alcun iteratore né riferimento.

Durante l'inserimento, se viene generata un'eccezione, lo stato del contenitore non viene modificato.

Esempio

// set_emplace.cpp
// compile with: /EHsc
#include <set>
#include <string>
#include <iostream>

using namespace std;

template <typename S> void print(const S& s) {
    cout << s.size() << " elements: " << endl;

    for (const auto& p : s) {
        cout << "(" << p <<  ") ";
    }

    cout << endl;
}

int main()
{
    set<string> s1;

    // Emplace some test data
    s1.emplace("Anna");
    s1.emplace("Bob");
    s1.emplace("Carmine");

    cout << "set starting data: ";
    print(s1);
    cout << endl;

    // Emplace with hint
    // s1.end() should be the "next" element after this emplacement
    s1.emplace_hint(s1.end(), "Doug");

    cout << "set modified, now contains ";
    print(s1);
    cout << endl;
}

`empty`

Verifica se un set è vuoto.

bool empty() const;

Valore restituito

true se il set è vuoto; false se il set non èempty.

Esempio

// set_empty.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1, s2;
   s1.insert ( 1 );

   if ( s1.empty( ) )
      cout << "The set s1 is empty." << endl;
   else
      cout << "The set s1 is not empty." << endl;

   if ( s2.empty( ) )
      cout << "The set s2 is empty." << endl;
   else
      cout << "The set s2 is not empty." << endl;
}

The set s1 is not empty.
The set s2 is empty.

`end`

Restituisce l'iteratore successivo all'ultimo valore.

const_iterator end() const;

iterator end();

Valore restituito

Iteratore successivo all'ultimo valore. Se il set è vuoto, verrà restituito set::end() == set::begin().

Osservazioni:

end viene usato per verificare se un iteratore ha superato la fine del set.

Il valore restituito da end non deve essere dereferenziato.

Per un esempio di codice, vedere set::find.

`equal_range`

Restituisce una coppia di iteratori rispettivamente al primo elemento di un oggetto set con una chiave maggiore o uguale a una chiave specificata e al primo elemento dell'oggetto set con una chiave maggiore di tale chiave.

pair <const_iterator, const_iterator> equal_range (const Key& key) const;

pair <iterator, iterator> equal_range (const Key& key);

Parametri

key
Chiave dell'argomento per cui trovare una corrispondenza con la chiave di ordinamento di un elemento presente nell'oggetto set in cui si esegue la ricerca.

Valore restituito

Coppia di iteratori in cui il primo è l'oggetto lower_bound della chiave e il secondo è il upper_bound della chiave.

Per accedere al primo iteratore di una coppia pr restituita dalla funzione membro, usare pr. per prima cosa e per dereferenziare l'iteratore con limite inferiore, usare *( pr. first). Per accedere al secondo iteratore di una coppia pr restituita dalla funzione membro, usare pr. second, e per dereferenziare l'iteratore superiore associato, usare *( pr. secondo).

Esempio

// set_equal_range.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   typedef set<int, less< int > > IntSet;
   IntSet s1;
   set <int, less< int > > :: const_iterator s1_RcIter;

   s1.insert( 10 );
   s1.insert( 20 );
   s1.insert( 30 );

   pair <IntSet::const_iterator, IntSet::const_iterator> p1, p2;
   p1 = s1.equal_range( 20 );

   cout << "The upper bound of the element with "
        << "a key of 20 in the set s1 is: "
        << *(p1.second) << "." << endl;

   cout << "The lower bound of the element with "
        << "a key of 20 in the set s1 is: "
        << *(p1.first) << "." << endl;

   // Compare the upper_bound called directly
   s1_RcIter = s1.upper_bound( 20 );
   cout << "A direct call of upper_bound( 20 ) gives "
        << *s1_RcIter << "," << endl
        << "matching the 2nd element of the pair"
        << " returned by equal_range( 20 )." << endl;

   p2 = s1.equal_range( 40 );

   // If no match is found for the key,
   // both elements of the pair return end( )
   if ( ( p2.first == s1.end( ) ) && ( p2.second == s1.end( ) ) )
      cout << "The set s1 doesn't have an element "
           << "with a key less than 40." << endl;
   else
      cout << "The element of set s1 with a key >= 40 is: "
           << *(p1.first) << "." << endl;
}

The upper bound of the element with a key of 20 in the set s1 is: 30.
The lower bound of the element with a key of 20 in the set s1 is: 20.
A direct call of upper_bound( 20 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 20 ).
The set s1 doesn't have an element with a key less than 40.

`erase`

Rimuove un elemento o un intervallo di elementi in un set dalle posizioni specificate oppure rimuove gli elementi che corrispondono a una chiave specificata.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parametri

Where
Posizione dell'elemento che deve essere rimosso.

First
Posizione del primo elemento che deve essere rimosso.

Last
Posizione immediatamente successiva all'ultimo elemento che deve essere rimosso.

Key
Valore della chiave dell'elemento che deve essere rimosso.

Valore restituito

Per le prime due funzioni membro, iteratore bidirezionale che definisce il primo elemento rimanente oltre gli eventuali elementi rimossi o elemento che rappresenta la fine dell'oggetto set se tali elementi non sono presenti.

Per la terza funzione membro, restituisce il numero di elementi rimossi dall'oggetto set.

Esempio

// set_erase.cpp
// compile with: /EHsc
#include <set>
#include <string>
#include <iostream>
#include <iterator> // next() and prev() helper functions

using namespace std;

using myset = set<string>;

void printset(const myset& s) {
    for (const auto& iter : s) {
        cout << " [" << iter << "]";
    }
    cout << endl << "size() == " << s.size() << endl << endl;
}

int main()
{
    myset s1;

    // Fill in some data to test with, one at a time
    s1.insert("Bob");
    s1.insert("Robert");
    s1.insert("Bert");
    s1.insert("Rob");
    s1.insert("Bobby");

    cout << "Starting data of set s1 is:" << endl;
    printset(s1);
    // The 1st member function removes an element at a given position
    s1.erase(next(s1.begin()));
    cout << "After the 2nd element is deleted, the set s1 is:" << endl;
    printset(s1);

    // Fill in some data to test with, one at a time, using an initializer list
    myset s2{ "meow", "hiss", "purr", "growl", "yowl" };

    cout << "Starting data of set s2 is:" << endl;
    printset(s2);
    // The 2nd member function removes elements
    // in the range [First, Last)
    s2.erase(next(s2.begin()), prev(s2.end()));
    cout << "After the middle elements are deleted, the set s2 is:" << endl;
    printset(s2);

    myset s3;

    // Fill in some data to test with, one at a time, using emplace
    s3.emplace("C");
    s3.emplace("C#");
    s3.emplace("D");
    s3.emplace("D#");
    s3.emplace("E");
    s3.emplace("E#");
    s3.emplace("F");
    s3.emplace("F#");
    s3.emplace("G");
    s3.emplace("G#");
    s3.emplace("A");
    s3.emplace("A#");
    s3.emplace("B");

    cout << "Starting data of set s3 is:" << endl;
    printset(s3);
    // The 3rd member function removes elements with a given Key
    myset::size_type count = s3.erase("E#");
    // The 3rd member function also returns the number of elements removed
    cout << "The number of elements removed from s3 is: " << count << "." << endl;
    cout << "After the element with a key of \"E#\" is deleted, the set s3 is:" << endl;
    printset(s3);
}

`find`

Restituisce un iteratore che fa riferimento alla posizione di un elemento in un set che contiene una chiave equivalente a una chiave specificata.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametri

key
Valore chiave per cui trovare una corrispondenza con la chiave di ordinamento di un elemento presente nel set in cui eseguire la ricerca.

Valore restituito

Iteratore che fa riferimento alla posizione di un elemento con una chiave specificata o alla posizione successiva all'ultimo elemento del set (set::end()) se non viene trovata alcuna corrispondenza per la chiave.

Osservazioni:

La funzione membro restituisce un iteratore che fa riferimento a un elemento nel set la cui chiave è equivalente alla chiave dell'argomento in un predicato binario che induce un ordinamento basato su una relazione di confronto minore di.

Se il valore restituito di find viene assegnato a un const_iteratoroggetto , l'oggetto set non può essere modificato. Se il valore restituito di find viene assegnato a un iteratoroggetto , l'oggetto set può essere modificato

Esempio

// compile with: /EHsc /W4 /MTd
#include <set>
#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename T> void print_elem(const T& t) {
    cout << "(" << t << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

template <typename C, class T> void findit(const C& c, T val) {
    cout << "Trying find() on value " << val << endl;
    auto result = c.find(val);
    if (result != c.end()) {
        cout << "Element found: "; print_elem(*result); cout << endl;
    } else {
        cout << "Element not found." << endl;
    }
}

int main()
{
    set<int> s1({ 40, 45 });
    cout << "The starting set s1 is: " << endl;
    print_collection(s1);

    vector<int> v;
    v.push_back(43);
    v.push_back(41);
    v.push_back(46);
    v.push_back(42);
    v.push_back(44);
    v.push_back(44); // attempt a duplicate

    cout << "Inserting the following vector data into s1: " << endl;
    print_collection(v);

    s1.insert(v.begin(), v.end());

    cout << "The modified set s1 is: " << endl;
    print_collection(s1);
    cout << endl;
    findit(s1, 45);
    findit(s1, 6);
}

`get_allocator`

Restituisce una copia dell'oggetto allocatore usato per costruire l'oggetto set.

allocator_type get_allocator() const;

Valore restituito

Allocatore usato dall'oggetto set per gestire la memoria, che corrisponde al parametro di modello Allocator.

Per altre informazioni su Allocator, vedere la sezione Osservazioni dell'argomento set Classe .

Osservazioni:

Gli allocatori per la classe set specificano il modo in cui la classe gestisce l'archiviazione. Gli allocatori predefiniti forniti con le classi contenitore della libreria standard C++ sono sufficienti per la maggior parte delle esigenze di programmazione. Scrivere e usare una classe allocator personalizzata è un argomento di C++ avanzato.

Esempio

// set_get_allocator.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int>::allocator_type s1_Alloc;
   set <int>::allocator_type s2_Alloc;
   set <double>::allocator_type s3_Alloc;
   set <int>::allocator_type s4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   set <int> s1;
   set <int, allocator<int> > s2;
   set <double, allocator<double> > s3;

   s1_Alloc = s1.get_allocator( );
   s2_Alloc = s2.get_allocator( );
   s3_Alloc = s3.get_allocator( );

   cout << "The number of integers that can be allocated"
        << endl << "before free memory is exhausted: "
        << s2.max_size( ) << "." << endl;

   cout << "\nThe number of doubles that can be allocated"
        << endl << "before free memory is exhausted: "
        << s3.max_size( ) <<  "." << endl;

   // The following line creates a set s4
   // with the allocator of multiset s1.
   set <int> s4( less<int>( ), s1_Alloc );

   s4_Alloc = s4.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated by the other
   if( s1_Alloc == s4_Alloc )
   {
      cout << "\nThe allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "\nThe allocators are not interchangeable."
           << endl;
   }
}

insert

Inserisce un elemento o un intervallo di elementi in un set.

// (1) single element
pair<iterator, bool> insert(
    const value_type& Val);

// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool>
insert(
    ValTy&& Val);

// (3) single element with hint
iterator insert(
    const_iterator Where,
    const value_type& Val);

// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(
    const_iterator Where,
    ValTy&& Val);

// (5) range
template <class InputIterator>
void insert(
    InputIterator First,
    InputIterator Last);

// (6) initializer list
void insert(
    initializer_list<value_type>
IList);

Parametri

Val
Valore di un elemento da inserire nel set a meno che non vi sia già contenuto un elemento il cui valore è ordinato in modo equivalente.

Where
Posizione in cui iniziare a cercare il punto di inserimento corretto. (Se tale punto precede immediatamenteDove, l'inserimento può verificarsi in tempo costante ammortizzato anziché in tempo logaritmico.

ValTy
Parametro modello che specifica il tipo di argomento che il set può usare per costruire un elemento di value_typee inoltra perfettamente Val come argomento.

First
Posizione del primo elemento da copiare.

Last
Posizione immediatamente dopo l'ultimo elemento da copiare.

InputIterator
Argomento della funzione modello che soddisfa i requisiti di un iteratore di input che punta agli elementi di un tipo che può essere usato per costruire value_type oggetti.

IList
Oggetto initializer_list da cui copiare gli elementi.

Valore restituito

Le funzioni membro a singolo elemento, (1) e (2), restituiscono un pair il cui bool componente è true se è stato effettuato un inserimento e false se il set contiene già un elemento di valore equivalente nell'ordinamento. Il componente dell'iteratore della coppia di valori restituita punta all'elemento appena inserito se il componente bool è true oppure all'elemento esistente se il componente bool è false.

Le funzioni membro a elemento singolo con suggerimento, (3) e (4), restituiscono un iteratore che punta alla posizione in cui il nuovo elemento è stato inserito nel set o all'elemento già esistente, se esiste un elemento con una chiave equivalente.

Osservazioni:

Non ci sono iteratori, puntatori o riferimenti invalidati da questa funzione.

Durante l'inserimento di un solo elemento, se viene generata un'eccezione, lo stato del contenitore non viene modificato. Se viene generata un'eccezione durante l'inserimento di più elementi, il contenitore viene lasciato in uno stato non specificato ma comunque valido.

Per accedere al componente dell'iteratore di una pairpr restituita dalle funzioni membro a elemento singolo, usare pr.first; per dereferenziare l'iteratore all'interno della coppia restituita, usare *pr.first fornendo un elemento. Per accedere al componente bool, usare pr.second. Per un esempio, vedere il codice di esempio più avanti in questo articolo.

L'oggetto value_type di un contenitore è un typedef che appartiene al contenitore e, per set, set<V>::value_type è di tipo const V.

La funzione membro dell'intervallo (5) inserisce la sequenza di valori degli elementi in un set che corrisponde a ogni elemento indirizzato da un iteratore nell'intervallo [First, Last), pertanto Last non viene inserito. La funzione membro di contenitore end() fa riferimento alla posizione immediatamente dopo l'ultimo elemento nel contenitore. L'istruzione s.insert(v.begin(), v.end());, ad esempio, cerca di inserire tutti gli elementi di v in s. Solo gli elementi che hanno valori univoci nell'intervallo vengono inseriti; i duplicati vengono ignorati. Per osservare quali elementi vengono rifiutati, usare le versioni con un singolo elemento di insert.

La funzione membro dell'elenco di inizializzatori (6) usa un initializer_list oggetto per copiare gli elementi nel set.

Per l'inserimento di un elemento costruito sul posto, ovvero non vengono eseguite operazioni di copia o spostamento, vedere set::emplace e set::emplace_hint.

Esempio

// set_insert.cpp
// compile with: /EHsc
#include <set>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

template <typename S> void print(const S& s) {
    cout << s.size() << " elements: ";

    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{
    // insert single values
    set<int> s1;
    // call insert(const value_type&) version
    s1.insert({ 1, 10 });
    // call insert(ValTy&&) version
    s1.insert(20);

    cout << "The original set values of s1 are:" << endl;
    print(s1);

    // intentionally attempt a duplicate, single element
    auto ret = s1.insert(1);
    if (!ret.second){
        auto elem = *ret.first;
        cout << "Insert failed, element with value 1 already exists."
            << endl << "  The existing element is (" << elem << ")"
            << endl;
    }
    else{
        cout << "The modified set values of s1 are:" << endl;
        print(s1);
    }
    cout << endl;

    // single element, with hint
    s1.insert(s1.end(), 30);
    cout << "The modified set values of s1 are:" << endl;
    print(s1);
    cout << endl;

    // The templatized version inserting a jumbled range
    set<int> s2;
    vector<int> v;
    v.push_back(43);
    v.push_back(294);
    v.push_back(41);
    v.push_back(330);
    v.push_back(42);
    v.push_back(45);

    cout << "Inserting the following vector data into s2:" << endl;
    print(v);

    s2.insert(v.begin(), v.end());

    cout << "The modified set values of s2 are:" << endl;
    print(s2);
    cout << endl;

    // The templatized versions move-constructing elements
    set<string>  s3;
    string str1("blue"), str2("green");

    // single element
    s3.insert(move(str1));
    cout << "After the first move insertion, s3 contains:" << endl;
    print(s3);

    // single element with hint
    s3.insert(s3.end(), move(str2));
    cout << "After the second move insertion, s3 contains:" << endl;
    print(s3);
    cout << endl;

    set<int> s4;
    // Insert the elements from an initializer_list
    s4.insert({ 4, 44, 2, 22, 3, 33, 1, 11, 5, 55 });
    cout << "After initializer_list insertion, s4 contains:" << endl;
    print(s4);
    cout << endl;
}

`iterator`

Tipo che fornisce un iteratore bidirezionale costante in grado di leggere qualsiasi elemento in un oggetto set.

typedef implementation-defined iterator;

Esempio

Vedere l'esempio per begin un esempio di come dichiarare e usare un oggetto iterator.

`key_comp`

Recupera una copia dell'oggetto di confronto utilizzato per ordinare le chiavi di un set.

key_compare key_comp() const;

Valore restituito

Restituisce l'oggetto funzione che viene usato da un oggetto set per ordinare gli elementi, corrispondente al parametro di modello Traits.

Per altre informazioni su Traits, vedere l'argomento set Classe .

Osservazioni:

L'oggetto archiviato definisce la funzione membro:

bool operator()(const Key&_xVal, const Key&_yVal);

che restituisce true se _xVal precede e non è uguale a _yVal nell'ordinamento.

Entrambi key_compare e value_compare sono sinonimi per il parametro Traitsdi modello . Entrambi i tipi vengono forniti per le classi set e multiset, in cui sono identiche, per compatibilità con le classi map e multimap, dove sono distinte.

Esempio

// set_key_comp.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;

   set <int, less<int> > s1;
   set<int, less<int> >::key_compare kc1 = s1.key_comp( ) ;
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true, "
           << "where kc1 is the function object of s1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of s1."
           << endl;
   }

   set <int, greater<int> > s2;
   set<int, greater<int> >::key_compare kc2 = s2.key_comp( ) ;
   bool result2 = kc2( 2, 3 ) ;
   if(result2 == true)
   {
      cout << "kc2( 2,3 ) returns value of true, "
           << "where kc2 is the function object of s2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of s2."
           << endl;
   }
}

kc1( 2,3 ) returns value of true, where kc1 is the function object of s1.
kc2( 2,3 ) returns value of false, where kc2 is the function object of s2.

`key_compare`

Tipo che fornisce un oggetto funzione in grado di confrontare due chiavi di ordinamento per determinare l'ordine relativo di due elementi nel set.

typedef Traits key_compare;

Osservazioni:

key_compare è un sinonimo per il parametro di modello Traits.

Per altre informazioni su Traits, vedere l'argomento set Classe .

Esempio

Vedere l'esempio per key_comp un esempio di come dichiarare e usare key_compare.

`key_type`

Tipo che descrive un oggetto archiviato come elemento di un oggetto set in qualità di chiave di ordinamento.

typedef Key key_type;

Osservazioni:

key_type è un sinonimo per il parametro di modello Key.

Per altre informazioni su Key, vedere la sezione Osservazioni dell'argomento set Classe .

Entrambi key_type e value_type sono sinonimi per il parametro Keydi modello . Entrambi i tipi vengono forniti per le classi set e multiset, in cui sono identiche, per compatibilità con le classi map e multimap, dove sono distinte.

Esempio

Vedere l'esempio per value_type un esempio di come dichiarare e usare key_type.

`lower_bound`

Restituisce un iteratore al primo elemento di un set con una chiave uguale o maggiore di una chiave specificata.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Parametri

key
Chiave dell'argomento per cui trovare una corrispondenza con la chiave di ordinamento di un elemento presente nell'oggetto set in cui si esegue la ricerca.

Valore restituito

Tipo iterator o const_iterator che punta alla posizione di un elemento di un oggetto set con una chiave uguale o maggiore della chiave dell'argomento o che punta alla posizione successiva all'ultimo elemento dell'oggetto set se non viene trovata alcuna corrispondenza per la chiave.

Esempio

// set_lower_bound.cpp
// compile with: /EHsc
#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.lower_bound( 20 );
   cout << "The element of set s1 with a key of 20 is: "
        << *s1_RcIter << "." << endl;

   s1_RcIter = s1.lower_bound( 40 );

   // If no match is found for the key, end( ) is returned
   if ( s1_RcIter == s1.end( ) )
      cout << "The set s1 doesn't have an element "
           << "with a key of 40." << endl;
   else
      cout << "The element of set s1 with a key of 40 is: "
           << *s1_RcIter << "." << endl;

   // The element at a specific location in the set can be found
   // by using a dereferenced iterator that addresses the location
   s1_AcIter = s1.end( );
   s1_AcIter--;
   s1_RcIter = s1.lower_bound( *s1_AcIter );
   cout << "The element of s1 with a key matching "
        << "that of the last element is: "
        << *s1_RcIter << "." << endl;
}

The element of set s1 with a key of 20 is: 20.
The set s1 doesn't have an element with a key of 40.
The element of s1 with a key matching that of the last element is: 30.

`max_size`

Restituisce la lunghezza massima del set.

size_type max_size() const;

Valore restituito

Massima lunghezza possibile dell'oggetto set.

Esempio

// set_max_size.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int>::size_type i;

   i = s1.max_size( );
   cout << "The maximum possible length "
        << "of the set is " << i << "." << endl;
}

`operator=`

Sostituisce gli elementi di questo oggetto set usando gli elementi di un altro oggetto set.

set& operator=(const set& right);

set& operator=(set&& right);

Parametri

right
Oggetto set che fornisce nuovi elementi da assegnare a questo oggetto set.

Osservazioni:

La prima versione di operator= usa un riferimento lvalue per right al fine di copiare elementi da right a questo oggetto set.

La seconda versione usa un riferimento rvalue per right. Sposta gli elementi da right a questo set.

Gli elementi di questo oggetto set vengono eliminati prima che venga eseguita la funzione dell'operatore.

Esempio

// set_operator_as.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
   {
   using namespace std;
   set<int> v1, v2, v3;
   set<int>::iterator iter;

   v1.insert(10);

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << *iter << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;
   }

`pointer`

Tipo che fornisce un puntatore a un elemento di un set.

typedef typename allocator_type::pointer pointer;

Osservazioni:

È possibile utilizzare un tipo pointer per modificare il valore di un elemento.

Nella maggior parte dei casi, un oggetto iterator deve essere utilizzato per accedere agli elementi in un oggetto set.

`rbegin`

Restituisce un iteratore che punta al primo elemento di un set invertito.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valore restituito

Iteratore bidirezionale inverso che punta al primo elemento di un oggetto set invertito o a quello che è stato l'ultimo elemento dell'oggetto set non invertito.

Osservazioni:

rbegin viene usato con un set invertito esattamente come begin viene usato con un set.

Se il valore restituito di rbegin viene assegnato a un const_reverse_iteratoroggetto , l'oggetto set non può essere modificato. Se il valore restituito di rbegin viene assegnato a un reverse_iterator, l'oggetto set può essere modificato.

rbegin può essere usato per eseguire l'iterazione all'indietro su un oggetto set.

Esempio

// set_rbegin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int>::iterator s1_Iter;
   set <int>::reverse_iterator s1_rIter;

   s1.insert( 10 );
   s1.insert( 20 );
   s1.insert( 30 );

   s1_rIter = s1.rbegin( );
   cout << "The first element in the reversed set is "
        << *s1_rIter << "." << endl;

   // begin can be used to start an iteration
   // through a set in a forward order
   cout << "The set is:";
   for ( s1_Iter = s1.begin( ) ; s1_Iter != s1.end( ); s1_Iter++ )
      cout << " " << *s1_Iter;
   cout << endl;

   // rbegin can be used to start an iteration
   // through a set in a reverse order
   cout << "The reversed set is:";
   for ( s1_rIter = s1.rbegin( ) ; s1_rIter != s1.rend( ); s1_rIter++ )
      cout << " " << *s1_rIter;
   cout << endl;

   // A set element can be erased by dereferencing to its key
   s1_rIter = s1.rbegin( );
   s1.erase ( *s1_rIter );

   s1_rIter = s1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed set is "<< *s1_rIter << "." << endl;
}

The first element in the reversed set is 30.
The set is: 10 20 30
The reversed set is: 30 20 10
After the erasure, the first element in the reversed set is 20.

`reference`

Tipo che fornisce un riferimento a un elemento archiviato in un set.

typedef typename allocator_type::reference reference;

Esempio

// set_reference.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;

   s1.insert( 10 );
   s1.insert( 20 );

   // Declare and initialize a reference &Ref1 to the 1st element
   const int &Ref1 = *s1.begin( );

   cout << "The first element in the set is "
        << Ref1 << "." << endl;
}

The first element in the set is 10.

`rend`

Restituisce un iteratore che punta alla posizione successiva all'ultimo elemento di un set invertito.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valore restituito

Iteratore bidirezionale inverso che punta alla posizione successiva all'ultimo elemento di un oggetto set invertito, ovvero la posizione che precedeva il primo elemento dell'oggetto set non invertito.

Osservazioni:

rend viene usato con un set invertito esattamente come end viene usato con un set.

Se il valore restituito di rend viene assegnato a un const_reverse_iteratoroggetto , l'oggetto set non può essere modificato. Se il valore restituito di rend viene assegnato a un reverse_iterator, l'oggetto set può essere modificato. Il valore restituito da rend non deve essere dereferenziato.

rend può essere usato per verificare se un iteratore inverso ha raggiunto la fine del relativo oggetto set.

Esempio

// set_rend.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main() {
   using namespace std;
   set <int> s1;
   set <int>::iterator s1_Iter;
   set <int>::reverse_iterator s1_rIter;
   set <int>::const_reverse_iterator s1_crIter;

   s1.insert( 10 );
   s1.insert( 20 );
   s1.insert( 30 );

   s1_rIter = s1.rend( );
   s1_rIter--;
   cout << "The last element in the reversed set is "
        << *s1_rIter << "." << endl;

   // end can be used to terminate an iteration
   // through a set in a forward order
   cout << "The set is: ";
   for ( s1_Iter = s1.begin( ) ; s1_Iter != s1.end( ); s1_Iter++ )
      cout << *s1_Iter << " ";
   cout << "." << endl;

   // rend can be used to terminate an iteration
   // through a set in a reverse order
   cout << "The reversed set is: ";
   for ( s1_rIter = s1.rbegin( ) ; s1_rIter != s1.rend( ); s1_rIter++ )
      cout << *s1_rIter << " ";
   cout << "." << endl;

   s1_rIter = s1.rend( );
   s1_rIter--;
   s1.erase ( *s1_rIter );

   s1_rIter = s1.rend( );
   --s1_rIter;
   cout << "After the erasure, the last element in the "
        << "reversed set is " << *s1_rIter << "." << endl;
}

`reverse_iterator`

Tipo che fornisce un iteratore bidirezionale in grado di leggere o modificare un elemento di un set invertito.

typedef std::reverse_iterator<iterator> reverse_iterator;

Osservazioni:

Un tipo reverse_iterator viene usato per scorrere il set inverso.

Esempio

Vedere l'esempio per rbegin un esempio di come dichiarare e usare reverse_iterator.

`set`

Costruisce un set vuoto o che rappresenta una copia totale o parziale di un altro set.

set();

explicit set(
    const Traits& Comp);

set(
    const Traits& Comp,
    const Allocator& Al);

set(
    const set& Right);

set(
    set&& Right);

set(
    initializer_list<Type> IList);

set(
    initializer_list<Type> IList,
    const Compare& Comp);

set(
    initializer_list<Type> IList,
    const Compare& Comp,
    const Allocator& Al);

template <class InputIterator>
set(
    InputIterator First,
    InputIterator Last);

template <class InputIterator>
set(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp);

template <class InputIterator>
set(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp,
    const Allocator& Al);

Parametri

Al
Classe allocatore di archiviazione da usare per questo oggetto set, che per impostazione predefinita è Allocator.

Comp
Funzione di confronto di tipo const Traits usata per ordinare gli elementi nell'oggetto set. Per impostazione predefinita è Compare.

Rght
Oggetto set di cui il set costruito deve essere una copia.

First
Posizione del primo elemento nell'intervallo di elementi da copiare.

Last
Posizione del primo elemento oltre l'intervallo di elementi da copiare.

IList
initializer_list da cui copiare gli elementi.

Osservazioni:

Tutti i costruttori archiviano un tipo di oggetto allocatore che gestisce l'archiviazione di memoria per il set e che può essere restituito in un secondo momento chiamando get_allocator. Il parametro allocator viene spesso omesso nelle dichiarazioni di classe e vengono usate macro di pre-elaborazione per introdurre allocatori alternativi.

Tutti i costruttori inizializzano i relativi oggetti set.

Tutti i costruttori archiviano un oggetto funzione di tipo Traits utilizzato per stabilire un ordine tra le chiavi del set e che possono essere restituiti in un secondo momento chiamando key_comp.

I primi tre costruttori specificano un set iniziale vuoto, il secondo che specifica il tipo di funzione di confronto (comp) da usare per stabilire l'ordine degli elementi e il terzo specifica in modo esplicito il tipo di allocatore (al). La parola chiave explicit elimina alcuni tipi di conversione automatica del tipo.

Il quarto costruttore specifica una copia dell'oggetto set right.

I tre costruttori successivi usano un oggetto initializer_list per specificare gli elementi.

I tre costruttori successivi copiano l'intervallo [ first, last) di un set con maggiore esplicitità per specificare il tipo di funzione di confronto della classe Traits e Allocator.

L'ottavo costruttore specifica una copia dell'oggetto set tramite lo spostamento di right.

Esempio

// set_set.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main()
{
    using namespace std;

    // Create an empty set s0 of key type integer
    set <int> s0;

    // Create an empty set s1 with the key comparison
    // function of less than, then insert 4 elements
    set <int, less<int> > s1;
    s1.insert(10);
    s1.insert(20);
    s1.insert(30);
    s1.insert(40);

    // Create an empty set s2 with the key comparison
    // function of less than, then insert 2 elements
    set <int, less<int> > s2;
    s2.insert(10);
    s2.insert(20);

    // Create a set s3 with the
    // allocator of set s1
    set <int>::allocator_type s1_Alloc;
    s1_Alloc = s1.get_allocator();
    set <int> s3(less<int>(), s1_Alloc);
    s3.insert(30);

    // Create a copy, set s4, of set s1
    set <int> s4(s1);

    // Create a set s5 by copying the range s1[ first,  last)
    set <int>::const_iterator s1_bcIter, s1_ecIter;
    s1_bcIter = s1.begin();
    s1_ecIter = s1.begin();
    s1_ecIter++;
    s1_ecIter++;
    set <int> s5(s1_bcIter, s1_ecIter);

    // Create a set s6 by copying the range s4[ first,  last)
    // and with the allocator of set s2
    set <int>::allocator_type s2_Alloc;
    s2_Alloc = s2.get_allocator();
    set <int> s6(s4.begin(), ++s4.begin(), less<int>(), s2_Alloc);

    cout << "s1 =";
    for (auto i : s1)
        cout << " " << i;
    cout << endl;

    cout << "s2 = " << *s2.begin() << " " << *++s2.begin() << endl;

    cout << "s3 =";
    for (auto i : s3)
        cout << " " << i;
    cout << endl;

    cout << "s4 =";
    for (auto i : s4)
        cout << " " << i;
    cout << endl;

    cout << "s5 =";
    for (auto i : s5)
        cout << " " << i;
    cout << endl;

    cout << "s6 =";
    for (auto i : s6)
        cout << " " << i;
    cout << endl;

    // Create a set by moving s5
    set<int> s7(move(s5));
    cout << "s7 =";
    for (auto i : s7)
        cout << " " << i;
    cout << endl;

    // Create a set with an initializer_list
    cout << "s8 =";
    set<int> s8{ { 1, 2, 3, 4 } };
    for (auto i : s8)
        cout << " " << i;
    cout << endl;

    cout << "s9 =";
    set<int> s9{ { 5, 6, 7, 8 }, less<int>() };
    for (auto i : s9)
        cout << " " << i;
    cout << endl;

    cout << "s10 =";
    set<int> s10{ { 10, 20, 30, 40 }, less<int>(), s9.get_allocator() };
    for (auto i : s10)
        cout << " " << i;
    cout << endl;
}

s1 = 10 20 30 40s2 = 10 20s3 = 30s4 = 10 20 30 40s5 = 10 20s6 = 10s7 = 10 20s8 = 1 2 3 4s9 = 5 6 7 8s10 = 10 20 30 40

`size`

Restituisce il numero di elementi nel set.

size_type size() const;

Valore restituito

Lunghezza corrente dell'oggetto set.

Esempio

// set_size.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int> :: size_type i;

   s1.insert( 1 );
   i = s1.size( );
   cout << "The set length is " << i << "." << endl;

   s1.insert( 2 );
   i = s1.size( );
   cout << "The set length is now " << i << "." << endl;
}

The set length is 1.
The set length is now 2.

`size_type`

Tipo Unsigned Integer in grado di rappresentare il numero di elementi di un set.

typedef typename allocator_type::size_type size_type;

Esempio

Vedere l'esempio per size un esempio di come dichiarare e usare size_type

`swap`

Scambia gli elementi di due set.

void swap(
    set<Key, Traits, Allocator>& right);

Parametri

right
Argomento di tipo set che fornisce gli elementi da scambiare con l'oggetto set di destinazione.

Osservazioni:

La funzione membro non invalida riferimenti, puntatori o iteratori che designano gli elementi dei due oggetti set di cui vengono scambiati gli elementi.

Esempio

// set_swap.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1, s2, s3;
   set <int>::iterator s1_Iter;

   s1.insert( 10 );
   s1.insert( 20 );
   s1.insert( 30 );
   s2.insert( 100 );
   s2.insert( 200 );
   s3.insert( 300 );

   cout << "The original set s1 is:";
   for ( s1_Iter = s1.begin( ); s1_Iter != s1.end( ); s1_Iter++ )
      cout << " " << *s1_Iter;
   cout   << "." << endl;

   // This is the member function version of swap
   s1.swap( s2 );

   cout << "After swapping with s2, list s1 is:";
   for ( s1_Iter = s1.begin( ); s1_Iter != s1.end( ); s1_Iter++ )
      cout << " " << *s1_Iter;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( s1, s3 );

   cout << "After swapping with s3, list s1 is:";
   for ( s1_Iter = s1.begin( ); s1_Iter != s1.end( ); s1_Iter++ )
      cout << " " << *s1_Iter;
   cout   << "." << endl;
}

The original set s1 is: 10 20 30.
After swapping with s2, list s1 is: 100 200.
After swapping with s3, list s1 is: 300.

`upper_bound`

Restituisce un iteratore al primo elemento di un oggetto set con una chiave maggiore di una chiave specificata.

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Parametri

key
Chiave dell'argomento per cui trovare una corrispondenza con la chiave di ordinamento di un elemento presente nell'oggetto set in cui si esegue la ricerca.

Valore restituito

Oggetto iterator o const_iterator che punta alla posizione di un elemento in un set con una chiave maggiore della chiave dell'argomento oppure che punta alla posizione successiva all'ultimo elemento nel set se non viene trovata alcuna corrispondenza per la chiave.

Esempio

// set_upper_bound.cpp
// compile with: /EHsc
#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 << "The first element of set s1 with a key greater "
        << "than 20 is: " << *s1_RcIter << "." << endl;

   s1_RcIter = s1.upper_bound( 30 );

   // If no match is found for the key, end( ) is returned
   if ( s1_RcIter == s1.end( ) )
      cout << "The set s1 doesn't have an element "
           << "with a key greater than 30." << endl;
   else
      cout << "The element of set s1 with a key > 40 is: "
           << *s1_RcIter << "." << endl;

   // The element at a specific location in the set can be found
   // by using a dereferenced iterator addressing the location
   s1_AcIter = s1.begin( );
   s1_RcIter = s1.upper_bound( *s1_AcIter );
   cout << "The first element of s1 with a key greater than"
        << endl << "that of the initial element of s1 is: "
        << *s1_RcIter << "." << endl;
}

The first element of set s1 with a key greater than 20 is: 30.
The set s1 doesn't have an element with a key greater than 30.
The first element of s1 with a key greater than
that of the initial element of s1 is: 20.

`value_comp`

Recupera una copia dell'oggetto di confronto utilizzato per ordinare i valori degli elementi di un set.

value_compare value_comp() const;

Valore restituito

Restituisce l'oggetto funzione che viene usato da un oggetto set per ordinare gli elementi, corrispondente al parametro di modello Traits.

Per altre informazioni su Traits, vedere l'argomento set Classe .

Osservazioni:

L'oggetto archiviato definisce la funzione membro:

bool operator(const Key&_xVal, const Key&_yVal);

che restituisce true se _xVal precede e non è uguale a _yVal nell'ordinamento.

Entrambi value_compare e key_compare sono sinonimi per il parametro Traitsdi modello . Entrambi i tipi vengono forniti per le classi set e multiset, in cui sono identiche, per compatibilità con le classi map e multimap, dove sono distinte.

Esempio

// set_value_comp.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;

   set <int, less<int> > s1;
   set <int, less<int> >::value_compare vc1 = s1.value_comp( );
   bool result1 = vc1( 2, 3 );
   if( result1 == true )
   {
      cout << "vc1( 2,3 ) returns value of true, "
           << "where vc1 is the function object of s1."
           << endl;
   }
   else
   {
      cout << "vc1( 2,3 ) returns value of false, "
           << "where vc1 is the function object of s1."
           << endl;
   }

   set <int, greater<int> > s2;
   set<int, greater<int> >::value_compare vc2 = s2.value_comp( );
   bool result2 = vc2( 2, 3 );
   if( result2 == true )
   {
      cout << "vc2( 2,3 ) returns value of true, "
           << "where vc2 is the function object of s2."
           << endl;
   }
   else
   {
      cout << "vc2( 2,3 ) returns value of false, "
           << "where vc2 is the function object of s2."
           << endl;
   }
}

vc1( 2,3 ) returns value of true, where vc1 is the function object of s1.
vc2( 2,3 ) returns value of false, where vc2 is the function object of s2.

`value_compare`

Tipo che fornisce un oggetto funzione in grado di confrontare due valori di elemento per determinarne l'ordine relativo nell'oggetto set.

typedef key_compare value_compare;

Osservazioni:

value_compare è un sinonimo per il parametro di modello Traits.

Per altre informazioni su Traits, vedere l'argomento set Classe .

Esempio

Vedere l'esempio per value_comp un esempio di come dichiarare e usare value_compare.

`value_type`

Tipo che descrive un oggetto archiviato come elemento di un oggetto set in qualità di valore.

typedef Key value_type;

Osservazioni:

value_type è un sinonimo per il parametro di modello Key.

Per altre informazioni su Key, vedere la sezione Osservazioni dell'argomento set Classe .

Esempio

// set_value_type.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int>::iterator s1_Iter;

   set <int>::value_type svt_Int;   // Declare value_type
   svt_Int = 10;            // Initialize value_type

   set <int> :: key_type skt_Int;   // Declare key_type
   skt_Int = 20;             // Initialize key_type

   s1.insert( svt_Int );         // Insert value into s1
   s1.insert( skt_Int );         // Insert key into s1

   // A set accepts key_types or value_types as elements
   cout << "The set has elements:";
   for ( s1_Iter = s1.begin( ) ; s1_Iter != s1.end( ); s1_Iter++)
      cout << " " << *s1_Iter;
   cout << "." << endl;
}

The set has elements: 10 20.

Condividi tramite

Classe set

Sintassi

Parametri

Osservazioni:

Costruttori

Typedef

Funzioni

Operatori

allocator_type

Osservazioni:

Esempio

begin

Valore restituito

Osservazioni:

Esempio

cbegin

Valore restituito

Osservazioni:

cend

Valore restituito

Osservazioni:

clear

Esempio

const_iterator

Osservazioni:

Esempio

const_pointer

Osservazioni:

const_reference

Esempio

const_reverse_iterator

Osservazioni:

Esempio

contains

Parametri

Valore restituito

Osservazioni:

Esempio

count

Parametri

Valore restituito

Osservazioni:

Esempio

crbegin

Valore restituito

Osservazioni:

Esempio

crend

Valore restituito

Osservazioni:

Esempio

difference_type

Osservazioni:

Esempio

emplace

Parametri

Valore restituito

Osservazioni:

Esempio

emplace_hint

Parametri

Valore restituito

Osservazioni:

Esempio

empty

Valore restituito

Esempio

end

Valore restituito

Osservazioni:

equal_range

Parametri

Valore restituito

Esempio

erase

Parametri

Valore restituito

Esempio

find

Classe `set`

`allocator_type`

`begin`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`contains`

`count`

`crbegin`

`crend`

`difference_type`

`emplace`

`emplace_hint`

`empty`

`end`

`equal_range`

`erase`

`find`

`get_allocator`

`iterator`

`key_comp`

`key_compare`

`key_type`

`lower_bound`

`max_size`

`operator=`

`pointer`

`rbegin`

`reference`

`rend`

`reverse_iterator`

`set`

`size`

`size_type`

`swap`

`upper_bound`

`value_comp`