set-klass

Containerklassen set C++ Standard Library används för att lagra och hämta data från en samling. Värdena för elementen i set är unika och fungerar som nyckelvärden enligt vilka data sorteras automatiskt. Värdet för ett element i ett set kanske inte ändras direkt. I stället måste du ta bort gamla värden och infoga element med nya värden.

Syntax

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

Parameterar

Key
Den elementdatatyp som ska lagras i uppsättningen.

Traits
Den typ som tillhandahåller ett funktionsobjekt som kan jämföra två elementvärden som sorteringsnycklar för att fastställa deras relativa ordning i uppsättningen. Det här argumentet är valfritt och det binära predikatet less <Key> är standardvärdet.

I C++14 kan du aktivera heterogen sökning genom att ange eller std::less<>std::greater<> predikat som inte har några typparametrar. Mer information finns i Heterogen sökning i associativa containrar .

Allocator
Den typ som representerar det lagrade allokeringsobjektet som kapslar in information om uppsättningens allokering och frigöring av minne. Det här argumentet är valfritt och standardvärdet är allocator<Key>.

Anmärkningar

En C++-standardbiblioteksuppsättning är:

• En associativ container, som en container med variabel storlek som stöder effektiv hämtning av elementvärden baserat på ett associerat nyckelvärde. Dessutom är det en enkel associativ container eftersom dess elementvärden är dess nyckelvärden.

• Reversibel eftersom den tillhandahåller en dubbelriktad iterator för att komma åt dess element.

• Sorterade eftersom dess element sorteras efter nyckelvärden i containern i enlighet med en angiven jämförelsefunktion.

• Unikt i den meningen att vart och ett av dess element måste ha en unik nyckel. Eftersom set också är en enkel associativ container är dess element också unika.

En uppsättning beskrivs också som en klassmall eftersom de funktioner som den tillhandahåller är generiska och oberoende av den specifika typen av data som ingår som element. Den datatyp som ska användas anges i stället som en parameter i klassmallen tillsammans med jämförelsefunktionen och allokeraren.

Valet av containertyp bör i allmänhet baseras på vilken typ av sökning och infogning som krävs av programmet. Associativa containrar är optimerade för åtgärder för sökning, infogning och borttagning. Medlemsfunktionerna som uttryckligen stöder dessa åtgärder är effektiva och gör dem i en tid som i genomsnitt är proportionell mot logaritmen för antalet element i containern. Om element infogas ogiltigförklaras inga iteratorer och om elementen tas bort ogiltigförklaras endast de iteratorer som pekar på de borttagna elementen.

Uppsättningen bör vara den associativa container som ska väljas när villkoren som associerar värdena med deras nycklar uppfylls av programmet. Elementen i en uppsättning är unika och fungerar som egna sorteringsnycklar. En modell för den här typen av struktur är en ordnad lista över till exempel ord där orden bara kan förekomma en gång. Om flera förekomster av orden tilläts skulle en flermängd vara lämplig containerstruktur. Om värden måste kopplas till en lista med unika nyckelord är en karta en lämplig struktur för att innehålla dessa data. Om nycklarna i stället inte är unika är en flerkarta den container som du väljer.

Uppsättningen beställer sekvensen som den styr genom att anropa ett lagrat funktionsobjekt av typen key_compare. Det här lagrade objektet är en jämförelsefunktion som kan nås genom att anropa medlemsfunktionen key_comp. I allmänhet måste elementen bara vara mindre än jämförbara för att fastställa den här ordningen så att det, med tanke på två element, kan fastställas antingen att de är likvärdiga (i den meningen att ingen av dem är mindre än den andra) eller att den ena är mindre än den andra. Detta resulterar i en ordning mellan de icke-nödvändiga elementen. På ett mer tekniskt sätt är jämförelsefunktionen ett binärt predikat som inducerar en strikt svag ordning i standard matematisk mening. Ett binärt predikat f(x,y) är ett funktionsobjekt som har två argumentobjekt x och y och ett returvärde för true eller false. En ordning på en uppsättning är en strikt svag ordning om binärpredikatet är irreflexivt, antisymmetriskt och transitivt och om ekvivalensen är transitiv, där två objekt x och y definieras som likvärdiga när både fx,y) och f(y,x) är falska. Om det starkare villkoret för likhet mellan nycklar ersätter likvärdighetens, blir ordningen total (i den meningen att alla element sorteras med avseende på varandra) och de nycklar som matchas kommer att vara urskiljbara från varandra.

