`set` Sınıf

C++ Standart Kitaplığı kapsayıcı sınıfı set , bir koleksiyondaki verileri depolamak ve almak için kullanılır. içindeki set öğelerin değerleri benzersizdir ve verilerin otomatik olarak sıralandığı anahtar değerler olarak görev görür. içindeki bir öğenin set değeri doğrudan değiştirilmeyebilir. Bunun yerine, eski değerleri silmeniz ve yeni değerlere sahip öğeler eklemeniz gerekir.

Sözdizimi

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

Parametreler

Key
Kümede depolanacak öğe veri türü.

Traits
İki öğenin değerlerini kümede kendi göreli sıralarını belirlemek için sıralama anahtarları olarak karşılaştırabilen bir işlev nesnesi sağlayan tür. Bu bağımsız değişken isteğe bağlıdır ve ikili koşul less <Key> varsayılan değerdir.

C++14'te, tür parametresi olmayan veya std::less<> koşulunu std::greater<> belirterek heterojen aramayı etkinleştirebilirsiniz. Daha fazla bilgi için bkz . İlişkili Kapsayıcılarda Heterojen Arama.

Allocator
Kümenin bellek ayırmayı ve ayırmayı kaldırma hakkındaki ayrıntıları içeren saklı ayırıcı nesnesini gösteren tür. Bu bağımsız değişken isteğe bağlıdır ve varsayılan değerdir allocator<Key>.

Açıklamalar

C++ Standart Kitaplığı kümesi:

İlişkili bir anahtar değerine dayalı öğe değerlerinin verimli alınmasını destekleyen bir değişken boyutu kapsayıcı olan ilişkilendirilebilir bir kapsayıcı. Ayrıca, öğe değerleri temel değerleri olduğundan basit bir ilişkilendirici kapsayıcıdır.
Çift yönlüdür, çünkü öğelerine erişmek için çift yönlü bir yineleyici sağlar.
Sıralıdır, çünkü öğeleri belirtilen karşılaştırma işlevine uygun olarak kapsayıcı içindeki anahtar değerlere göre sıralanır.
Benzersizdir, çünkü öğelerinin her birinde benzersiz bir anahtar olması gerekir. Ayrıca, küme basit ilişkilendirilebilir bir kapsayıcı olduğundan, onun da öğeleri benzersizdir.

Sağladığı işlevsellik genel olduğundan ve öğe olarak yer alan belirli veri türünden bağımsız olduğundan, küme de sınıf şablonu olarak tanımlanır. Kullanılacak veri türü, karşılaştırma işlevi ve ayırıcı ile birlikte bir sınıf şablonunda bir parametre olarak belirtilir.

Kapsayıcı türünün seçimi genelde uygulamanın gerektirdiği arama ve ekleme türüne dayalı olmalıdır. İlişkilendirilebilir kapsayıcılar, arama, ekleme ve kaldırma işlemleri için en iyi duruma getirilir. Bu işlemleri açıkça destekleyen üye işlevleri verimlidir ve bunları kapsayıcıdaki öğe sayısının logaritmasıyla ortalama orantılı bir zamanda gerçekleştirir. Öğelerin eklenmesi hiçbir yineleyiciyi geçersiz kılmaz ve öğelerin kaldırılması yalnızca kaldırılan öğeleri işaret eden yineleyicileri geçersiz kılabilir.

Küme, değerleri onların kendi anahtarlarıyla ilişkilendiren koşullar uygulama tarafından karşılandığında seçimin ilişkili kapsayıcısı olmalıdır. Kümenin öğeleri benzersizdir ve kendi sıralama anahtarı olarak hizmet eder. Bu tür bir yapı modeli, sözcüklerin yalnızca bir defa geçebildiği sıralı bir sözcükler listesindedir. Sözcüklerin birden çok defa geçmelerine izin verilirse, bir çoklu küme uygun bir kapsayıcı yapısı olacaktır. Değerlerin benzersiz anahtar sözcükler listesine eklenmesi gerekirse, bir eşlem verileri kapsayacak uygun bir yapı olacaktır. Bunun yerine anahtarlar benzersiz değilse, çok eşlemeli bir kapsayıcı tercih edilebilir.

küme, türündeki key_comparebir saklı işlev nesnesini çağırarak denetlediği sırayı sıralar. Bu depolanan nesne, üye işlevi çağrılarak erişilebilen bir karşılaştırma işlevidir key_comp. Genel olarak, öğelerin bu düzeni oluşturmak için yalnızca karşılaştırılabilirden daha az olması gerekir; böylece, iki öğe göz önüne alındığında, eşdeğer oldukları (diğerinden küçük olmadığı anlamına gelir) veya birinin diğerinden küçük olduğu belirlenebilir. Bu, denk olmayan öğeler arasında bir sıralamaya neden olur. Daha teknik bir not üzerinde, karşılaştırma işlevi standart matematiksel anlamda katı bir zayıf sıralama sevk eden ikili bir koşuldur. İkili koşul f(x,y), x İkili koşul esnek değilse, antisymetrik ve geçişliyse ve denklik geçişliyse, hem f x,y) hem de f(y,x) yanlış olduğunda iki x ve y nesnesinin eşdeğer olarak tanımlandığı kümeye uygulanan sıralama katı bir zayıf sıralamadır. Anahtarlar arasındaki eşitliğinin daha güçlü koşulu bu denkliğin yerini alırsa, sıralama (içindeki tüm öğelerin birbirine göre sıralanması anlamında) toplam haline gelir ve eşleşen anahtarlar birbirinden ayırt edilemez olacaktır.

