set::set

Construye un conjunto que está vacío o que es una copia de todo o parte de algún otro conjunto.

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
);

Parámetros

Comentarios

Todos los constructores almacenan un tipo de objeto del asignador que administra el almacenamiento de memoria para el conjunto y pueda devolver más adelante llamando a get_allocator.El parámetro de asignador se omite en las declaraciones de clase y las macros de preprocesamiento utilizadas para sustituir asignadores alternativos.

Todos los constructores inicializan los conjuntos.

Todos los constructores almacenan un objeto de función de rasgos tipo que se utiliza para establecer una orden entre las claves de conjunto y pueda devolver más adelante llamando a key_comp.

Los primeros tres constructores especifican un conjunto vacío inicial, el segundo especificando el tipo de función de comparación (comp) que se utilizará en el establecimiento del orden de los elementos y el tercero explícitamente que especifica el tipo del asignador (al) que se va a utilizar.La palabra clave explícito suprime ciertos tipos de conversión automática.

el cuarto constructor especifica una copia de rightdeterminado.

Los tres constructores siguientes copian el intervalo [first, last) de un conjunto con la mejora de explicidad en especificar el tipo de función de comparación de la clase rasgos y asignador.

El constructor último especifica una copia del conjunto moviendo right.

Ejemplo

// 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;
}

El ejemplo siguiente se muestra cómo utilizar comparadores personalizados.

#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);
}

Requisitos

encabezado: <conjunto>

espacio de nombres: std

Vea también

Referencia

set Class

Biblioteca de plantillas estándar