I C++14 kan du aktivera heterogen sökning genom att ange eller std::less<>std::greater<> predikat som inte har några typparametrar. Mer information finns i Heterogen sökning i associativa containrar .

Iteratorn som tillhandahålls av den angivna klassen är en dubbelriktad iterator, men klassmedlemsfunktionerna insert och set har versioner som tar som mallparametrar en svagare indata-iterator, vars funktionskrav är mer minimala än de som garanteras av klassen med dubbelriktade iteratorer. De olika iteratorbegreppen utgör en familj som är relaterad till förbättringar i deras funktioner. Varje iteratorkoncept har en egen uppsättning krav, och de algoritmer som fungerar med dem måste begränsa sina antaganden till de krav som tillhandahålls av den typen av iterator. Det kan antas att en indata-iterator kan derefereras för att referera till ett objekt och att det kan ökas till nästa iterator i sekvensen. Det här är en minimal uppsättning funktioner, men det räcker att kunna tala meningsfullt om en rad iteratorer [ First, Last) i kontexten för klassens medlemsfunktioner.

Konstruktörer

Typedefs

Funktionen

Operatörer

allocator_type

En typ som representerar allokeringsklassen för det angivna objektet.

typedef Allocator allocator_type;

Anmärkningar

allocator_type är synonymt med mallparametern Allocator.

Returnerar det funktionsobjekt som en multimängd använder för att ordna dess element, vilket är mallparametern Allocator.

Mer information om Allocatorfinns i avsnittet Kommentarer i set ämnet Klass .

Exempel

Se exemplet för get_allocator för ett exempel som använder allocator_type.

begin

Returnerar en iterator som adresserar det första elementet i uppsättningen.

const_iterator begin() const;

iterator begin();

Returvärde

En dubbelriktad iterator som adresserar det första elementet i uppsättningen eller platsen som lyckas med en tom uppsättning.

Anmärkningar

Om returvärdet begin för har tilldelats till ett const_iteratorkan elementen i det angivna objektet inte ändras. Om returvärdet begin för har tilldelats till ett iteratorkan elementen i det angivna objektet ändras.

Exempel

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

Returnerar en const iterator som adresserar det första elementet i intervallet.

const_iterator cbegin() const;

Returvärde

En const dubbelriktad iterator som pekar på det första elementet i intervallet, eller platsen precis utanför slutet av ett tomt intervall (för ett tomt intervall, cbegin() == cend()).

Anmärkningar

Med returvärdet för cbeginkan elementen i intervallet inte ändras.

Du kan använda den här medlemsfunktionen i stället för funktionen begin() medlem för att garantera att returvärdet är const_iterator. Vanligtvis används det tillsammans med nyckelordet auto typavdrag, som du ser i följande exempel. I exemplet bör du överväga att Container vara en ändringsbar (icke-const) container av något slag som stöder begin() och cbegin().

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

// i2 is Container<T>::const_iterator

cend

Returnerar en const iterator som adresserar platsen precis utanför det sista elementet i ett intervall.

const_iterator cend() const;

Returvärde

En const iterator med dubbelriktad åtkomst som pekar precis utanför intervallets slut.

Anmärkningar

cend används för att testa om en iterator har passerat slutet av sitt intervall.

Du kan använda den här medlemsfunktionen i stället för funktionen end() medlem för att garantera att returvärdet är const_iterator. Vanligtvis används det tillsammans med nyckelordet auto typavdrag, som du ser i följande exempel. I exemplet bör du överväga att Container vara en ändringsbar (icke-const) container av något slag som stöder end() och cend().

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