Set sınıfı tarafından sağlanan yineleyici çift yönlü bir yineleyicidir, ancak sınıf üyesi işlevleri insert ve set şablon parametresi olarak işlev gereksinimleri çift yönlü yineleyiciler sınıfı tarafından garanti edilenden daha düşük olan daha zayıf bir giriş yineleyicisi olarak alan sürümlere sahiptir. Farklı yineleyici kavramları, işlevselliklerindeki iyileştirmelere göre ilgili bir aile biçimlendirir. Her yineleyici kavramının kendi gereksinimler kümesi vardır ve bunlarla çalışan algoritmaların kendi varsayımlarını yineleyici türü tarafından sağlanan gereksinimlerle sınırlaması gerekir. Bir giriş yineleyicinin bazı nesnelere başvurusunun kaldırılacağı ve dizideki sonraki yineleyiciye artırılabileceği varsayılabilir. Bu çok az işlev kümesidir, ancak sınıfın üye işlevleri bağlamında [ First, Last) bir dizi yineleyici hakkında anlamlı bir şekilde konuşabilmek yeterlidir.

Oluşturucular

Veri Akışı Adı	Açıklama
`set`	Boş veya küme öğesinin tümünün veya diğer bir kısmının kopyası olan bir küme oluşturur.

Tür tanımları

Veri Akışı Adı	Açıklama
`allocator_type`	Set nesnesinin sınıfını `allocator` temsil eden bir tür.
`const_iterator`	Kümedeki bir öğeyi okuyabilen çift yönlü bir yineleyici sağlayan tür `const` .
`const_pointer`	Kümedeki bir `const` öğeye işaretçi sağlayan tür.
`const_reference`	Okuma ve işlem yapma `const` için bir kümede depolanan bir öğeye `const` başvuru sağlayan bir tür.
`const_reverse_iterator`	Kümedeki herhangi `const` bir öğeyi okuyabilen çift yönlü bir yineleyici sağlayan tür.
`difference_type`	Yineleyiciler tarafından gösterilen öğeler arasındaki bir aralıktaki küme öğelerinin sayısını temsil etmek için kullanılabilen işaretli bir tamsayı türü.
`iterator`	Küme içindeki herhangi bir öğeyi okuyabilen veya değiştirebilen çift yönlü yineleyiciler sağlayan tür.
`key_compare`	Küme içindeki iki öğenin göreli sırasını belirlemek için iki sıralama anahtarını karşılaştıran bir işlev nesnesi sağlayan bir tür.
`key_type`	Bir sıralama anahtarı olarak kapasitesi dahilinde bir küme öğesi olarak depolanan nesneyi tanımlayan bir tür.
`pointer`	Bir küme içindeki öğeye işaretçi sağlayan bir tür.
`reference`	Küme içinde depolanan öğeye başvuru sağlayan bir tür.
`reverse_iterator`	Ters döndürülmüş küme içindeki bir öğeyi okuyabilen veya değiştirebilen çift yönlü yineleyiciler sağlayan tür.
`size_type`	Küme içindeki öğelerin sayısını temsil edebilen bir işaretsiz tamsayı türü.
`value_compare`	Küme içindeki iki öğenin kendi göreli sıralarını belirlemek için iki öğeyi karşılaştıran bir işlev nesnesi sağlayan bir tür.
`value_type`	Bir değer olarak kapasitesi dahilinde bir küme öğesi şeklinde depolanan nesneyi tanımlayan bir tür.

İşlevler

Veri Akışı Adı	Açıklama
`begin`	içindeki `set`ilk öğeyi ele alan bir yineleyici döndürür.
`cbegin`	içindeki ilk öğeyi `set`ele alan bir sabit yineleyici döndürür.
`cend`	bir içindeki son öğenin başarılı olduğu konumu ele alan bir `set`sabit yineleyici döndürür.
`clear`	öğesinin `set`tüm öğelerini siler.
`contains` ^C++20	içinde `set`belirtilen anahtara sahip bir öğe olup olmadığını denetleyin.
`count`	Anahtarı parametre tarafından belirtilen anahtarla eşleşen bir `set` içindeki öğelerin sayısını döndürür.
`crbegin`	ters çevrilmiş `set`içindeki ilk öğeyi ele alan bir sabit yineleyici döndürür.
`crend`	Ters çevrilmiş `set`bir içindeki son öğeyi başaran konumu ele alan bir sabit yineleyici döndürür.
`emplace`	içine yerinde inşa edilmiş bir `set`öğe ekler.
`emplace_hint`	Bir yerleştirme ipucuyla içine yerinde `set`inşa edilmiş bir öğe ekler.
`empty`	boş `set` olup olmadığını sınar.
`end`	içindeki son öğenin başarılı olduğu konumu ele alan bir `set`yineleyici döndürür.
`equal_range`	Belirtilen anahtardan büyük bir anahtara sahip bir anahtarı olan içindeki ilk öğeye `set` ve anahtara eşit veya daha büyük bir anahtarla içindeki ilk öğeye `set` sırasıyla bir yineleyici çifti döndürür.
`erase`	Küme içindeki bir öğeyi veya öğelerin aralığını belirtilen konumlardan kaldırır veya belirtilen bir anahtarla eşleşen öğeleri kaldırır.
`find`	Belirtilen anahtara eşdeğer bir anahtara sahip bir `set` öğenin konumunu adresleyen bir yineleyici döndürür.
`get_allocator`	oluşturmak için kullanılan nesnesinin `allocator`bir kopyasını `set` döndürür.
`insert`	içine bir öğe veya öğe `set`aralığı ekler.
`key_comp`	içindeki anahtarları sıralamak için kullanılan karşılaştırma nesnesinin bir `set`kopyasını alır.
`lower_bound`	Bir yineleyiciyi belirtilen anahtardan daha büyük veya ona eşit bir anahtarla küme içindeki ilk öğeye döndürür.
`max_size`	değerinin uzunluk üst sınırını `set`döndürür.
`rbegin`	ters çevrilmiş `set`içindeki ilk öğeyi ele alan bir yineleyici döndürür.
`rend`	Ters çevrilmiş `set`bir içindeki son öğeyi başaran konumu ele alan bir yineleyici döndürür.
`size`	içindeki `set`öğe sayısını döndürür.
`swap`	İki `set`öğesinin öğelerini değiştirir.
`upper_bound`	Belirtilen anahtardan büyük bir anahtarla içindeki ilk öğeye `set` bir yineleyici döndürür.
`value_comp`	içindeki öğe değerlerini sıralamak için kullanılan karşılaştırma nesnesinin bir `set`kopyasını alır.

