set::set
Erstellt einen Satz, der leer ist, oder der eine Kopie von vollständig oder teilweise eines anderen Satzes ist.
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
);
Parameter
Parameter |
Description |
Al |
Die für dieses Objekt festgelegte verwendet werden, Speicherreservierungsklasse, das zu Allocator führt. |
comp |
Die Vergleichsfunktion des Typs constTraits verwendet, um Elemente im Satz zu sortieren, der zu Compare führt. |
right |
Der Satz, von dem der erstellte Satz, eine Kopie sein soll. |
first |
Die Position des ersten Elements im Bereich von Elementen kopiert werden. |
last |
Die Position des ersten Elements über den Bereich von Elementen hinaus kopiert werden. |
Hinweise
Alle Konstruktoren speichern einen Typ allocator-Objekt, das Arbeitsspeicherspeicher für den Satz verwaltet und der später zurückgegeben werden kann, indem get_allocator aufruft.Der Belegungsfunktionsparameter wird häufig in Klassendeklarationen und in den Vorverarbeitungsmakros weggelassen, die verwendet werden, um alternative Belegungsfunktionen zu ersetzen.
Alle Konstruktoren initialisieren ihre Sätze.
Alle Konstruktoren speichern ein Funktionsobjekt des Typs Traits, der verwendet wird, um eine Bestellung unter dem Schlüssel des Satzes zu erstellen und das später zurückgegeben werden kann, indem key_comp aufruft.
Die ersten drei Konstruktoren geben einen leeren Anfangssatz an, der den Typ der zweiten, wenn sie verwendet werden comp Vergleichsfunktion () wird die Reihenfolge der Elemente und der Drittels den verwendet werden Belegungsfunktionstyp (al) explizit angibt herstellen.Das Schlüsselwort explicit unterdrückt bestimmte Arten der automatische Konvertierung.
Der vierte Konstruktor gibt eine Kopie festgelegten right an.
Die folgenden drei Konstruktoren kopieren den Bereich [first, last) eines Satzes bei Erhöhung der Deutlichkeit, wenn sie den Typ der Vergleichsfunktion der Klasse Traits und Allocator angeben.
Der letzte Konstruktor wird eine Kopie des Satzes an, indem er right verschoben wird.
Beispiel
// 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;
}
Das folgende Beispiel zeigt, wie benutzerdefinierte Vergleichsoperatoren verwendet.
#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);
}
Anforderungen
Header: <set>
Namespace: std