// i2 is Container<T>::const_iterator

Värdet som returneras av cend ska inte derefereras.

clear

Raderar alla element i en uppsättning.

void clear();

Exempel

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

En typ som tillhandahåller en dubbelriktad iterator som kan läsa ett const element i uppsättningen.

typedef implementation-defined const_iterator;

Anmärkningar

En typ const_iterator kan inte användas för att ändra värdet för ett element.

Exempel

Se exemplet för begin för ett exempel som använder const_iterator.

const_pointer

En typ som ger en pekare till ett const element i en uppsättning.

typedef typename allocator_type::const_pointer const_pointer;

Anmärkningar

En typ const_pointer kan inte användas för att ändra värdet för ett element.

I de flesta fall bör en const_iterator användas för att komma åt elementen i ett const set-objekt.

const_reference

En typ som ger en referens till ett const element som lagras i en uppsättning för att läsa och utföra const åtgärder.

typedef typename allocator_type::const_reference const_reference;

Exempel

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

En typ som tillhandahåller en dubbelriktad iterator som kan läsa alla const element i uppsättningen.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Anmärkningar

En typ const_reverse_iterator kan inte ändra värdet för ett element och används för att iterera genom uppsättningen i omvänd ordning.

Exempel

Se exemplet för rend ett exempel på hur du deklarerar och använder const_reverse_iterator.

contains

Kontrollera om det finns ett element med den angivna nyckeln i set.

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

Parameterar

K
Typ av nyckel.

key
Elementets nyckelvärde att söka efter.

Returvärde

true om elementet hittas i set, false annars.

Anmärkningar

contains() är nytt i C++20. Om du vill använda den anger du alternativet /std:c++20 eller senare kompilator.

template<class K> bool contains(const K& key) const deltar endast i överbelastningsmatchning om key_compare är transparent. Mer information finns i Heterogen sökning i associativa containrar .

Exempel

// Requires /std:c++20 or later
#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

Returnerar antalet element i en uppsättning vars nyckel matchar en parameter angiven nyckel.

size_type count(const Key& key) const;

Parameterar

key
Nyckeln för de element som ska matchas från uppsättningen.

Returvärde

1 om uppsättningen innehåller ett element vars sorteringsnyckel matchar parameternyckeln. 0 om uppsättningen inte innehåller ett element med en matchande nyckel.

Anmärkningar

Medlemsfunktionen returnerar antalet element i följande intervall:

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

Exempel

I följande exempel visas användningen av set::count medlemsfunktionen.

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

Returnerar en const iterator som adresserar det första elementet i en omvänd uppsättning.

const_reverse_iterator crbegin() const;

Returvärde

En omvänd dubbelriktad iterator som hanterar det första elementet i en omvänd uppsättning eller som hanterar vad som hade varit det sista elementet i den oreverserade uppsättningen.

Anmärkningar

crbegin används med en omvänd uppsättning precis som begin används med en uppsättning.

Med returvärdet crbeginför går det inte att ändra det angivna objektet.

Exempel

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

Returnerar en const iterator som adresserar platsen som lyckas med det sista elementet i en omvänd uppsättning.

const_reverse_iterator crend() const;

Returvärde

En omvänd dubbelriktad iterator som adresserar platsen som lyckades med det sista elementet i en omvänd uppsättning (platsen som hade föregått det första elementet i den oreverserade uppsättningen).

Anmärkningar

crend används med en omvänd uppsättning precis som end används med en uppsättning.

Med returvärdet crendför går det inte att ändra det angivna objektet. Värdet som returneras av crend ska inte derefereras.

crend kan användas för att testa om en omvänd iterator har nått slutet av sin uppsättning.

Exempel

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

En signerad heltalstyp som kan användas för att representera antalet element i en uppsättning i ett intervall mellan element som iteratorer pekar på.

typedef typename allocator_type::difference_type difference_type;

Anmärkningar