İşleçler

Veri Akışı Adı	Açıklama
`operator=`	Bir kümenin öğelerini başka bir küme kopyasıyla değiştirir.

`allocator_type`

Küme nesnesi için ayırıcı sınıfını temsil eden bir tür.

typedef Allocator allocator_type;

Açıklamalar

allocator_type , şablon parametresinin Allocatoreş anlamlısıdır.

Çok kümeli bir kümenin şablon parametresi Allocatorolan öğelerini sıralamak için kullandığı işlev nesnesini döndürür.

hakkında Allocatordaha fazla bilgi için Sınıfset bakın.

Örnek

kullanan get_allocatorbir örneğin allocator_type örneğine bakın.

`begin`

Küme içindeki ilk öğeyi ele alan bir yineleyici döndürür.

const_iterator begin() const;

iterator begin();

Dönüş Değeri

Kümedeki ilk öğeyi veya boş bir kümenin başarılı olduğu konumu ele alan çift yönlü bir yineleyici.

Açıklamalar

değerinin dönüş değeri begin öğesine const_iteratoratanmışsa, ayarlanan nesnedeki öğeler değiştirilemez. değerinin dönüş değeri begin bir iteratoröğesine atanmışsa, küme nesnesindeki öğeler değiştirilebilir.

Örnek

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

Aralıktaki ilk öğeyi ele alan bir const yineleyici döndürür.

const_iterator cbegin() const;

Dönüş Değeri

Aralığın const ilk öğesini veya boş aralığın sonunun hemen ötesindeki konumu gösteren çift yönlü erişim yineleyicisi (boş aralık için). cbegin() == cend()

Açıklamalar

değerinin cbegindönüş değeriyle, aralıktaki öğeler değiştirilemez.

Dönüş değerinin olduğunu begin()garanti etmek için üye işlevinin const_iterator yerine bu üye işlevini kullanabilirsiniz. Genellikle, aşağıdaki örnekte gösterildiği gibi tür kesinti anahtar sözcüğüyle auto birlikte kullanılır. Örnekte, ve Containerdestekleyen herhangi bir türde const değiştirilebilir (non- begin()) kapsayıcısı olduğunu düşününcbegin().

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

// i2 is Container<T>::const_iterator

`cend`

Bir const aralıktaki son öğenin hemen ötesindeki konumu ele alan bir yineleyici döndürür.

const_iterator cend() const;

Dönüş Değeri

Aralığın const sonunun hemen ötesine işaret eden çift yönlü erişim yineleyicisi.

Açıklamalar

cend bir yineleyicinin aralığının sonunu geçip geçmediğini test etmek için kullanılır.

Dönüş değerinin olduğunu end()garanti etmek için üye işlevinin const_iterator yerine bu üye işlevini kullanabilirsiniz. Genellikle, aşağıdaki örnekte gösterildiği gibi tür kesinti anahtar sözcüğüyle auto birlikte kullanılır. Örnekte, ve Containerdestekleyen herhangi bir türde const değiştirilebilir (non- end()) kapsayıcısı olduğunu düşününcend().

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

// i2 is Container<T>::const_iterator

tarafından cend döndürülen değer başvurulmamalıdır.

`clear`

Bir kümenin tüm öğelerini siler.

void clear();

Örnek

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

Kümedeki bir öğeyi okuyabilen çift yönlü bir yineleyici sağlayan tür const .

typedef implementation-defined const_iterator;

Açıklamalar

Bir öğenin değerini değiştirmek için bir tür const_iterator kullanılamaz.

Örnek

kullanan beginbir örneğin const_iterator örneğine bakın.

`const_pointer`

Kümedeki bir const öğeye işaretçi sağlayan tür.

typedef typename allocator_type::const_pointer const_pointer;

Açıklamalar

Bir öğenin değerini değiştirmek için bir tür const_pointer kullanılamaz.

Çoğu durumda, const const_iterator kümesi nesnesindeki öğelere erişmek için bir kullanılmalıdır.

`const_reference`

Okuma ve işlem yapma const için bir kümede depolanan bir öğeye const başvuru sağlayan bir tür.

typedef typename allocator_type::const_reference const_reference;

Örnek

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

Kümedeki herhangi const bir öğeyi okuyabilen çift yönlü bir yineleyici sağlayan tür.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Açıklamalar

Bir tür const_reverse_iterator bir öğenin değerini değiştiremez ve kümede tersten yinelemek için kullanılır.

Örnek

nasıl bildirilip kullanılacağına ilişkin bir örnek için rend örneğine const_reverse_iteratorbakın.

`contains`

içinde setbelirtilen anahtara sahip bir öğe olup olmadığını denetleyin.

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

Parametreler

