set::set
Crea un set che è vuoto o mediante la copia di tutto o parte di un altro set.
set( );
explicit set(
const Traits& comp
);
set(
const Traits& comp,
const Allocator& al
);
set(
const set& right
);
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
);
set(
set&& right
);
Parametri
Parametro |
Descrizione |
Al |
La classe di allocatore di memoria da utilizzare per questo oggetto impostato, che imposta come valore predefinito a Allocator. |
comp |
La funzione di confronto di tipo constTraits utilizzato per ordinare gli elementi nel set, che imposta come valore predefinito a Compare. |
right |
Il set di cui il set viene costruito da una copia. |
first |
La posizione del primo elemento nella sequenza di elementi da copiare. |
last |
La posizione del primo elemento nell'intervallo di elementi da copiare. |
Note
Tutti i costruttori archivia un tipo di oggetto allocatore che gestisce l'archiviazione di memoria per il set e che successivamente può essere restituito chiamando get_allocator.Il parametro di allocatore viene omesso spesso nelle dichiarazioni di classe e nelle macro del preprocessore utilizzate per sostituire di allocatori alternativi.
Tutti i costruttori inizializzano i relativi set.
Tutti i costruttori archiviano un oggetto funzione di tipo Traits utilizzato per stabilire un ordine tra le chiavi get e set che può successivamente essere restituito chiamando key_comp.
I primi tre costruttori specificano un set vuoto iniziali, il secondo specifica il tipo di funzione di confrontocomp() da utilizzare per stabilire l'ordine degli elementi e del terzo specificare in modo esplicito il tipo dialallocatore () da utilizzare.La parola chiave explicit elimina determinati tipi di conversione automatica dei tipi.
Il quarto costruttore specifica una copia rightimpostato.
I tre costruttori seguenti copia dell'intervallo [first, last) di un set con l'aumento di chiarezza nello specificare il tipo di funzione di confronto di classe Traits e Allocator.
L'ultimo costruttore specifica una copia del set spostando right.
Esempio
// set_set.cpp
// compile with: /EHsc
#include <set>
#include <iostream>
int main( )
{
using namespace std;
set <int>::iterator s1_Iter, s2_Iter, s3_Iter, s4_Iter, s5_Iter, s6_Iter, s7_Iter;
// 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 geater than, then insert 2 elements
set <int, greater<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 ( s1_Iter = s1.begin( ); s1_Iter != s1.end( ); s1_Iter++ )
cout << " " << *s1_Iter;
cout << endl;
cout << "s2 = " << *s2.begin( ) << " " << *++s2.begin( ) << endl;
cout << "s3 =";
for ( s3_Iter = s3.begin( ); s3_Iter != s3.end( ); s3_Iter++ )
cout << " " << *s3_Iter;
cout << endl;
cout << "s4 =";
for ( s4_Iter = s4.begin( ); s4_Iter != s4.end( ); s4_Iter++ )
cout << " " << *s4_Iter;
cout << endl;
cout << "s5 =";
for ( s5_Iter = s5.begin( ); s5_Iter != s5.end( ); s5_Iter++ )
cout << " " << *s5_Iter;
cout << endl;
cout << "s6 =";
for ( s6_Iter = s6.begin( ); s6_Iter != s6.end( ); s6_Iter++ )
cout << " " << *s6_Iter;
cout << endl;
// Create a set by moving s5
set<int> s7(move(s5));
cout << "s7 =";
for ( s7_Iter = s7.begin( ); s7_Iter != s7.end( ); s7_Iter++ )
cout << " " << *s7_Iter;
cout << endl;
}
Nell'esempio seguente viene illustrato come utilizzare i comparatori personalizzati.
#include <iostream>
#include <ostream>
#include <set>
#include <string>
#include <vector>
using namespace std;
struct Person {
Person(const string& name, const int age)
: m_name(name), m_age(age) { }
string m_name;
int m_age;
};
struct PersonAgeLess {
bool operator()(const Person& lhs, const Person& rhs) const {
return lhs.m_age < rhs.m_age;
}
};
bool PersonNameGreater(const Person& lhs, const Person& rhs) {
return lhs.m_name > rhs.m_name;
}
template <typename Container> void print(const string& s, const Container& c) {
cout << s << ":" << endl;
for (typename Container::const_iterator i = c.begin(); i != c.end(); ++i) {
cout << i->m_name << " " << i->m_age << endl;
}
cout << endl;
}
int main() {
vector<Person> v;
v.push_back(Person("Washington", 12));
v.push_back(Person("Hayes", 8));
v.push_back(Person("Bush", 5));
v.push_back(Person("Garfield", 30));
v.push_back(Person("Clinton", 7));
v.push_back(Person("Jefferson", 10));
set<Person, PersonAgeLess> sl;
for (vector<Person>::const_iterator i = v.begin(); i != v.end(); ++i) {
sl.insert(*i);
}
set<Person, bool (*)(const Person&, const Person&)> sg(PersonNameGreater);
for (vector<Person>::const_iterator i = v.begin(); i != v.end(); ++i) {
sg.insert(*i);
}
print("Original vector", v);
print("Sorted by age (ascending)", sl);
print("Sorted by name (descending)", sg);
}
Requisiti
intestazione: <set>
Spazio dei nomi: deviazione standard