difference_type är den typ som returneras när du subtraherar eller ökar genom iteratorer i containern. difference_type Används vanligtvis för att representera antalet element i intervallet [ första, sista) mellan iteratorerna och first, innehåller elementet som pekas på av last och intervallet av element upp till, men inte inklusive, elementet som pekas first på av last.

Även om difference_type det är tillgängligt för alla iteratorer som uppfyller kraven för en indata-iterator, vilket inkluderar klassen av dubbelriktade iteratorer som stöds av reversibla containrar som set, stöds subtraktion mellan iteratorer endast av iteratorer med slumpmässig åtkomst som tillhandahålls av en container med slumpmässig åtkomst, till exempel vektor.

Exempel

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

Infogar ett element som skapats på plats (inga kopierings- eller flyttåtgärder utförs).

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

Parameterar

args
Argumenten som vidarebefordras för att konstruera ett element som ska infogas i uppsättningen såvida det inte redan innehåller ett element vars värde är ordnat på motsvarande sätt.

Returvärde

En pair vars bool-komponent returnerar sant om en insättning gjordes och falskt om kartan redan innehöll ett element vars värde hade ett motsvarande värde i ordningen. Iteratorkomponenten i returvärdeparet returnerar adressen där ett nytt element infogades (om boolkomponenten är sann) eller där elementet redan fanns (om boolkomponenten är false).

Anmärkningar

Inga iteratorer eller referenser har ogiltigförklarats av den här funktionen.

Om ett undantag utlöses under emplacement ändras inte containerns tillstånd.

Exempel

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

Infogar ett element som är konstruerat på plats (inga kopierings- eller flyttåtgärder utförs) med ett placeringstips.

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

Parameterar

args
Argumenten som vidarebefordras för att konstruera ett element som ska infogas i uppsättningen såvida inte uppsättningen redan innehåller elementet eller, mer allmänt, om det inte redan innehåller ett element vars värde är ordnat på motsvarande sätt.

where
Platsen där du vill börja söka efter rätt insättningspunkt. (Om den punkten omedelbart föregår wherekan infogning ske i amorterad konstant tid i stället för logaritmisk tid.)

Returvärde

En iterator till det nyligen infogade elementet.

Om infogningen misslyckades eftersom elementet redan finns returnerar en iterator till det befintliga elementet.

Anmärkningar

Inga iteratorer eller referenser har ogiltigförklarats av den här funktionen.

Om ett undantag utlöses under emplacement ändras inte containerns tillstånd.

Exempel

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

Testar om en uppsättning är tom.

bool empty() const;

Returvärde

true om uppsättningen är tom; false om uppsättningen inte är snål.

Exempel

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

Returnerar iteratorn past-the-end.

const_iterator end() const;

iterator end();

Returvärde

Iteratorn past-the-end. Om uppsättningen är tom, så set::end() == set::begin().

Anmärkningar

end används för att testa om en iterator har passerat slutet av sin uppsättning.

Värdet som returneras av end ska inte derefereras.

Ett kodexempel finns i set::find.

equal_range

Returnerar ett par iteratorer till det första elementet i en uppsättning med en nyckel som är större än eller lika med en angiven nyckel och till det första elementet i uppsättningen med en nyckel som är större än nyckeln.

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

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

Parameterar

key
Argumentnyckeln som ska jämföras med sorteringsnyckeln för ett element från uppsättningen som genomsöks.

Returvärde

Ett par iteratorer där den första är lower_bound nyckelns och den andra är upper_bound nyckelns.

Om du vill komma åt den första iteratorn för ett par pr som returneras av medlemsfunktionen använder du pr. först, och om du vill avreferering av iteratorn med lägre gräns använder du *(pr. först). Om du vill komma åt den andra iteratorn för ett par pr som returneras av medlemsfunktionen använder du pr. second och för att avreferering av den övre bundna iteratorn använder du *(pr. andra).

Exempel

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

Tar bort ett element eller ett område med element i en uppsättning från angivna positioner eller tar bort element som matchar en angiven nyckel.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parameterar

Where
Positionen för elementet som ska tas bort.