K
Anahtarın türü.

key
Aranacak öğenin anahtar değeri.

Dönüş Değeri

true öğesi içinde setbulunursa, false aksi takdirde.

Açıklamalar

contains() C++20 sürümünde yenidir. Bunu kullanmak için veya sonraki derleyici seçeneğini belirtin /std:c++20 .

template<class K> bool contains(const K& key) const yalnızca saydamsa key_compare aşırı yükleme çözümlemeye katılır. Daha fazla bilgi için bkz . İlişkili kapsayıcılarda heterojen arama.

Örnek

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

Anahtarı parametre tarafından belirtilen anahtarla eşleşen küme içindeki öğelerin sayısını döndürür.

size_type count(const Key& key) const;

Parametreler

key
Kümeden eşleştirilecek öğelerin anahtarı.

Dönüş Değeri

Küme, sıralama anahtarı parametre anahtarıyla eşleşen bir öğe içeriyorsa 1. Küme eşleşen anahtara sahip bir öğe içermiyorsa 0.

Açıklamalar

üye işlevi aşağıdaki aralıktaki öğe sayısını döndürür:

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

Örnek

Aşağıdaki örnekte üye işlevinin kullanımı gösterilmektedir set::count .

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

Ters çevrilen kümedeki ilk öğeyi ele alan bir sabit yineleyici döndürür.

const_reverse_iterator crbegin() const;

Dönüş Değeri

Ters çevrilmiş bir kümedeki ilk öğeyi veya ters çevrilmemiş kümedeki son öğeyi ele alan en büyük ters çift yönlü yineleyici.

Açıklamalar

crbegin aynı bir kümede kullanıldığı gibi begin ters çevrilmiş bir kümeyle kullanılır.

değerinin crbegindönüş değeriyle küme nesnesi değiştirilemez.

Örnek

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

Ters çevrilen kümedeki son öğeden sonra gelen konumu ele alan bir sabit yineleyici döndürür.

const_reverse_iterator crend() const;

Dönüş Değeri

Ters çevrilmiş kümedeki son öğeyi (ters çevrilmiş kümedeki ilk öğeden önce gelen konum) başaran konumu ele alan en ters çift yönlü yineleyici.

Açıklamalar

crend aynı bir kümede kullanıldığı gibi end ters çevrilmiş bir kümeyle kullanılır.

değerinin crenddönüş değeriyle küme nesnesi değiştirilemez. tarafından crend döndürülen değer başvurulmamalıdır.

crend bir ters yineleyicinin kümesinin sonuna ulaşıp ulaşmadığını test etmek için kullanılabilir.

Örnek

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

Yineleyiciler tarafından gösterilen öğeler arasındaki bir aralıktaki küme öğelerinin sayısını temsil etmek için kullanılabilen işaretli bir tamsayı türü.

typedef typename allocator_type::difference_type difference_type;

Açıklamalar

difference_type, kapsayıcının yineleyicileri çıkarılırken veya artırılırken döndürülen türdür. difference_type genellikle yineleyiciler ile firstarasındaki [ ilk, son)lastöğe sayısını temsil etmek için first kullanılır; tarafından işaret edilen öğeyi ve ile işaret edilen lastöğeyi dahil etmek için değil, öğesine kadar olan öğe aralığını içerir.

Küme gibi geri alınabilir kapsayıcılar tarafından desteklenen çift yönlü yineleyici sınıfını içeren bir giriş yineleyicisinin gereksinimlerini karşılayan tüm yineleyiciler için kullanılabilir olsa difference_type da, yineleyiciler arasındaki çıkarma yalnızca vektör gibi rastgele erişim kapsayıcısı tarafından sağlanan rastgele erişim yineleyicileri tarafından desteklenir.

Örnek

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

Yerinde derlenmiş bir öğe ekler (kopyalama veya taşıma işlemi yapılmaz).

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

Parametreler

args
Değeri eşdeğer sıralanmış bir öğe içermediği sürece kümeye eklenecek bir öğe oluşturmak için iletilen bağımsız değişkenler.

Dönüş Değeri

Ekleme pair yapıldığında bool bileşeni true, eşlemede değeri sıralamada eşdeğer bir değere sahip bir öğe varsa false değeri döndürülür. Dönüş değeri çiftinin yineleyici bileşeni, yeni bir öğenin eklendiği adresi (bool bileşeni true ise) veya öğenin zaten bulunduğu adresi (bool bileşeni false ise) döndürür.

Açıklamalar

Bu işlev tarafından hiçbir yineleyici veya başvuru geçersiz kılınmamış.

Yer değiştirme sırasında özel durum oluşursa kapsayıcının durumu değiştirilmez.

Örnek

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

Yerleştirme ipucuyla yerinde (hiçbir kopyalama veya taşıma işlemi gerçekleştirilmemiş) bir öğe ekler.

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

Parametreler

args
Küme zaten bu öğeyi içermiyorsa kümeye eklenecek bir öğe oluşturmak için iletilen bağımsız değişkenler veya daha genel olarak, değeri eşdeğer olarak sıralanmış bir öğe içermiyorsa.

where
Doğru ekleme noktasını aramaya başlanması gereken yer. (Bu nokta hemen önüne wheregeçerse ekleme işlemi logaritmik saat yerine amorti edilmiş sabit sürede gerçekleşebilir.)

Dönüş Değeri

Yeni eklenen öğeye bir yineleyici.

Öğe zaten var olduğundan ekleme başarısız olduysa, var olan öğeye bir yineleyici döndürür.

Açıklamalar

Bu işlev tarafından hiçbir yineleyici veya başvuru geçersiz kılınmamış.

