set::set
Construit un jeu qui est vide ou qui est une copie de l'ensemble ou une partie d'un autre ensemble.
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
);
Paramètres
Paramètre |
Description |
Al |
La classe de l'allocateur de mémoire à utiliser pour cet objet de positionnement, qui correspond par défaut à Allocator. |
comp |
La fonction de comparaison du type constTraits utilisé pour classer les éléments dans le jeu, qui correspond par défaut à Compare. |
right |
Le jeu dont le jeu construit doit être une copie. |
first |
Position du premier élément de la plage d'éléments à copier. |
last |
Position du premier élément au delà de la plage d'éléments à copier. |
Notes
Tous les constructeurs enregistre un type d'objet d'allocation qui gère la mémoire de mémoire pour le positionnement et qui peut ensuite être retourné en appelant get_allocator.Le paramètre de l'allocateur est souvent omis dans les déclarations de classe et les macros de prétraitement utilisées pour substituer d'autres allocateurs.
Tous les constructeurs initialisent leurs jeux.
Tous les constructeurs enregistre un objet de fonction de type Traits utilisé pour générer une commande entre les clés de positionnement et qui peut ensuite être retourné en appelant key_comp.
Les trois premiers constructeurs spécifient un ensemble vide initiale, le deuxième spécifiant le type de fonction de comparaison (comp) à utiliser lorsque vous établissez l'ordre des éléments et du tiers spécifiant explicitement le type de l'allocateur (al) à utiliser.Le mot clé explicit supprimer certains genres de conversion de type automatique.
Le quatrième constructeur spécifie une copie du jeu right.
Les trois suivants constructeurs copiez la plage [first, last) d'un jeu avec l'augmentation de l'explicité en spécifiant le type de fonction de comparaison de classe Traits et Allocator.
Le dernier constructeur spécifie une copie du jeu en déplaçant right.
Exemple
// 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;
}
L'exemple suivant montre comment utiliser des comparateurs personnalisés.
#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);
}
Configuration requise
en-tête : <set>
l'espace de noms : DST