First
Positionen för det första elementet som ska tas bort.

Last
Placera precis utanför det sista elementet som ska tas bort.

Key
Nyckelvärdet för de element som ska tas bort.

Returvärde

För de två första medlemsfunktionerna, en dubbelriktad iterator som anger det första elementet som återstår utöver alla element som tas bort, eller ett element som är slutet på uppsättningen om det inte finns något sådant element.

För den tredje medlemsfunktionen returnerar antalet element som har tagits bort från uppsättningen.

Exempel

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

Returnerar en iterator som refererar till platsen för ett element i en uppsättning som har en nyckel som motsvarar en angiven nyckel.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parameterar

key
Nyckelvärdet som ska matchas av sorteringsnyckeln för ett element från uppsättningen som genomsöks.

Returvärde

En iterator som refererar till platsen för ett element med en angiven nyckel, eller platsen som lyckas med det sista elementet i uppsättningen (set::end()) om ingen matchning hittas för nyckeln.

Anmärkningar

Medlemsfunktionen returnerar en iterator som refererar till ett element i uppsättningen vars nyckel motsvarar argumentnyckeln under ett binärt predikat som inducerar en ordning baserat på en relation med mindre än jämförelse.

Om returvärdet find för har tilldelats till ett const_iteratorgår det inte att ändra det angivna objektet. Om returvärdet find för har tilldelats till ett iteratorkan det angivna objektet ändras

Exempel

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

Returnerar en kopia av allokeringsobjektet som används för att konstruera uppsättningen.

allocator_type get_allocator() const;

Returvärde

Allokeraren som används av uppsättningen för att hantera minne, vilket är mallparametern Allocator.

Mer information om Allocatorfinns i avsnittet Kommentarer i set ämnet Klass .

Anmärkningar

Allokerare för den angivna klassen anger hur klassen hanterar lagring. Standardallokeringsprogrammen som levereras med C++ Standard Library-containerklasser räcker för de flesta programmeringsbehov. Att skriva och använda din egen allokeringsklass är ett avancerat C++-ämne.

Exempel

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

infoga

Infogar ett element eller ett område med element i en uppsättning.

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

Parameterar

Val
Värdet för ett element som ska infogas i uppsättningen om det inte redan innehåller ett element vars värde är ordnat på motsvarande sätt.

Where
Platsen där du vill börja söka efter rätt insättningspunkt. (Om den punkten omedelbart föregår Where kan infogning ske i amorterad konstant tid i stället för logaritmisk tid.)

ValTy
Mallparameter som anger den argumenttyp som uppsättningen kan använda för att konstruera ett element i value_type, och perfekt vidarebefordrar Val som ett argument.

First
Positionen för det första element som ska kopieras.

Last
Positionen precis utanför det sista element som ska kopieras.

InputIterator
Mallfunktionsargument som uppfyller kraven för en indata iterator som pekar på element av en typ som kan användas för att konstruera value_type objekt.

IList
Den initializer_list som elementen ska kopieras från.

Returvärde

Medlemsfunktionerna med ett element, (1) och (2), returnerar en pair vars bool komponent är sann om en insättning gjordes och falskt om uppsättningen redan innehåller ett element med motsvarande värde i ordningen. Iteratorkomponenten i retur/värde-paret pekar på det nyligen infogade elementet om komponenten bool är sann eller till det befintliga elementet om komponenten bool är false.

Medlemsfunktionerna single-element-with-hint, (3) och (4), returnerar en iterator som pekar på positionen där det nya elementet infogades i uppsättningen eller, om ett element med motsvarande nyckel redan finns, till det befintliga elementet.

Anmärkningar

Inga iteratorer, pekare eller referenser har ogiltigförklarats av den här funktionen.

Om ett undantag utlöses under infogningen av bara ett element ändras inte containerns tillstånd. Om ett undantag utlöses under införandet av flera element lämnas containern i ett ospecificerat men giltigt tillstånd.