Yer değiştirme sırasında özel durum oluşursa kapsayıcının durumu değiştirilmez.

Örnek

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

Kümenin boş olup olmadığını sınar.

bool empty() const;

Dönüş Değeri

true küme boşsa; false ayarı boşsa.

Örnek

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

past-the-end yineleyici döndürür.

const_iterator end() const;

iterator end();

Dönüş Değeri

Son zaman yineleyicisi. Küme boşsa, öğesini seçin set::end() == set::begin().

Açıklamalar

end bir yineleyicinin kümesinin sonunu geçip geçmediğini test etmek için kullanılır.

tarafından end döndürülen değer başvurulmamalıdır.

Kod örneği için bkz set::find. .

`equal_range`

Kümedeki belirtilen anahtardan büyük veya buna eşit bir anahtara sahip ilk öğeye ve anahtardan büyük bir anahtarla kümedeki ilk öğeye sırasıyla bir yineleyici çifti döndürür.

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

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

Parametreler

key
Aranmakta olan kümedeki bir öğenin sıralama anahtarıyla karşılaştırılacak bağımsız değişken anahtarı.

Dönüş Değeri

Birincisi lower_bound anahtarın, ikincisi upper_bound anahtarın olduğu bir çift yineleyici.

Üye işlevi tarafından döndürülen bir çiftin pr ilk yineleyicisine erişmek için kullanın pr. önce ve alt sınır yineleyicisini geri almak için *(pr kullanın. önce). Üye işlevi tarafından döndürülen bir çiftin pr ikinci yineleyicisine erişmek için kullanın pr. ikinci ve üst sınır yineleyicisini geri almak için *(pr kullanın. saniye).

Örnek

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

Küme içindeki bir öğeyi veya öğelerin aralığını belirtilen konumlardan kaldırır veya belirtilen bir anahtarla eşleşen öğeleri kaldırır.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parametreler

Where
Kaldırılacak öğenin konumu.

First
Kaldırılacak ilk öğenin konumu.

Last
Kaldırılacak son öğenin hemen ötesinde konumlandırın.

Key
Kaldırılacak öğelerin anahtar değeri.

Dönüş Değeri

İlk iki üye işlevi için, kaldırılan öğelerin ötesinde kalan ilk öğeyi belirleyen çift yönlü bir yineleyici veya böyle bir öğe yoksa kümenin sonu olan bir öğe.

Üçüncü üye işlevi için, kümeden kaldırılan öğelerin sayısını döndürür.

Örnek

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

Belirtilen anahtara eşdeğer bir anahtara sahip bir kümedeki öğenin konumuna başvuran bir yineleyici döndürür.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametreler

key
Aranmakta olan kümedeki bir öğenin sıralama anahtarıyla eşleştirilecek anahtar değeri.

Dönüş Değeri

Belirtilen anahtara sahip bir öğenin konumuna veya anahtar için eşleşme bulunamazsa kümedeki (set::end()) son öğenin başarılı olduğu konuma başvuran bir yineleyici.

Açıklamalar

Üye işlevi, kümedeki bağımsız değişken anahtarına eşit bir anahtara sahip öğeye işaret eden bir yineleyici döndürür. Böyle bir öğe yoksa işlevi döndürür end(). Karşılaştırma, küçüktür sıralama ilişkisine dayalı bir ikili koşul kullanır.

değerinin dönüş değeri find bir const_iteratoröğesine atanmışsa, küme nesnesi değiştirilemez. değerinin dönüş değeri find bir iteratoröğesine atanmışsa, küme nesnesi değiştirilebilir.

set::find() örneği

// compile with: /EHsc /W4 /MTd
#include <set>
#include <iostream>

using namespace std;  // std c++ libs implemented in std

void main()
{
	set<int, less<int>, allocator<int>> s1{5, 8, 12};

	// find() returns an iterator that points to the first element
	// that has the same key as the value passed to the find function.
	// If no such element exists, the iterator equals end().

	set<int, less<int>, allocator<int>>::iterator it;

	// Is 8 in the set?
	it = s1.find(8);
	if (it != s1.end())
	{
		cout << "Found 8" << endl;
	}
	else
	{
		cout << "Didn't find 8" << endl;
	}

	// Is 6 in the set?
	it = s1.find(6);
	if (it != s1.end())
	{
		cout << "Found 6" << endl;
	}
	else
	{
		cout << "Didn't find 6" << endl;
	}
}

Found 8
Didn't find 6

`get_allocator`

Kümeyi oluşturmak için kullanılan ayırıcı nesnesinin bir kopyasını döndürür.

allocator_type get_allocator() const;

Dönüş Değeri

Şablon parametresi Allocatorolan belleği yönetmek için kümesi tarafından kullanılan ayırıcı.

hakkında Allocatordaha fazla bilgi için Sınıfset bakın.

Açıklamalar

Küme sınıfı için ayırıcılar, sınıfın depolamayı nasıl yöneteceğini belirtir. C++ Standart Kitaplığı kapsayıcı sınıfları ile sağlanan varsayılan ayırıcılar çoğu programlama gereksinimi için yeterlidir. Kendi ayırıcı sınıfınızı yazmak ve kullanmak gelişmiş bir C++ konusudur.

Örnek

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

ekle

Bir küme içine bir öğe veya öğe aralığı ekler.

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

Parametreler

Val
Değeri eşdeğer olarak sıralanmış bir öğe içermediği sürece kümeye eklenecek öğenin değeri.

Where
Doğru ekleme noktasını aramaya başlanması gereken yer. (Bu nokta hemen önceyse Burada ekleme işlemi logaritmik saat yerine amorti edilmiş sabit sürede gerçekleşebilir.)