Om du vill komma åt iteratorkomponenten i en pairpr som returneras av medlemsfunktionerna med ett element använder du pr.first; om du vill avrefereras iteratorn i det returnerade paret använder du *pr.first, vilket ger dig ett element. Om du vill komma åt komponenten bool använder du pr.second. Ett exempel finns i exempelkoden senare i den här artikeln.

För value_type en container är en typedef som tillhör containern och, för angivet, set<V>::value_type är typ const V.

Funktionen range member (5) infogar sekvensen med elementvärden i en uppsättning som motsvarar varje element som hanteras av en iterator i intervallet [First, Last). Därför Last infogas inte. Funktionen containermedlem end() refererar till positionen strax efter det sista elementet i containern– till exempel försöker instruktionen s.insert(v.begin(), v.end()); infoga alla element i v i s. Endast element som har unika värden i intervallet infogas. dubbletter ignoreras. Om du vill se vilka element som avvisas använder du enelementsversionerna av insert.

Medlemsfunktionen i initieringslistan (6) använder ett initializer_list för att kopiera element till uppsättningen.

För infogning av ett element som konstruerats på plats, dvs. inga kopierings- eller flyttåtgärder utförs, se set::emplace och set::emplace_hint.

Exempel

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

En typ som ger en konstant dubbelriktad iterator som kan läsa alla element i en uppsättning.

typedef implementation-defined iterator;

Exempel

Se exemplet för begin ett exempel på hur du deklarerar och använder en iterator.

key_comp

Hämtar en kopia av jämförelseobjektet som används för att beställa nycklar i en uppsättning.

key_compare key_comp() const;

Returvärde

Returnerar det funktionsobjekt som en uppsättning använder för att sortera dess element, vilket är mallparametern Traits.

Mer information om Traitsfinns i set avsnittet Klass .

Anmärkningar

Det lagrade objektet definierar medlemsfunktionen:

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

som returnerar true om _xVal föregår och inte är lika med _yVal i sorteringsordningen.

Både key_compare och value_compare är synonymer för mallparametern Traits. Båda typerna tillhandahålls för klasserna set och multiset, där de är identiska, för kompatibilitet med map- och multimap-klasserna, där de är distinkta.

Exempel

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

En typ som tillhandahåller ett funktionsobjekt som kan jämföra två sorteringsnycklar för att fastställa den relativa ordningen för två element i uppsättningen.

typedef Traits key_compare;

Anmärkningar

key_compare är synonymt med mallparametern Traits.

Mer information om Traitsfinns i set avsnittet Klass .

Både key_compare och value_compare är synonymer för mallparametern Traits. Båda typerna tillhandahålls för klasserna set och multiset, där de är identiska, för kompatibilitet med map- och multimap-klasserna, där de är distinkta.

Exempel

Se exemplet för key_comp ett exempel på hur du deklarerar och använder key_compare.

key_type

En typ som beskriver ett objekt som lagras som ett element i en uppsättning i dess kapacitet som sorteringsnyckel.

typedef Key key_type;

Anmärkningar

key_type är synonymt med mallparametern Key.

Mer information om Keyfinns i avsnittet Kommentarer i set ämnet Klass .

Både key_type och value_type är synonymer för mallparametern Key. Båda typerna tillhandahålls för klasserna set och multiset, där de är identiska, för kompatibilitet med map- och multimap-klasserna, där de är distinkta.

Exempel

Se exemplet för value_type ett exempel på hur du deklarerar och använder key_type.

lower_bound

Returnerar en iterator till det första elementet i en uppsättning med en nyckel som är lika med eller större än en angiven nyckel.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Parameterar

key
Argumentnyckeln som ska jämföras med sorteringsnyckeln för ett element från uppsättningen som genomsöks.

Returvärde

En iterator eller const_iterator som adresserar platsen för ett element i en uppsättning som med en nyckel som är lika med eller större än argumentnyckeln eller som adresserar platsen som lyckas med det sista elementet i uppsättningen om ingen matchning hittas för nyckeln.

Exempel

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

Returnerar den maximala längden för uppsättningen.

size_type max_size() const;

Returvärde

Den maximala möjliga längden på uppsättningen.

Exempel

// 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=

Ersätter elementen i detta set med hjälp av element från en annan set.

set& operator=(const set& right);

set& operator=(set&& right);

Parameterar

right
De set nya element som ska tilldelas till den här set.

Anmärkningar

Den första versionen av operator= använder en lvalue-referens för , för rightatt kopiera element från right till den här set.

Den andra versionen använder en rvalue-referens för höger. Den flyttar element från right till den här set.

Alla element i detta set innan operatorfunktionen körs ignoreras.

Exempel

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

En typ som ger en pekare till ett element i en uppsättning.

typedef typename allocator_type::pointer pointer;

Anmärkningar

En typ pointer kan användas för att ändra värdet för ett element.

I de flesta fall bör en iterator användas för att komma åt elementen i ett angivet objekt.

rbegin

Returnerar en iterator som adresserar det första elementet i en omvänd uppsättning.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Returvärde

En omvänd dubbelriktad iterator som adresserar det första elementet i en omvänd uppsättning eller som behandlar vad som hade varit det sista elementet i den oreverserade uppsättningen.

Anmärkningar

rbegin används med en omvänd uppsättning precis som begin används med en uppsättning.

Om returvärdet rbegin för har tilldelats till ett const_reverse_iteratorgår det inte att ändra det angivna objektet. Om returvärdet rbegin för har tilldelats till ett reverse_iteratorkan det angivna objektet ändras.

rbegin kan användas för att iterera genom en uppsättning bakåt.

Exempel

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

En typ som ger en referens till ett element som lagras i en uppsättning.

typedef typename allocator_type::reference reference;

Exempel

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

Returnerar en iterator som adresserar platsen som lyckas med det sista elementet i en omvänd uppsättning.

const_reverse_iterator rend() const;

reverse_iterator rend();

Returvärde

En omvänd dubbelriktad iterator som adresserar platsen som lyckades med det sista elementet i en omvänd uppsättning (platsen som hade föregått det första elementet i den oreverserade uppsättningen).

Anmärkningar

rend används med en omvänd uppsättning precis som end används med en uppsättning.

Om returvärdet rend för har tilldelats till ett const_reverse_iteratorgår det inte att ändra det angivna objektet. Om returvärdet rend för har tilldelats till ett reverse_iteratorkan det angivna objektet ändras. Värdet som returneras av rend ska inte derefereras.

rend kan användas för att testa om en omvänd iterator har nått slutet av sin uppsättning.

Exempel

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

En typ som tillhandahåller en dubbelriktad iterator som kan läsa eller ändra ett element i en omvänd uppsättning.

typedef std::reverse_iterator<iterator> reverse_iterator;

Anmärkningar

En typ reverse_iterator används för att iterera genom uppsättningen i omvänd ordning.

Exempel

Se exemplet för rbegin ett exempel på hur du deklarerar och använder reverse_iterator.

set

Konstruerar en uppsättning som är tom eller som är en kopia av hela eller en del av någon annan uppsättning.

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

Parameterar

Al
Den lagringsallokeringsklass som ska användas för det här angivna objektet, som standard är Allocator.

Comp
Jämförelsefunktionen av typen const Traits som används för att sortera elementen i uppsättningen, som standard är Compare.

Rght
Den uppsättning som den konstruerade uppsättningen ska vara en kopia av.

First
Positionen för det första elementet i området med element som ska kopieras.

Last
Positionen för det första elementet utöver det område av element som ska kopieras.

IList
Den initializer_list som elementen ska kopieras från.

Anmärkningar

Alla konstruktorer lagrar en typ av allokeringsobjekt som hanterar minneslagring för uppsättningen och som senare kan returneras genom att anropa get_allocator. Allokeringsparametern utelämnas ofta i klassdeklarationerna och förbearbetar makron som används för att ersätta alternativa allokerare.

Alla konstruktorer initierar sina uppsättningar.