ValTy
Kümenin öğesini value_typeoluşturmak için kullanabileceği bağımsız değişken türünü belirten şablon parametresi ve Val'i bağımsız değişken olarak mükemmel iletir.

First
Kopyalanacak ilk öğenin konumu.

Last
Kopyalanacak son öğenin hemen ötesindeki konum.

InputIterator
Nesne oluşturmak için kullanılabilecek bir value_type gereksinimlerini karşılayan şablon işlevi bağımsız değişkeni.

IList
initializer_list Öğelerin kopyalandığı yer.

Dönüş Değeri

Tek öğeli üye işlevleri (1) ve (2), ekleme yapıldığında bileşeni true olan pair birbool, küme sıralamada eşdeğer değere sahip bir öğe içeriyorsa false döndürür. Dönüş-değer çiftinin yineleyici bileşeni, bileşen true ise bool yeni eklenen öğeye veya bileşen false ise var olan öğeye bool işaret eder.

İpucuyla tek öğeli üye işlevleri (3) ve (4), yeni öğenin kümeye eklendiği konumu veya eşdeğer anahtara sahip bir öğe zaten varsa mevcut öğeye işaret eden bir yineleyici döndürür.

Açıklamalar

Bu işlev tarafından hiçbir yineleyici, işaretçi veya başvuru geçersiz kılınmamış.

Yalnızca bir öğenin eklenmesi sırasında özel durum oluşursa kapsayıcının durumu değiştirilmez. Birden çok öğe eklenirken, bir özel durum oluşturulursa kapsayıcı belirtilmemiş ancak geçerli bir durumda bırakılır.

Tek öğeli üye işlevleri tarafından döndürülen bir pairpr öğesinin yineleyici bileşenine erişmek için , öğesini kullanarak pr.firstdöndürülen çift içinde yineleyiciye başvuruyu kaldırın, kullanın *pr.firstve size bir öğe sağlayın. Bileşene bool erişmek için kullanın pr.second. Örnek için bu makalenin devamında yer alan örnek koda bakın.

value_type Kapsayıcının türü, kapsayıcıya ait olan bir tür tanımıdır ve küme set<V>::value_type için türüdürconst V.

Aralık üye işlevi (5), öğe değerlerinin sırasını aralıktaki [First, Last)bir yineleyici tarafından ele alınan her öğeye karşılık gelen bir kümeye ekler; bu nedenle eklenmez Last . Kapsayıcı üyesi işlevi end() , kapsayıcıdaki son öğeden hemen sonraki konuma başvurur; örneğin, deyimi s.insert(v.begin(), v.end()); tüm öğelerini v içine seklemeye çalışır. Yalnızca aralıkta benzersiz değerlere sahip öğeler eklenir; yinelenenler yoksayılır. Hangi öğelerin reddedildiğini gözlemlemek için öğesinin tek öğeli sürümlerini insertkullanın.

Başlatıcı listesi üye işlevi (6), öğeleri kümeye kopyalamak için bir initializer_list kullanır.

Yerinde inşa edilmiş bir öğenin eklenmesi için (başka bir deyişle, hiçbir kopyalama veya taşıma işlemi gerçekleştirilmez), bkz set::emplace . ve set::emplace_hint.

Örnek

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

Bir kümedeki herhangi bir öğeyi okuyabilen sabit bir çift yönlü yineleyici sağlayan tür.

typedef implementation-defined iterator;

Örnek

bir bildirme ve kullanma beginörneği için iterator örneğine bakın.

`key_comp`

Bir küme içindeki anahtarları sıralamak için kullanılan karşılaştırma nesnesinin bir kopyasını alır.

key_compare key_comp() const;

Dönüş Değeri

Bir kümenin şablon parametresi Traitsolan öğelerini sıralamak için kullandığı işlev nesnesini döndürür.

hakkında Traitsdaha fazla bilgi için Sınıfset bakın.

Açıklamalar

Depolanan nesne üye işlevini tanımlar:

bool işleci()(const Key&

true _xVal döndürür ve sıralama düzeninde bu değere _yVal eşit değildir.

Hem hem key_compare devalue_compare, şablon parametresinin Traitseş anlamlılarıdır. Her iki tür de aynı olan küme ve çok kümeli sınıflar için, eşleme ve çok eşlemeli sınıflarla uyumluluk için sağlanır ve burada ayrıdırlar.

Örnek

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

Küme içindeki iki öğenin göreli sırasını belirlemek için iki sıralama anahtarını karşılaştıran bir işlev nesnesi sağlayan bir tür.

typedef Traits key_compare;

Açıklamalar

key_compare , şablon parametresinin Traitseş anlamlısıdır.

hakkında Traitsdaha fazla bilgi için Sınıfset bakın.

Örnek

bildirme ve kullanma key_compörneği için key_compare örneğine bakın.

`key_type`

Kapasitedeki bir kümenin öğesi olarak depolanan bir nesneyi sıralama anahtarı olarak tanımlayan tür.

typedef Key key_type;

Açıklamalar

key_type , şablon parametresinin Keyeş anlamlısıdır.

hakkında Keydaha fazla bilgi için Sınıfset bakın.

Hem hem key_type devalue_type, şablon parametresinin Keyeş anlamlılarıdır. Her iki tür de aynı olan küme ve çok kümeli sınıflar için, eşleme ve çok eşlemeli sınıflarla uyumluluk için sağlanır ve burada ayrıdırlar.

Örnek

bildirme ve kullanma value_typeörneği için key_type örneğine bakın.

`lower_bound`

Bir yineleyiciyi belirtilen anahtardan daha büyük veya ona eşit bir anahtarla küme içindeki ilk öğeye döndürür.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Parametreler

key
Aranmakta olan kümedeki bir öğenin sıralama anahtarıyla karşılaştırılacak bağımsız değişken anahtarı.

Dönüş Değeri

Bir yineleyici veya const_iterator bir öğenin konumunu, bağımsız değişken anahtarına eşit veya ondan büyük bir anahtarla ya da anahtar için eşleşme bulunamazsa kümedeki son öğeyi başarılı olan konumu ele alan bir kümede ele alır.

Örnek

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

Küme öğesinin maksimum uzunluğunu döndürür.

size_type max_size() const;

Dönüş Değeri

Kümenin mümkün olan en uzun uzunluğu.

Örnek

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

Bunun set öğelerini başka bir setöğesindeki öğeleri kullanarak değiştirir.

set& operator=(const set& right);

set& operator=(set&& right);

Parametreler

right
Bu setsetöğesine atanacak yeni öğeler sağlayan.

Açıklamalar

öğesinin operator= ilk sürümü, öğesinden bu rightöğesine öğe kopyalamak için için rightbir set kullanır.

İkinci sürümde sağ için bir rvalue başvurusu kullanılır. Öğeleri öğesinden right bu setöğesine taşır.

İşleç işlevi yürütülmeden önce bu set öğedeki tüm öğeler atılır.

Örnek

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

Bir küme içindeki öğeye işaretçi sağlayan bir tür.

typedef typename allocator_type::pointer pointer;

Açıklamalar

Bir öğenin değerini değiştirmek için bir tür pointer kullanılabilir.

Çoğu durumda, iterator bir küme nesnesindeki öğelere erişmek için kullanılmalıdır.

`rbegin`

Ters çevrilen küme içindeki ilk öğeyi ele alan bir yineleyici döndürür.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Dönüş Değeri

Ters çevrilmiş kümedeki ilk öğeyi veya ters çevrilmemiş kümedeki son öğeyi ele alan ters çift yönlü yineleyici.

Açıklamalar

rbegin aynı bir kümede kullanıldığı gibi begin ters çevrilmiş bir kümeyle kullanılır.

değerinin dönüş değeri rbegin öğesine const_reverse_iteratoratanmışsa, küme nesnesi değiştirilemez. değerinin dönüş değeri rbegin öğesine reverse_iteratoratanmışsa, küme nesnesi değiştirilebilir.

rbegin bir kümeyi geriye doğru yinelemek için kullanılabilir.

Örnek

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

Küme içinde depolanan öğeye başvuru sağlayan bir tür.

typedef typename allocator_type::reference reference;

Örnek

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

Ters çevrilen küme içindeki son öğeden sonra gelen konumu ele alan bir yineleyici döndürür.

const_reverse_iterator rend() const;

reverse_iterator rend();

Dönüş Değeri

Ters çevrilmiş bir kümedeki son öğeyi (ters çevrilmemiş kümedeki ilk öğeden önce gelen konum) başarılı olan konumu ele alan ters çift yönlü yineleyici.

Açıklamalar

rend aynı bir kümede kullanıldığı gibi end ters çevrilmiş bir kümeyle kullanılır.

değerinin dönüş değeri rend öğesine const_reverse_iteratoratanmışsa, küme nesnesi değiştirilemez. değerinin dönüş değeri rend öğesine reverse_iteratoratanmışsa, küme nesnesi değiştirilebilir. tarafından rend döndürülen değer başvurulmamalıdır.

rend bir ters yineleyicinin kümesinin sonuna ulaşıp ulaşmadığını test etmek için kullanılabilir.

Örnek

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

Ters döndürülmüş küme içindeki bir öğeyi okuyabilen veya değiştirebilen çift yönlü yineleyiciler sağlayan tür.

typedef std::reverse_iterator<iterator> reverse_iterator;

Açıklamalar

Bir tür reverse_iterator , kümeyi tersten yinelemek için kullanılır.

Örnek

bildirme ve kullanma rbeginörneği için reverse_iterator örneğine bakın.

`set`

Boş veya küme öğesinin tümünün veya diğer bir kısmının kopyası olan bir küme oluşturur.

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

Parametreler

Al
Varsayılan olarak Allocatordeğerine sahip olan bu küme nesnesi için kullanılacak depolama ayırıcı sınıfı.

Comp
Kümedeki öğeleri sıralamak için kullanılan ve varsayılan olarak const Traitsdeğerine sahip olan türünde Compare karşılaştırma işlevi.

Rght
Oluşturulacak kümenin bir kopya olması gerekir.

First
Kopyalanacak öğe aralığındaki ilk öğenin konumu.

Last
Kopyalanacak öğe aralığının ötesindeki ilk öğenin konumu.

IList
Öğelerin kopyalanacağı initializer_list.

Açıklamalar

Tüm oluşturucular, kümesi için bellek depolamasını yöneten ve daha sonra çağrılarak get_allocatordöndürülebilen bir ayırıcı nesne türü depolar. Ayırıcı parametresi genellikle sınıf bildirimlerinde ve alternatif ayırıcıları değiştirmek için kullanılan önişlem makrolarında atlanır.

Tüm oluşturucular kümelerini başlatır.

Tüm oluşturucular, kümesinin anahtarları arasında bir sıra oluşturmak için kullanılan ve daha sonra çağrılarak Traitsdöndürülebilecek türde key_comp bir işlev nesnesi depolar.

İlk üç oluşturucu boş bir başlangıç kümesi, ikincisi öğelerin sırasını oluştururken kullanılacak karşılaştırma işlevinin türünü (comp) ve kullanılacak ayırıcı türünü (al) açıkça belirten üçüncü bir küme belirtir. anahtar sözcüğü explicit belirli türdeki otomatik tür dönüştürmelerini gizler.

Dördüncü oluşturucu, kümesinin rightbir kopyasını belirtir.

Sonraki üç oluşturucu, öğeleri belirtmek için bir initializer_list kullanır.

Sonraki üç oluşturucu, ve sınıfının firstlast karşılaştırma işlevinin türünü belirtirken açıklığı artan bir kümenin [ Traits, Allocator) aralığını kopyalar.

Sekizinci oluşturucu, öğesini taşıyarak rightkümenin bir kopyasını belirtir.

Örnek

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

Kümedeki öğelerin sayısını döndürür.

size_type size() const;

Dönüş Değeri

Kümenin geçerli uzunluğu.

Örnek

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

Küme içindeki öğelerin sayısını temsil edebilen bir işaretsiz tamsayı türü.

typedef typename allocator_type::size_type size_type;

Örnek

Nasıl bildirilip kullanılacağına ilişkin bir örnek için size örneğine bakın size_type

`swap`

İki kümenin öğelerini birbiriyle değiştirir.

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

Parametreler

right
Hedef kümeyle değiştirilecek öğeleri sağlayan bağımsız değişken kümesi.

Açıklamalar

Üye işlevi, öğeleri değiştirilmekte olan iki kümedeki öğeleri belirleyen hiçbir başvuruyu, işaretçiyi veya yineleyiciyi geçersiz kılmaz.

Örnek

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

Belirtilen anahtardan büyük bir anahtarla kümedeki ilk öğeye bir yineleyici döndürür.

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Parametreler

key
Aranmakta olan kümedeki bir öğenin sıralama anahtarıyla karşılaştırılacak bağımsız değişken anahtarı.

Dönüş Değeri

Bir iterator kümedeki bir öğenin konumunu, bağımsız değişken anahtarından daha büyük bir anahtarla veya anahtar için eşleşme bulunamazsa kümedeki son öğeyi tamamlayan konumu ele alan bir veya const_iterator .

Örnek

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

Küme içindeki öğe değerlerini sıralamak için kullanılan karşılaştırma nesnesinin bir kopyasını alır.

value_compare value_comp() const;

Dönüş Değeri

Bir kümenin şablon parametresi Traitsolan öğelerini sıralamak için kullandığı işlev nesnesini döndürür.

hakkında Traitsdaha fazla bilgi için Sınıfset bakın.

Açıklamalar

Depolanan nesne üye işlevini tanımlar:

bool işleci(const Key&

true _xVal döndürür ve sıralama düzeninde bu değere _yVal eşit değildir.

Hem hem value_compare dekey_compare, şablon parametresinin Traitseş anlamlılarıdır. Her iki tür de aynı olan küme ve çok kümeli sınıflar için, eşleme ve çok eşlemeli sınıflarla uyumluluk için sağlanır ve burada ayrıdırlar.

Örnek

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

Kümedeki göreli sırasını belirlemek için iki öğe değerini karşılaştırabilen bir işlev nesnesi sağlayan tür.

typedef key_compare value_compare;

Açıklamalar

value_compare , şablon parametresinin Traitseş anlamlısıdır.

hakkında Traitsdaha fazla bilgi için Sınıfset bakın.

Örnek

bildirme ve kullanma value_compörneği için value_compare örneğine bakın.

`value_type`

Kapasitede bir kümenin öğesi olarak depolanan bir nesneyi değer olarak tanımlayan tür.

typedef Key value_type;

Açıklamalar

value_type , şablon parametresinin Keyeş anlamlısıdır.

hakkında Keydaha fazla bilgi için Sınıfset bakın.

Örnek

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

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-11-07

Aracılığıyla paylaş

set Sınıf

Sözdizimi

Parametreler

Açıklamalar

Oluşturucular

Tür tanımları

İşlevler

İşleçler

allocator_type

Açıklamalar

Örnek

begin

Dönüş Değeri

Açıklamalar

Örnek

cbegin

Dönüş Değeri

Açıklamalar

cend

Dönüş Değeri

Açıklamalar

clear

Örnek

const_iterator

Açıklamalar

Örnek

const_pointer

Açıklamalar

const_reference

Örnek

const_reverse_iterator

Açıklamalar

Örnek

contains

Parametreler

Dönüş Değeri

Açıklamalar

Örnek

count

Parametreler

Dönüş Değeri

Açıklamalar

Örnek

crbegin

Dönüş Değeri

Açıklamalar

Örnek

crend

Dönüş Değeri

Açıklamalar

Örnek

difference_type

Açıklamalar

Örnek

emplace

Parametreler

Dönüş Değeri

Açıklamalar

Örnek

emplace_hint

Parametreler

Dönüş Değeri

Açıklamalar

Örnek

empty

Dönüş Değeri

Örnek

end

Dönüş Değeri

Açıklamalar

equal_range

Parametreler

Dönüş Değeri

Örnek

erase

Parametreler

Dönüş Değeri

Örnek

find

`set` Sınıf

`allocator_type`

`begin`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`contains`

`count`

`crbegin`

`crend`

`difference_type`

`emplace`

`emplace_hint`

`empty`

`end`

`equal_range`

`erase`

`find`

`get_allocator`

`iterator`

`key_comp`

`key_compare`

`key_type`

`lower_bound`

`max_size`

`operator=`

`pointer`

`rbegin`

`reference`

`rend`

`reverse_iterator`

`set`

`size`

`size_type`

`swap`

`upper_bound`

`value_comp`