Alla konstruktorer lagrar ett funktionsobjekt av typen Traits som används för att upprätta en ordning bland nycklarna i uppsättningen och som senare kan returneras genom att anropa key_comp.

De första tre konstruktorerna anger en tom inledande uppsättning, den andra anger vilken typ av jämförelsefunktion (comp) som ska användas för att fastställa ordningen på elementen och den tredje anger uttryckligen den allokeringstyp (al) som ska användas. explicit Nyckelordet utelämnar vissa typer av automatisk typkonvertering.

Den fjärde konstruktorn anger en kopia av uppsättningen right.

De kommande tre konstruktorerna använder en initializer_list för att ange elementen.

De följande tre konstruktorerna kopierar intervallet [ first, last) för en uppsättning med ökad explicititet när du anger typen av jämförelsefunktion för klassen Traits och Allocator.

Den åttonde konstruktorn anger en kopia av uppsättningen genom att flytta right.

Exempel

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

Returnerar antalet element i uppsättningen.

size_type size() const;

Returvärde

Den aktuella längden på uppsättningen.

Exempel

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

En osignerad heltalstyp som kan representera antalet element i en uppsättning.

typedef typename allocator_type::size_type size_type;

Exempel

Se exemplet för size ett exempel på hur du deklarerar och använder size_type

swap

Utbyter elementen i två uppsättningar.

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

Parameterar

right
Argumentuppsättningen som anger de element som ska växlas med måluppsättningen.

Anmärkningar

Medlemsfunktionen ogiltigförklarar inga referenser, pekare eller iteratorer som anger element i de två uppsättningar vars element utbyts.

Exempel

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

Returnerar en iterator till det första elementet i en uppsättning som med en nyckel som är större än en angiven nyckel.

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Parameterar

key
Argumentnyckeln som ska jämföras med sorteringsnyckeln för ett element från uppsättningen som genomsöks.

Returvärde

En iterator eller const_iterator som adresserar platsen för ett element i en uppsättning som med en nyckel som är större än argumentnyckeln, eller som adresserar platsen som lyckas med det sista elementet i uppsättningen om ingen matchning hittas för nyckeln.

Exempel

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

Hämtar en kopia av jämförelseobjektet som används för att sortera elementvärden i en uppsättning.

value_compare value_comp() const;

Returvärde

Returnerar det funktionsobjekt som en uppsättning använder för att sortera dess element, vilket är mallparametern Traits.

Mer information om Traitsfinns i set avsnittet Klass .

Anmärkningar

Det lagrade objektet definierar medlemsfunktionen:

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

som returnerar true om _xVal föregår och inte är lika med _yVal i sorteringsordningen.

Både value_compare och key_compare är synonymer för mallparametern Traits. Båda typerna tillhandahålls för klasserna set och multiset, där de är identiska, för kompatibilitet med map- och multimap-klasserna, där de är distinkta.

Exempel

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

En typ som tillhandahåller ett funktionsobjekt som kan jämföra två elementvärden för att fastställa deras relativa ordning i uppsättningen.

typedef key_compare value_compare;

Anmärkningar

value_compare är synonymt med mallparametern Traits.

Mer information om Traitsfinns i set avsnittet Klass .

Både key_compare och value_compare är synonymer för mallparametern Traits. Båda typerna tillhandahålls för klasserna set och multiset, där de är identiska, för kompatibilitet med map- och multimap-klasserna, där de är distinkta.

Exempel

Se exemplet för value_comp ett exempel på hur du deklarerar och använder value_compare.

value_type

En typ som beskriver ett objekt som lagras som ett element i en uppsättning i dess kapacitet som ett värde.

typedef Key value_type;

Anmärkningar

value_type är synonymt med mallparametern Key.

Mer information om Keyfinns i avsnittet Kommentarer i set ämnet Klass .

Både key_type och value_type är synonymer för mallparametern Key. Båda typerna tillhandahålls för klasserna set och multiset, där de är identiska, för kompatibilitet med map- och multimap-klasserna, där de är distinkta.

Exempel

// 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.