hash_set Sınıfı

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Kapsayıcı sınıfı hash_set, C++ Standart Kitaplığı'nın bir uzantısıdır ve içerdiği öğelerin değerlerinin benzersiz olduğu ve anahtar değerleri olarak görev aldığı bir koleksiyondan verilerin depolanması ve hızlı alınması için kullanılır.

Sözdizimi

template <class Key,
    class Traits=hash_compare<Key, less<Key>>,
    class Allocator=allocator<Key>>
class hash_set

Parametreler

Anahtar
hash_set depolanacak öğe veri türü.

Özellik
İki işlev nesnesi içeren tür, sınıfından biri, iki öğe değerini sıralama anahtarları olarak karşılaştırarak göreli düzenlerini belirlemek için iki öğe değerini karşılaştırabilen ve öğelerin birli koşul eşleme anahtar değerlerini türündeki işaretsiz tamsayılara eşleyen bir karma işlevi olan türü size_tkarşılaştırır. Bu bağımsız değişken isteğe bağlıdır ve hash_compare<Key, less<Key> > varsayılan değerdir.

Ayırıcı
hash_set ayırması ve belleği serbest bırakması hakkındaki ayrıntıları kapsülleyen depolanmış ayırıcı nesnesini temsil eden tür. Bu bağımsız değişken isteğe bağlıdır ve varsayılan değerdir allocator<Key>.

Açıklamalar

hash_set:

İ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ı. Dahası, basit bir ilişkilendirilebilir kapsayıcıdır, çünkü öğelerinin değerleri kendi anahtar değerleridir.
Çift yönlüdür, çünkü öğelerine erişmek için çift yönlü bir yineleyici sağlar.
Karma, çünkü öğeleri öğelerinin anahtar değerlerine uygulanan bir karma işlevinin değerine göre demetler halinde gruplandırılır.
Benzersizdir, çünkü öğelerinin her birinde benzersiz bir anahtar olması gerekir. hash_set aynı zamanda basit bir ilişkilendirici kapsayıcı olduğundan, öğeleri de benzersizdir.
Sağladığı işlevsellik genel olduğundan ve öğe veya anahtar olarak yer alan belirli veri türünden bağımsız olduğundan sınıf şablonu. Öğeler ve anahtarlar için kullanılacak veri türleri, karşılaştırma işlevi ve ayırıcı ile birlikte bir sınıf şablonunda parametreler olarak belirtilir.

Sıralamaya göre karma oluşturmanın temel avantajı daha yüksek verimliliktir; başarılı bir karma ekleme, silme işlemleri gerçekleştirir ve sıralama teknikleri için kapsayıcıdaki öğe sayısının logaritmasıyla orantılı bir süreyle karşılaştırıldığında sabit ortalama süre bulur. Bir kümedeki bir öğenin değeri doğrudan değiştirilemez. Bunun yerine, eski değerleri silmeniz ve yeni değerlere sahip öğeler eklemeniz gerekir.

Kapsayıcı türünün seçimi genelde uygulamanın gerektirdiği arama ve ekleme türüne dayalı olmalıdır. Karma ilişkilendirme kapsayıcıları arama, ekleme ve kaldırma işlemleri için iyileştirilmiştir. Bu işlemleri açıkça destekleyen üye işlevleri, iyi tasarlanmış bir karma işleviyle kullanıldığında verimlidir ve bunları ortalama sabit olan ve kapsayıcıdaki öğe sayısına bağımlı olmayan bir zamanda gerçekleştirir. İyi tasarlanmış bir karma işlevi, karma değerlerin tekdüzen bir dağılımını oluşturur ve çakışma sayısını en aza indirir. Burada, farklı anahtar değerleri aynı karma değere eşlendiğinde çakışma olduğu söylenir. En kötü durumda, mümkün olan en kötü karma işleviyle, işlem sayısı dizideki öğe sayısıyla orantılıdır (doğrusal süre).

Değerleri anahtarlarıyla ilişkilendiren koşullar uygulama tarafından karşılandığında, hash_set tercih edilen ilişkilendirilebilir kapsayıcı olmalıdır. Bir hash_set öğeleri benzersizdir ve kendi sıralama anahtarları olarak görev görür. 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 örneğine izin verilseydi, hash_multiset uygun kapsayıcı yapısı olurdu. Değerlerin benzersiz anahtar sözcükler listesine eklenmesi gerekiyorsa, hash_map bu verileri içerecek uygun bir yapı olabilir. Bunun yerine anahtarlar benzersiz değilse, bir hash_multimap tercih edilir.

hash_set, value_compareTraitsbir depolanmış karma nesnesi çağırarak denetlediği sırayı sıralar. Bu depolanan nesneye üye işlevi key_comp çağrılarak erişilebilir. Böyle bir işlev nesnesi, daha az<Anahtar<> hash_compare>sınıfının nesnesiyle aynı şekilde davranmalıdır. Özellikle, Key türündeki tüm değerler key için Trait(key) çağrısı size_t türündeki değerlerin dağılımını verir.

Genelde, bu sıralamayı oluşturmak için öğelerin yalnızca küçüktür biçiminde karşılaştırılabilir olması gerekir; böylece, herhangi iki öğe belirtildiğinde, eşit oldukları (yani birinin diğerinden daha küçük olmadığı anlamında) veya birinin diğerinden küçük olduğu belirlenebilir. Bu, eşdeğer 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) iki bağımsız değişken nesnesi x ve y ile true veya false dönüş değerine sahip bir işlev nesnesidir. bir hash_set uygulanan sıralama, ikili koşulun esnek olmayan, antisymetrik ve geçişli olması ve denkliğin geçişli olması durumunda, hem f( x, y) hem de f( y, x) yanlış olduğunda iki x ve y nesnesinin eşdeğer olarak tanımlandığı 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.

Denetlenen dizideki öğelerin gerçek sırası karma işlevine, sıralama işlevine ve kapsayıcı nesnesinde depolanan karma tablosunun geçerli boyutuna bağlıdır. Karma tablosunun geçerli boyutunu belirleyemezsiniz, bu nedenle denetimli dizideki öğelerin sırasını genel olarak tahmin edemezsiniz. Öğelerin eklenmesi hiçbir yineleyiciyi geçersiz kılmaz; öğelerin kaldırılması yalnızca özellikle kaldırılan öğeleri gösteren yineleyicileri geçersiz kılar.

hash_set sınıfı tarafından sağlanan yineleyici çift yönlü bir yineleyicidir, ancak sınıf üyesi işlevleri ekleme ve hash_set , işlev gereksinimleri çift yönlü yineleyici sınıfı tarafından garanti edilenden daha düşük olan şablon parametreleri olarak daha zayıf bir giriş yineleyicisi 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 üyesi işlevleri bağlamında [ first, last) bir dizi yineleyici hakkında anlamlı bir şekilde konuşabilmek yeterlidir.

Oluşturucular

Oluşturucu	Açıklama
hash_set	Boş olan veya başka `hash_set`bir öğesinin tümünün veya bir bölümünün kopyası olan bir `hash_set` oluşturur.

Tür tanımları

Tür adı	Açıklama
allocator_type	Nesnenin sınıfını `allocatorhash_set` temsil eden bir tür.
const_iterator	içindeki bir öğeyi `const`okuyabilen çift yönlü bir yineleyici sağlayan tür`hash_set`.
const_pointer	içindeki bir `const` öğeye işaretçi sağlayan tür `hash_set`.
const_reference	okuma ve gerçekleştirme `const` işlemleri için içinde `hash_set` depolanan bir `const` öğeye başvuru sağlayan bir tür.
const_reverse_iterator	içindeki `const`herhangi `hash_set` bir öğeyi okuyabilen çift yönlü bir yineleyici sağlayan tür.
difference_type	Yineleyiciler tarafından işaret edilen öğeler arasındaki bir aralıktaki öğelerinin `hash_set` sayısını göstermek için kullanılabilecek imzalı bir tamsayı türü.
Yineleyici	bir içindeki herhangi bir öğeyi okuyabilen veya değiştirebilen çift yönlü bir yineleyici sağlayan tür `hash_set`.
key_compare	içindeki iki öğeye `hash_set`göre sırasını belirlemek için iki sıralama anahtarını karşılaştırabilen bir işlev nesnesi sağlayan tür.
key_type	Kapasitede bir öğesinin öğesi `hash_set` olarak depolanan bir nesneyi sıralama anahtarı olarak tanımlayan tür.
Işaretçi	içindeki bir öğeye işaretçi sağlayan tür `hash_set`.
referans	içinde depolanan bir öğeye başvuru sağlayan tür `hash_set`.
reverse_iterator	Ters çevrilmiş `hash_set`içindeki bir öğeyi okuyabilen veya değiştirebilen çift yönlü bir yineleyici sağlayan tür.
size_type	içindeki öğe sayısını temsil eden işaretsiz bir `hash_set`tamsayı türü.
value_compare	İki işlev nesnesi sağlayan bir tür, göreli sırasını belirlemek için öğesinin `hash_set` iki öğe değerini karşılaştırabilen bir sınıf karşılaştırması ikili koşulu ve öğeleri karma hale getiren bir birli koşul.
value_type	Kapasitede bir öğesinin öğesi `hash_set` olarak depolanan bir nesneyi değer olarak tanımlayan tür.

Üye işlevleri

Üye işlevi	Açıklama
başlamak	içindeki `hash_set`ilk öğeyi ele alan bir yineleyici döndürür.
cbegin	içindeki ilk öğeyi `hash_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 `hash_set`sabit yineleyici döndürür.
berrak	öğesinin `hash_set`tüm öğelerini siler.
sayı	Anahtarı parametre tarafından belirtilen anahtarla eşleşen bir `hash_set` içindeki öğelerin sayısını döndürür.
crbegin	ters çevrilmiş `hash_set`içindeki ilk öğeyi ele alan bir sabit yineleyici döndürür.
crend	Ters çevrilmiş `hash_set`bir içindeki son öğeyi başaran konumu ele alan bir sabit yineleyici döndürür.
yer değiştirme	içine yerinde inşa edilmiş bir `hash_set`öğe ekler.
emplace_hint	Bir yerleştirme ipucuyla içine yerinde `hash_set`inşa edilmiş bir öğe ekler.
boş	boş `hash_set` olup olmadığını sınar.
son	içindeki son öğenin başarılı olduğu konumu ele alan bir `hash_set`yineleyici döndürür.
equal_range	Belirtilen anahtardan büyük bir anahtara sahip bir anahtarı olan içindeki ilk öğeye `hash_set` ve anahtara eşit veya daha büyük bir anahtarla içindeki ilk öğeye `hash_set` sırasıyla bir yineleyici çifti döndürür.
silmek	Belirtilen konumlardan bir öğeyi veya bir `hash_set` öğe aralığını kaldırır veya belirtilen bir anahtarla eşleşen öğeleri kaldırır.
bulmak	Belirtilen anahtara eşdeğer bir anahtara sahip bir `hash_set` öğenin konumunu adresleyen bir yineleyici döndürür.
get_allocator	oluşturmak için kullanılan nesnesinin `allocator`bir kopyasını `hash_set` döndürür.
sokmak	içine bir öğe veya öğe `hash_set`aralığı ekler.
key_comp	içindeki anahtarları sıralamak için kullanılan karşılaştırma nesnesinin bir `hash_set`kopyasını alır.
lower_bound	Belirtilen anahtara eşit veya bundan büyük bir anahtara sahip bir içindeki ilk öğeye `hash_set` bir yineleyici döndürür.
max_size	değerinin uzunluk üst sınırını `hash_set`döndürür.
rbegin	ters çevrilmiş `hash_set`içindeki ilk öğeyi ele alan bir yineleyici döndürür.
yarmak	Ters çevrilmiş `hash_set`bir içindeki son öğeyi başaran konumu ele alan bir yineleyici döndürür.
boyut	içindeki `hash_set`öğe sayısını döndürür.
değiş tokuş etmek	İki `hash_set`öğesinin öğelerini değiştirir.
upper_bound	Belirtilen anahtara eşit veya bundan büyük bir `hash_set` anahtara sahip olan bir içindeki ilk öğeye bir yineleyici döndürür.
value_comp	içindeki öğe anahtarı değerlerini karma ve sıralamak için kullanılan karma özellik nesnesinin bir `hash_set`kopyasını alır.

İşleçler

Operatör	Açıklama
hash_set::operator=	öğesinin `hash_set` öğelerini başka `hash_set`bir kopyasının kopyasıyla değiştirir.

Gereksinimler

Üst Bilgi:<hash_set>

Ad alanı: stdext

hash_set::allocator_type

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

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

typedef list<typename Traits::value_type, typename Traits::allocator_type>::allocator_type allocator_type;

Açıklamalar

allocator_type, Ayırıcı şablon parametresinin eş anlamlısıdır.

Ayırıcı hakkında daha fazla bilgi için hash_set Sınıfı konusunun Açıklamalar bölümüne bakın.

Örnek

kullanan bir örnek için allocator_type örneğine bakın.

hash_set::begin

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

hash_set ilk öğeyi ele alan bir yineleyici döndürür.

const_iterator begin() const;

iterator begin();

Dönüş Değeri

hash_set ilk öğeyi veya boş bir hash_set başarılı olan konumu ele alan çift yönlü bir yineleyici.

Açıklamalar

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

Örnek

// hash_set_begin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;
   hash_set <int>::const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_Iter = hs1.begin( );
   cout << "The first element of hs1 is " << *hs1_Iter << endl;

   hs1_Iter = hs1.begin( );
   hs1.erase( hs1_Iter );

   // The following 2 lines would err because the iterator is const
   // hs1_cIter = hs1.begin( );
   // hs1.erase( hs1_cIter );

   hs1_cIter = hs1.begin( );
   cout << "The first element of hs1 is now " << *hs1_cIter << endl;
}

The first element of hs1 is 1
The first element of hs1 is now 2

hash_set::cbegin

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

hash_set ilk öğeyi ele alan bir sabit yineleyici döndürür.

const_iterator cbegin() const;

Dönüş Değeri

hash_set ilk öğeyi veya boş hash_setbir konumun başarılı olduğu konumu ele alan iki yönlü bir çift yönlü yineleyici.

Açıklamalar

dönüş değeriyle cbegin, nesnedeki hash_set öğeler değiştirilemez.

Örnek

// hash_set_cbegin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_cIter = hs1.cbegin( );
   cout << "The first element of hs1 is " << *hs1_cIter << endl;
}

The first element of hs1 is 1

hash_set::cend

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

bir hash_set son öğesinin başarılı olduğu konumu ele alan bir sabit yineleyici döndürür.

const_iterator cend() const;

Dönüş Değeri

bir hash_set son öğeyi başaran konumu ele alan iki yönlü bir sabit yineleyici. hash_set boşsa, öğesini seçinhash_set::cend == hash_set::begin.

Açıklamalar

cend , yineleyicinin sonuna hash_setulaşıp ulaşmadığını test etmek için kullanılır. tarafından cend döndürülen değer başvurulmamalıdır.

Örnek

// hash_set_cend.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_cIter = hs1.cend( );
   hs1_cIter--;
   cout << "The last element of hs1 is " << *hs1_cIter << endl;
}

The last element of hs1 is 3

hash_set::clear

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

bir hash_set tüm öğelerini siler.

void clear();

Örnek

// hash_set_clear.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;

   hs1.insert( 1 );
   hs1.insert( 2 );

   cout << "The size of the hash_set is initially " << hs1.size( )
        << "." << endl;

   hs1.clear( );
   cout << "The size of the hash_set after clearing is "
        << hs1.size( ) << "." << endl;
}

The size of the hash_set is initially 2.
The size of the hash_set after clearing is 0.

hash_set::const_iterator

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

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

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_iterator const_iterator;

Açıklamalar

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

Örnek

kullanan bir örnek için const_iterator örneğine bakın.

hash_set::const_pointer

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

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

typedef list<typename Traits::value_type, typename Traits::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, bir hash_set nesnesindeki öğelere erişmek için bir const const_iterator kullanılmalıdır.

hash_set::const_reference

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

okuma ve işlem gerçekleştirmeye const yönelik bir const hash_set depolanan bir öğeye başvuru sağlayan tür.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_reference const_reference;

Örnek

// hash_set_const_ref.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;

   hs1.insert( 10 );
   hs1.insert( 20 );

   // Declare and initialize a const_reference &Ref1
   // to the 1st element
   const int &Ref1 = *hs1.begin( );

   cout << "The first element in the hash_set is "
        << Ref1 << "." << endl;

   // The following line would cause an error because the
   // const_reference cannot be used to modify the hash_set
   // Ref1 = Ref1 + 5;
}

The first element in the hash_set is 10.

hash_set::const_reverse_iterator

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

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

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_reverse_iterator const_reverse_iterator;

Açıklamalar

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

Örnek

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

hash_set::count

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Anahtarı parametre tarafından belirtilen bir anahtarla eşleşen bir hash_set öğe sayısını döndürür.

size_type count(const Key& key) const;

Parametreler

anahtar
hash_set eşleştirilecek öğelerin anahtarı.

Dönüş Değeri

hash_set sıralama anahtarı parametre anahtarıyla eşleşen bir öğe içeriyorsa 1.

hash_set 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(anahtar), upper_bound(anahtar) ).

Örnek

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

// hash_set_count.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_set<int> hs1;
    hash_set<int>::size_type i;

    hs1.insert(1);
    hs1.insert(1);

    // Keys must be unique in hash_set, so duplicates are ignored.
    i = hs1.count(1);
    cout << "The number of elements in hs1 with a sort key of 1 is: "
         << i << "." << endl;

    i = hs1.count(2);
    cout << "The number of elements in hs1 with a sort key of 2 is: "
         << i << "." << endl;
}

The number of elements in hs1 with a sort key of 1 is: 1.
The number of elements in hs1 with a sort key of 2 is: 0.

hash_set::crbegin

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Ters çevrilmiş bir hash_set ilk öğeyi ele alan bir sabit yineleyici döndürür.

const_reverse_iterator crbegin() const;

Dönüş Değeri

Ters çevrilmiş bir hash_set içindeki ilk öğeyi veya ters hash_setçevrilmemiş içindeki son öğeyi ele alan en ters çift yönlü yineleyici.

Açıklamalar

crbeginhash_set::begin bir hash_set ile kullanıldığı gibi ters çevrilmiş bir hash_set ile kullanılır.

dönüş değeriyle crbeginhash_set nesne değiştirilemez.

crbegin geriye doğru yinelemek hash_set için kullanılabilir.

Örnek

// hash_set_crbegin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::const_reverse_iterator hs1_crIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_crIter = hs1.crbegin( );
   cout << "The first element in the reversed hash_set is "
        << *hs1_crIter << "." << endl;
}

The first element in the reversed hash_set is 30.

hash_set::crend

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Ters çevrilmiş bir hash_set son öğenin başarılı olduğu konumu ele alan bir sabit yineleyici döndürür.

const_reverse_iterator crend() const;

Dönüş Değeri

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

Açıklamalar

crend, hash_set::endhash_setters çevrilmiş bir hash_setile kullanılır.

dönüş değeriyle crendhash_set nesne değiştirilemez.

crend , ters yineleyicinin sonuna hash_setulaşıp ulaşmadığını test etmek için kullanılabilir.

Örnek

// hash_set_crend.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::const_reverse_iterator hs1_crIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_crIter = hs1.crend( );
   hs1_crIter--;
   cout << "The last element in the reversed hash_set is "
        << *hs1_crIter << "." << endl;
}

The last element in the reversed hash_set is 10.

hash_set::d ifference_type

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Yineleyiciler tarafından işaret edilen öğeler arasındaki bir aralıktaki bir hash_set öğelerinin sayısını göstermek için kullanılabilecek imzalı bir tamsayı türü.

typedef list<typename Traits::value_type, typename Traits::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 first ile lastarasındaki [ first, last) aralığındaki öğe sayısını temsil etmek için first kullanılır; öğesinin işaret ettiği öğeyi ve öğesinin işaret lastettiği öğ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 çıkarmanın yalnızca vektör veya deque gibi rastgele erişim kapsayıcısı tarafından sağlanan rastgele erişim yineleyicileri tarafından desteklendiğini unutmayın.

Örnek

// hash_set_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_set>
#include <algorithm>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter, hs1_bIter, hs1_eIter;

   hs1.insert( 20 );
   hs1.insert( 10 );
   hs1.insert( 20 );   // Won't insert as hash_set elements are unique

   hs1_bIter = hs1.begin( );
   hs1_eIter = hs1.end( );

   hash_set <int>::difference_type   df_typ5, df_typ10, df_typ20;

   df_typ5 = count( hs1_bIter, hs1_eIter, 5 );
   df_typ10 = count( hs1_bIter, hs1_eIter, 10 );
   df_typ20 = count( hs1_bIter, hs1_eIter, 20 );

   // The keys, and hence the elements, of a hash_set are unique,
   // so there is at most one of a given value
   cout << "The number '5' occurs " << df_typ5
        << " times in hash_set hs1.\n";
   cout << "The number '10' occurs " << df_typ10
        << " times in hash_set hs1.\n";
   cout << "The number '20' occurs " << df_typ20
        << " times in hash_set hs1.\n";

   // Count the number of elements in a hash_set
   hash_set <int>::difference_type  df_count = 0;
   hs1_Iter = hs1.begin( );
   while ( hs1_Iter != hs1_eIter)
   {
      df_count++;
      hs1_Iter++;
   }

   cout << "The number of elements in the hash_set hs1 is: "
        << df_count << "." << endl;
}

The number '5' occurs 0 times in hash_set hs1.
The number '10' occurs 1 times in hash_set hs1.
The number '20' occurs 1 times in hash_set hs1.
The number of elements in the hash_set hs1 is: 2.

hash_set::emplace

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Bir hash_set yerinde inşa edilmiş bir öğe ekler.

template <class ValTy>
pair <iterator, bool>
emplace(
    ValTy&& val);

Parametreler

Val
Zaten bu öğeyi veya daha genel olarak anahtarı eşdeğer sıralanmış bir öğeyi içermediği sürece, hash_sethash_setöğenin değeri.

Dönüş Değeri

emplace Üye işlevi, bir ekleme yapıldıysa ve anahtarı sıralamada eşdeğer bir değere sahip olan ve booltrue yineleyici bileşeni yeni öğenin eklendiği veya öğenin zaten bulunduğu adresi döndüren bir öğe içeriyorsa bileşeni döndüren false bir çift hash_set döndürür.

Örnek

// hash_set_emplace.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set<string> hs3;
   string str1("a");

   hs3.emplace(move(str1));
   cout << "After the emplace insertion, hs3 contains "
      << *hs3.begin() << "." << endl;
}

After the emplace insertion, hs3 contains a.

hash_set::emplace_hint

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Bir hash_set yerinde inşa edilmiş bir öğe ekler.

template <class ValTy>
iterator emplace(
    const_iterator _Where,
    ValTy&& val);

Parametreler

Val
Zaten bu öğeyi veya daha genel olarak anahtarı eşdeğer sıralanmış bir öğeyi içermediği sürece, hash_sethash_setöğenin değeri.

_Nerede
Doğru ekleme noktasını aramaya başlanması gereken yer. (Ekleme noktası hemen _Where izlerse ekleme işlemi logaritmik saat yerine amorti edilmiş sabit sürede gerçekleşebilir.)

Dönüş Değeri

hash_set::emplace üye işlevi, yeni öğenin içine hash_seteklendiği veya eşdeğer sıralamaya sahip mevcut öğenin bulunduğu konumu gösteren bir yineleyici döndürür.

Açıklamalar

Ekleme noktası hemen _Where izlerse ekleme işlemi logaritmik saat yerine amorti edilmiş sabit sürede gerçekleşebilir.

Örnek

// hash_set_emplace_hint.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set<string> hs3;
   string str1("a");

   hs3.insert(hs3.begin(), move(str1));
   cout << "After the emplace insertion, hs3 contains "
      << *hs3.begin() << "." << endl;
}

After the emplace insertion, hs3 contains a.

hash_set::empty

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

hash_set boş olup olmadığını sınar.

bool empty() const;

Dönüş Değeri

true hash_set boşsa; false hash_set yoksa.

Örnek

// hash_set_empty.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1, hs2;
   hs1.insert ( 1 );

   if ( hs1.empty( ) )
      cout << "The hash_set hs1 is empty." << endl;
   else
      cout << "The hash_set hs1 is not empty." << endl;

   if ( hs2.empty( ) )
      cout << "The hash_set hs2 is empty." << endl;
   else
      cout << "The hash_set hs2 is not empty." << endl;
}

The hash_set hs1 is not empty.
The hash_set hs2 is empty.

hash_set::end

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

bir hash_set son öğesinin başarılı olduğu konumu ele alan bir yineleyici döndürür.

const_iterator end() const;

iterator end();

Dönüş Değeri

bir hash_set son öğesinin başarılı olduğu konumu ele alan çift yönlü yineleyici. hash_set boşsa hash_set::end == hash_set::begin.

Açıklamalar

end , yineleyicinin hash_set sonuna ulaşıp ulaşmadığını test etmek için kullanılır. tarafından end döndürülen değer başvurulmamalıdır.

Örnek

// hash_set_end.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: iterator hs1_Iter;
   hash_set <int> :: const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_Iter = hs1.end( );
   hs1_Iter--;
   cout << "The last element of hs1 is " << *hs1_Iter << endl;

   hs1.erase( hs1_Iter );

   // The following 3 lines would err because the iterator is const:
   // hs1_cIter = hs1.end( );
   // hs1_cIter--;
   // hs1.erase( hs1_cIter );

   hs1_cIter = hs1.end( );
   hs1_cIter--;
   cout << "The last element of hs1 is now " << *hs1_cIter << endl;
}

The last element of hs1 is 3
The last element of hs1 is now 2

hash_set::equal_range

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Belirtilen anahtara eşit bir anahtara sahip bir karma kümesindeki ilk öğeye ve anahtardan büyük bir anahtarla karma kümesindeki ilk öğeye sırasıyla bir çift yineleyici döndürür.

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

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

Parametreler

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

Dönüş Değeri

Birincisi anahtarın lower_bound, ikincisi anahtarın upper_bound olan bir çift yineleyici.

Üye işlevi tarafından döndürülen çift pr'nin 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

// hash_set_equal_range.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_set<int> IntHSet;
   IntHSet hs1;
   hash_set <int> :: const_iterator hs1_RcIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   pair <IntHSet::const_iterator, IntHSet::const_iterator> p1, p2;
   p1 = hs1.equal_range( 20 );

   cout << "The upper bound of the element with "
        << "a key of 20 in the hash_set hs1 is: "
        << *(p1.second) << "." << endl;

   cout << "The lower bound of the element with "
        << "a key of 20 in the hash_set hs1 is: "
        << *(p1.first) << "." << endl;

   // Compare the upper_bound called directly
   hs1_RcIter = hs1.upper_bound( 20 );
   cout << "A direct call of upper_bound( 20 ) gives "
        << *hs1_RcIter << "," << endl
        << "matching the 2nd element of the pair"
        << " returned by equal_range( 20 )." << endl;

   p2 = hs1.equal_range( 40 );

   // If no match is found for the key,
   // both elements of the pair return end( )
   if ( ( p2.first == hs1.end( ) ) && ( p2.second == hs1.end( ) ) )
      cout << "The hash_set hs1 doesn't have an element "
           << "with a key greater than or equal to 40." << endl;
   else
      cout << "The element of hash_set hs1 with a key >= 40 is: "
           << *(p1.first) << "." << endl;
}

The upper bound of the element with a key of 20 in the hash_set hs1 is: 30.
The lower bound of the element with a key of 20 in the hash_set hs1 is: 20.
A direct call of upper_bound( 20 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 20 ).
The hash_set hs1 doesn't have an element with a key greater than or equal to 40.

hash_set::erase

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

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

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

Parametreler

_Nerede
hash_set kaldırılacak öğenin konumu.

birinci
hash_set kaldırılan ilk öğenin konumu.

son
hash_set kaldırılan son öğenin hemen ötesinde konum.

anahtar
hash_set kaldırılacak öğelerin anahtarı.

Dönüş Değeri

İlk iki üye işlevi için, kaldırılan öğelerin ötesinde kalan ilk öğeyi belirten çift yönlü bir yineleyici veya böyle bir öğe yoksa hash_set sonuna yönelik bir işaretçi. Üçüncü üye işlevi için, hash_set kaldırılan öğe sayısı.

Açıklamalar

Üye işlevleri hiçbir zaman özel durum oluşturmaz.

Örnek

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

// hash_set_erase.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_set<int> hs1, hs2, hs3;
    hash_set<int>::iterator pIter, Iter1, Iter2;
    int i;
    hash_set<int>::size_type n;

    for (i = 1; i < 5; i++)
    {
        hs1.insert (i);
        hs2.insert (i * i);
        hs3.insert (i - 1);
    }

    // The 1st member function removes an element at a given position
    Iter1 = ++hs1.begin();
    hs1.erase(Iter1);

    cout << "After the 2nd element is deleted, the hash_set hs1 is:";
    for (pIter = hs1.begin(); pIter != hs1.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

    // The 2nd member function removes elements
    // in the range [ first,  last)
    Iter1 = ++hs2.begin();
    Iter2 = --hs2.end();
    hs2.erase(Iter1, Iter2);

    cout << "After the middle two elements are deleted, "
         << "the hash_set hs2 is:";
    for (pIter = hs2.begin(); pIter != hs2.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

    // The 3rd member function removes elements with a given  key
    n = hs3.erase(2);

    cout << "After the element with a key of 2 is deleted, "
         << "the hash_set hs3 is:";
    for (pIter = hs3.begin(); pIter != hs3.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

    // The 3rd member function returns the number of elements removed
    cout << "The number of elements removed from hs3 is: "
         << n << "." << endl;

    // The dereferenced iterator can also be used to specify a key
    Iter1 = ++hs3.begin();
    hs3.erase(Iter1);

    cout << "After another element (unique for hash_set) with a key "
         << endl;
    cout  << "equal to that of the 2nd element is deleted, "
          << "the hash_set hs3 is:";
    for (pIter = hs3.begin(); pIter != hs3.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;
}

After the 2nd element is deleted, the hash_set hs1 is: 1 3 4.
After the middle two elements are deleted, the hash_set hs2 is: 16 4.
After the element with a key of 2 is deleted, the hash_set hs3 is: 0 1 3.
The number of elements removed from hs3 is: 1.
After another element (unique for hash_set) with a key
equal to that of the 2nd element is deleted, the hash_set hs3 is: 0 3.

hash_set::find

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Hash_set belirtilen anahtara eşdeğer bir anahtara sahip bir öğenin konumunu adresleyen bir yineleyici döndürür.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametreler

anahtar
Aranmakta olan hash_set bir öğenin sıralama anahtarıyla eşleştirilecek bağımsız değişken anahtarı.

Dönüş Değeri

Belirtilen iterator anahtara eşdeğer bir öğenin konumunu veya anahtar için eşleşme bulunamazsa hash_set son öğenin başarılı olduğu konumu ele alan bir veya const_iterator .

Açıklamalar

Üye işlevi, hash_set sıralama anahtarı equivalent , küçük karşılaştırmalı bir ilişkiyi temel alan bir sıralamaya neden olan ikili koşul altındaki bağımsız değişken anahtarına yönelik bir öğeyi ele alan bir yineleyici döndürür.

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

Örnek

// hash_set_find.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_RcIter = hs1.find( 20 );
   cout << "The element of hash_set hs1 with a key of 20 is: "
        << *hs1_RcIter << "." << endl;

   hs1_RcIter = hs1.find( 40 );

   // If no match is found for the key, end( ) is returned
   if ( hs1_RcIter == hs1.end( ) )
      cout << "The hash_set hs1 doesn't have an element "
           << "with a key of 40." << endl;
   else
      cout << "The element of hash_set hs1 with a key of 40 is: "
           << *hs1_RcIter << "." << endl;

   // The element at a specific location in the hash_set can be found
   // by using a dereferenced iterator addressing the location
   hs1_AcIter = hs1.end( );
   hs1_AcIter--;
   hs1_RcIter = hs1.find( *hs1_AcIter );
   cout << "The element of hs1 with a key matching "
        << "that of the last element is: "
        << *hs1_RcIter << "." << endl;
}

The element of hash_set hs1 with a key of 20 is: 20.
The hash_set hs1 doesn't have an element with a key of 40.
The element of hs1 with a key matching that of the last element is: 30.

hash_set::get_allocator

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

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

Allocator get_allocator() const;

Dönüş Değeri

hash_set tarafından kullanılan ayırıcı, Allocator şablon parametresi olan belleği yönetmek için kullanılır.

Ayırıcı hakkında daha fazla bilgi için hash_set Sınıfı konusunun Açıklamalar bölümüne bakın.

Açıklamalar

hash_set 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

// hash_set_get_allocator.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   // The following lines declare objects
   // that use the default allocator.
   hash_set <int, hash_compare <int, less<int> > > hs1;
   hash_set <int,  hash_compare <int, greater<int> > > hs2;
   hash_set <double, hash_compare <double,
      less<double> >, allocator<double> > hs3;

   hash_set <int, hash_compare <int,
      greater<int> > >::allocator_type hs2_Alloc;
   hash_set <double>::allocator_type hs3_Alloc;
   hs2_Alloc = hs2.get_allocator( );

   cout << "The number of integers that can be allocated"
        << endl << "before free memory is exhausted: "
        << hs1.max_size( ) << "." << endl;

   cout << "The number of doubles that can be allocated"
        << endl << "before free memory is exhausted: "
        << hs3.max_size( ) <<  "." << endl;

   // The following lines create a hash_set hs4
   // with the allocator of hash_set hs1.
   hash_set <int>::allocator_type hs4_Alloc;
   hash_set <int> hs4;
   hs4_Alloc = hs2.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated by the other
   if( hs2_Alloc == hs4_Alloc )
   {
      cout << "The allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "The allocators are not interchangeable."
           << endl;
   }
}

hash_set::hash_set

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Boş olan veya başka hash_setbir öğesinin tümünün veya bir bölümünün kopyası olan bir hash_set oluşturur.

hash_set();

explicit hash_set(
    const Traits& Comp);

hash_set(
    const Traits& Comp,
    const Allocator& Al);

hash_set(
    const hash_set<Key, Traits, Allocator>& Right);

hash_set(
    hash_set&& Right);

hash_set(
    initializer_list<Type> IList);

hash_set(
    initializer_list<Type> IList,
    const Compare& Comp);

hash_set(
    initializer_list<value_type> IList,
    const Compare& Comp,
    const Allocator& Al);

template <class InputIterator>
hash_set(
    InputIterator First,
    InputIterator Last);

template <class InputIterator>
hash_set(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp);

template <class InputIterator>
hash_set(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp,
    const Allocator& Al);

Parametreler

Al
Bu hash_set nesne için kullanılacak depolama ayırıcı sınıfı, varsayılan olarak Allocatorolarak kullanılır.

Comp
türündeki const Traits öğeleri hash_setsıralamak için kullanılan karşılaştırma işlevidir ve varsayılan olarak hash_compareolarak kullanılır.

Sağ
hash_set Bunun için bir hash_set kopya oluşturulur.

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

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

Açıklamalar

Tüm oluşturucular, ve için hash_set bellek depolamasını yöneten ve daha sonra hash_set::get_allocator çağrılarak döndürülebilen bir tür ayırıcı nesnesi 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 hash_sets başlatır.

Tüm oluşturucular, anahtarları Traits arasında bir sıra oluşturmak için kullanılan ve daha sonra hash_set::key_comphash_setdöndürülebilecek türde bir işlev nesnesi depolar. Hakkında daha fazla bilgi Traits için hash_set Sınıfı konusuna bakın.

İlk oluşturucu boş bir başlangıç hash_set oluşturur İkinci, öğelerin sırasını oluştururken kullanılacak karşılaştırma işlevinin türünü (Comp) ve üçüncüsü kullanılacak ayırıcı türünü (Al) açıkça belirtir. Anahtar sözcük explicit , belirli tür otomatik tür dönüştürmelerini gizler.

Dördüncü ve beşinci oluşturucular, öğesinin hash_setRightbir kopyasını belirtir.

Son altıncı, yedinci ve sekizinci oluşturucular öğeler için bir initializer_list kullanır.

Son oluşturucular, Sınıfın Traits ve ayırıcısının karşılaştırma işlevinin türünü belirtirken açıklığı artan bir şekilde [ FirstLast , hash_set) aralığını kopyalar.

Sekizinci oluşturucu öğesini hash_setRighttaşır.

Kapsayıcıdaki hash_set öğelerin gerçek sırası karma işlevine, sıralama işlevine ve karma tablosunun geçerli boyutuna bağlıdır ve genel olarak, yalnızca sıralama işlevi tarafından belirlendiği küme kapsayıcısında olduğu gibi tahmin edilemez.

hash_set::insert

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

içine bir öğe veya öğe hash_setaralığı ekler.

pair<iterator, bool> insert(
    const value_type& Val);

iterator insert(
    iterator Where,
    const value_type& Val);

void insert(
    initializer_list<value_type> IList)
template <class InputIterator>
void insert(
    InputIterator First,
    InputIterator Last);

Parametreler

Val
zaten bu öğeyi veya daha genel olarak, anahtarı eşdeğer sıralanmış bir öğeyi içermediği sürece hash_set içine eklenecek hash_set öğenin değeri.

Nerede
Doğru ekleme noktasını aramaya başlanması gereken yer. (Ekleme noktası hemen takip _Whereederse, ekleme işlemi logaritmik saat yerine amorti edilmiş sabit sürede gerçekleşebilir.)

Birinci
bir öğesinden hash_setkopyalanacak ilk öğenin konumu.

Son
bir öğesinden hash_setkopyalanacak son öğenin hemen ötesindeki konum.

IList
Öğelerin kopyalanacağı initializer_list.

Dönüş Değeri

İlk insert üye işlevi, ekleme yapıldıysa ve anahtarı sıralamada eşdeğer bir değere sahip olan ve booltrue yineleyici bileşeni yeni öğenin eklendiği veya öğenin zaten bulunduğu adresi döndüren bir öğe içeriyorsa bileşeni döndüren false bir çift hash_set döndürür.

Bu üye işlevi tarafından döndürülen bir çiftin pr yineleyici bileşenine erişmek için ve komutunu kullanarak pr.first*(pr.first)başvuruyu kaldırın. Bu üye işlevi booltarafından döndürülen bir çiftin pr bileşenine erişmek pr.second için kullanın ve başvuruyu geri almak için kullanın*(pr.second).

İkinci insert üye işlevi, yeni öğenin içine eklendiği hash_setkonumu gösteren bir yineleyici döndürür.

Açıklamalar

Üçüncü üye işlevi öğeleri bir initializer_list ekler.

Üçüncü üye işlevi, belirtilen hash_setbir First öğesinin [ Last, hash_set) aralığındaki yineleyicisi tarafından ele alınan her öğeye karşılık gelen öğe değerlerinin sırasını ekler.

hash_set::yineleyici

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

hash_set herhangi bir öğeyi okuyabilen veya değiştirebilen çift yönlü bir yineleyici sağlayan tür.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::iterator iterator;

Açıklamalar

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

Örnek

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

hash_set::key_comp

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Bir hash_set öğe anahtarı değerlerini karma ve sıralamak için kullanılan karma özellik nesnesinin bir kopyasını alır.

key_compare key_comp() const;

Dönüş Değeri

Bir hash_set öğelerini sıralamak için kullandığı işlev nesnesini döndürür. Bu, Traits şablon parametresidir.

Özellikler hakkında daha fazla bilgi için hash_set Sınıfı konusuna bakın.

Açıklamalar

Depolanan nesne üye işlevini tanımlar:

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

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

Hem key_compare hem de value_compare, Şablon parametresiNin Traits eş anlamlıları olduğunu unutmayın. Her iki tür de hash_set ve hash_multiset sınıfları için sağlanır ve burada aynı olan sınıflar, hash_map ve hash_multimap sınıfları ile uyumluluk açısından ayrıdır.

Örnek

// hash_set_key_comp.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_set <int, hash_compare < int, less<int> > >hs1;
   hash_set<int, hash_compare < int, less<int> > >::key_compare kc1
          = hs1.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 hs1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of hs1."
        << endl;
   }

   hash_set <int, hash_compare < int, greater<int> > > hs2;
   hash_set<int, hash_compare < int, greater<int> > >::key_compare
         kc2 = hs2.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 hs2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of hs2."
           << endl;
   }
}

hash_set::key_compare

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

hash_set iki öğe göreli sırasını belirlemek için iki sıralama anahtarını karşılaştırabilen bir işlev nesnesi sağlayan bir tür.

typedef Traits key_compare;

Açıklamalar

key_compare , Traits şablon parametresinin eş anlamlısıdır.

Özellikler hakkında daha fazla bilgi için hash_set Sınıfı konusuna bakın.

Hem hem de key_compare value_compare,Traits şablon parametresinin eş anlamlıları olduğunu unutmayın. Her iki tür de aynı olan küme ve çok kümeli sınıflar için, eşleme ve çoklu eşleme sınıfları ile uyumluluk için sağlanır ve burada ayrıdırlar.

Örnek

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

hash_set::key_type

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

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

typedef Key key_type;

Açıklamalar

key_type, Anahtar şablon parametresinin eş anlamlısıdır.

Anahtar hakkında daha fazla bilgi için hash_set Sınıfı konusunun Açıklamalar bölümüne bakın.

Hem hem de key_type value_type, anahtar şablon parametresinin eş anlamlıları olduğunu unutmayın. Her iki tür de hash_set ve hash_multiset sınıfları için sağlanır ve burada aynı olan sınıflar, hash_map ve hash_multimap sınıfları ile uyumluluk açısından ayrıdır.

Örnek

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

hash_set::lower_bound

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Bir hash_set belirtilen anahtara eşit veya daha büyük bir anahtara sahip ilk öğeye bir yineleyici döndürür.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Parametreler

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

Dönüş Değeri

Bir iterator hash_set const_iterator bir öğenin, bağımsız değişken anahtarına eşit veya ondan büyük olan veya anahtar için eşleşme bulunamazsa hash_set son öğeyi başarılı olan konumu ele alan konumu ele alan veya.

Örnek

// hash_set_lower_bound.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_RcIter = hs1.lower_bound( 20 );
   cout << "The element of hash_set hs1 with a key of 20 is: "
        << *hs1_RcIter << "." << endl;

   hs1_RcIter = hs1.lower_bound( 40 );

   // If no match is found for the key, end( ) is returned
   if ( hs1_RcIter == hs1.end( ) )
      cout << "The hash_set hs1 doesn't have an element "
           << "with a key of 40." << endl;
   else
      cout << "The element of hash_set hs1 with a key of 40 is: "
           << *hs1_RcIter << "." << endl;

   // An element at a specific location in the hash_set can be found
   // by using a dereferenced iterator that addresses the location
   hs1_AcIter = hs1.end( );
   hs1_AcIter--;
   hs1_RcIter = hs1.lower_bound( *hs1_AcIter );
   cout << "The element of hs1 with a key matching "
        << "that of the last element is: "
        << *hs1_RcIter << "." << endl;
}

The element of hash_set hs1 with a key of 20 is: 20.
The hash_set hs1 doesn't have an element with a key of 40.
The element of hs1 with a key matching that of the last element is: 30.

hash_set::max_size

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

hash_set uzunluğu üst sınırını döndürür.

size_type max_size() const;

Dönüş Değeri

hash_set maksimum olası uzunluğu.

Örnek

// hash_set_max_size.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::size_type i;

   i = hs1.max_size( );
   cout << "The maximum possible length "
        << "of the hash_set is " << i << "." << endl;
}

hash_set::operator=

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

hash_set öğelerini başka bir hash_set kopyasıyla değiştirir.

hash_set& operator=(const hash_set& right);

hash_set& operator=(hash_set&& right);

Parametreler

Sağ
içine .

Açıklamalar

içindeki hash_setoperator= mevcut öğeleri sildikten sonra içeriğini kopyalayarak veya doğrudan içine hash_settaşır.

Örnek

// hash_set_operator_as.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set<int> v1, v2, v3;
   hash_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;
}

hash_set::p ointer

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

hash_set bir öğeye işaretçi sağlayan bir tür.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::pointer pointer;

Açıklamalar

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

Çoğu durumda, bir hash_set nesnesindeki öğelere erişmek için yineleyici kullanılmalıdır.

hash_set::rbegin

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Ters çevrilmiş bir hash_set ilk öğeyi ele alan bir yineleyici döndürür.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Dönüş Değeri

Ters çevrilmiş bir hash_set ilk öğeyi ele alan veya ters çevrilmeyen hash_set son öğe olan öğeyi ele alan ters çift yönlü yineleyici.

Açıklamalar

rbegin, bir hash_set ile kullanıldığında olduğu gibi ters çevrilmiş bir hash_set ile kullanılır.

dönüş değeri rbegin öğesine const_reverse_iteratoratanmışsa, hash_set nesnesi değiştirilemez. değerinin dönüş değeri rbegin bir reverse_iteratoröğesine atanmışsa, hash_set nesnesi değiştirilebilir.

rbegin bir hash_set geriye doğru yinelemek için kullanılabilir.

Örnek

// hash_set_rbegin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;
   hash_set <int>::reverse_iterator hs1_rIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_rIter = hs1.rbegin( );
   cout << "The first element in the reversed hash_set is "
        << *hs1_rIter << "." << endl;

   // begin can be used to start an iteration
   // through a hash_set in a forward order
   cout << "The hash_set is: ";
   for ( hs1_Iter = hs1.begin( ) ; hs1_Iter != hs1.end( );
         hs1_Iter++ )
      cout << *hs1_Iter << " ";
   cout << endl;

   // rbegin can be used to start an iteration
   // through a hash_set in a reverse order
   cout << "The reversed hash_set is: ";
   for ( hs1_rIter = hs1.rbegin( ) ; hs1_rIter != hs1.rend( );
         hs1_rIter++ )
      cout << *hs1_rIter << " ";
   cout << endl;

   // A hash_set element can be erased by dereferencing to its key
   hs1_rIter = hs1.rbegin( );
   hs1.erase ( *hs1_rIter );

   hs1_rIter = hs1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed hash_set is "<< *hs1_rIter << "."
        << endl;
}

The first element in the reversed hash_set is 30.
The hash_set is: 10 20 30
The reversed hash_set is: 30 20 10
After the erasure, the first element in the reversed hash_set is 20.

hash_set::reference

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

hash_set depolanan bir öğeye başvuru sağlayan tür.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::reference reference;

Örnek

// hash_set_reference.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;

   hs1.insert( 10 );
   hs1.insert( 20 );

   // Declare and initialize a reference &Ref1 to the 1st element
   int &Ref1 = *hs1.begin( );

   cout << "The first element in the hash_set is "
        << Ref1 << "." << endl;

   // The value of the 1st element of the hash_set can be changed
   // by operating on its (non-const) reference
   Ref1 = Ref1 + 5;

   cout << "The first element in the hash_set is now "
        << *hs1.begin() << "." << endl;
}

The first element in the hash_set is 10.
The first element in the hash_set is now 15.

hash_set::rend

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Ters çevrilmiş bir hash_set son öğenin başarılı olduğu konumu ele alan bir yineleyici döndürür.

const_reverse_iterator rend() const;

reverse_iterator rend();

Dönüş Değeri

Ters çevrilmiş bir hash_set son öğeden sonra gelen konumu (ters çevrilmeyen hash_set ilk öğeden önce gelen konum) ele alan ters çift yönlü yineleyici.

Açıklamalar

rendaynı ucun bir hash_set ile kullanıldığı gibi ters çevrilmiş bir hash_set ile kullanılır.

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

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

Örnek

// hash_set_rend.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;
   hash_set <int>::reverse_iterator hs1_rIter;
   hash_set <int>::const_reverse_iterator hs1_crIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_rIter = hs1.rend( );
   hs1_rIter--;
   cout << "The last element in the reversed hash_set is "
        << *hs1_rIter << "." << endl;

   // end can be used to terminate an iteration
   // through a hash_set in a forward order
   cout << "The hash_set is: ";
   for ( hs1_Iter = hs1.begin( ) ; hs1_Iter != hs1.end( );
         hs1_Iter++ )
      cout << *hs1_Iter << " ";
   cout << "." << endl;

   // rend can be used to terminate an iteration
   // through a hash_set in a reverse order
   cout << "The reversed hash_set is: ";
   for ( hs1_rIter = hs1.rbegin( ) ; hs1_rIter != hs1.rend( );
         hs1_rIter++ )
      cout << *hs1_rIter << " ";
   cout << "." << endl;

   hs1_rIter = hs1.rend( );
   hs1_rIter--;
   hs1.erase ( *hs1_rIter );

   hs1_rIter = hs1.rend( );
   hs1_rIter--;
   cout << "After the erasure, the last element in the "
        << "reversed hash_set is " << *hs1_rIter << "."
        << endl;
}

The last element in the reversed hash_set is 10.
The hash_set is: 10 20 30 .
The reversed hash_set is: 30 20 10 .
After the erasure, the last element in the reversed hash_set is 20.

hash_set::reverse_iterator

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Ters çevrilmiş bir hash_set bir öğeyi okuyabilen veya değiştirebilen çift yönlü bir yineleyici sağlayan tür.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::reverse_iterator reverse_iterator;

Açıklamalar

Tür reverse_iterator , hash_set tersten yinelemek için kullanılır.

Örnek

nasıl bildirilip örneğine bakın.

hash_set::size

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

hash_set öğe sayısını döndürür.

size_type size() const;

Dönüş Değeri

hash_set geçerli uzunluğu.

Örnek

// hash_set_size.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: size_type i;

   hs1.insert( 1 );
   i = hs1.size( );
   cout << "The hash_set length is " << i << "." << endl;

   hs1.insert( 2 );
   i = hs1.size( );
   cout << "The hash_set length is now " << i << "." << endl;
}

The hash_set length is 1.
The hash_set length is now 2.

hash_set::size_type

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

bir hash_set öğe sayısını temsil eden işaretsiz bir tamsayı türü.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::size_type size_type;

Örnek

Bildirme ve kullanma örneği için boyut örneğine bakın size_type

hash_set::swap

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

İki hash_sets öğelerini değiştirir.

void swap(hash_set& right);

Parametreler

Sağ
bağımsız değişkeni, hedef hash_set ile değiştirilecek öğeleri sağlayan hash_set.

Açıklamalar

Üye işlevi, öğeleri değiş tokuş edilen iki hash_sets öğeleri belirten hiçbir başvuruyu, işaretçiyi veya yineleyiciyi geçersiz kılmaz.

Örnek

// hash_set_swap.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1, hs2, hs3;
   hash_set <int>::iterator hs1_Iter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );
   hs2.insert( 100 );
   hs2.insert( 200 );
   hs3.insert( 300 );

   cout << "The original hash_set hs1 is:";
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );
         hs1_Iter++ )
         cout << " " << *hs1_Iter;
   cout   << "." << endl;

   // This is the member function version of swap
   hs1.swap( hs2 );

   cout << "After swapping with hs2, list hs1 is:";
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );
         hs1_Iter++ )
         cout << " " << *hs1_Iter;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( hs1, hs3 );

   cout << "After swapping with hs3, list hs1 is:";
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );
         hs1_Iter++ )
         cout << " " << *hs1_Iter;
   cout   << "." << endl;
}

The original hash_set hs1 is: 10 20 30.
After swapping with hs2, list hs1 is: 200 100.
After swapping with hs3, list hs1 is: 300.

hash_set::upper_bound

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

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

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Parametreler

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

Dönüş Değeri

bir iterator hash_set bağımsız değişken anahtarına eşit veya ondan büyük bir anahtarla veya anahtar için eşleşme bulunamazsa hash_set son öğeyi tamamlayan konumu ele alan bir veya const_iterator öğesinin konumunu giderir.

Örnek

// hash_set_upper_bound.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_RcIter = hs1.upper_bound( 20 );
   cout << "The first element of hash_set hs1 with a key greater "
        << "than 20 is: " << *hs1_RcIter << "." << endl;

   hs1_RcIter = hs1.upper_bound( 30 );

   // If no match is found for the key, end( ) is returned
   if ( hs1_RcIter == hs1.end( ) )
      cout << "The hash_set hs1 doesn't have an element "
           << "with a key greater than 30." << endl;
   else
      cout << "The element of hash_set hs1 with a key > 40 is: "
           << *hs1_RcIter << "." << endl;

   // An element at a specific location in the hash_set can be found
   // by using a dereferenced iterator addressing the location
   hs1_AcIter = hs1.begin( );
   hs1_RcIter = hs1.upper_bound( *hs1_AcIter );
   cout << "The first element of hs1 with a key greater than "
        << endl << "that of the initial element of hs1 is: "
        << *hs1_RcIter << "." << endl;
}

The first element of hash_set hs1 with a key greater than 20 is: 30.
The hash_set hs1 doesn't have an element with a key greater than 30.
The first element of hs1 with a key greater than
that of the initial element of hs1 is: 20.

hash_set::value_comp

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Bir hash_set öğ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 hash_set öğelerini sıralamak için kullandığı işlev nesnesini döndürür. Bu, Karşılaştır şablon parametresidir.

Karşılaştırma hakkında daha fazla bilgi için hash_set Sınıfı konusunun Açıklamalar bölümüne bakın.

Açıklamalar

Depolanan nesne üye işlevini tanımlar:

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

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

Hem value_compare hem de key_compare, Karşılaştır şablon parametresinin eş anlamlıları olduğunu unutmayın. Her iki tür de hash_set ve hash_multiset sınıfları için sağlanır ve burada aynı olan sınıflar, hash_map ve hash_multimap sınıfları ile uyumluluk açısından ayrıdır.

Örnek

// hash_set_value_comp.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_set <int, hash_compare < int, less<int> > > hs1;
   hash_set <int, hash_compare < int, less<int> >  >::value_compare
      vc1 = hs1.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 hs1."
           << endl;
   }
   else
   {
      cout << "vc1( 2,3 ) returns value of false, "
           << "where vc1 is the function object of hs1."
           << endl;
   }

   hash_set <int, hash_compare < int, greater<int> > > hs2;
   hash_set<int, hash_compare < int, greater<int> > >::value_compare
      vc2 = hs2.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 hs2."
           << endl;
   }
   else
   {
      cout << "vc2( 2,3 ) returns value of false, "
           << "where vc2 is the function object of hs2."
           << endl;
   }
}

hash_set::value_compare

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

İki işlev nesnesi sağlayan bir tür, göreli sırasını belirlemek için bir hash_set iki öğe değerini karşılaştırabilen bir sınıf karşılaştırması ikili koşulu ve öğeleri karma oluşturan bir birli koşul.

typedef key_compare value_compare;

Açıklamalar

value_compare , Traits şablon parametresinin eş anlamlısıdır.

Özellikler hakkında daha fazla bilgi için hash_set Sınıfı konusuna bakın.

Hem key_compareşablon parametresiNin value_compare olduğunu unutmayın. Her iki tür de hash_set ve hash_multiset sınıfları için sağlanır ve burada aynı olan sınıflar, hash_map ve hash_multimap sınıfları ile uyumluluk açısından ayrıdır.

Örnek

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

hash_set::value_type

Not

Bu, API artık kullanılmıyor. Alternatif olarak sınıfı unordered_set.

Kapasitedeki bir hash_set öğesi olarak depolanan bir nesneyi değer olarak tanımlayan tür.

typedef Key value_type;

Örnek

// hash_set_value_type.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;

   hash_set <int> :: value_type hsvt_Int;   // Declare value_type
   hsvt_Int = 10;             // Initialize value_type

   hash_set <int> :: key_type hskt_Int;   // Declare key_type
   hskt_Int = 20;             // Initialize key_type

   hs1.insert( hsvt_Int );         // Insert value into hs1
   hs1.insert( hskt_Int );         // Insert key into hs1

   // A hash_set accepts key_types or value_types as elements
   cout << "The hash_set has elements:";
   for ( hs1_Iter = hs1.begin( ) ; hs1_Iter != hs1.end( ); hs1_Iter++)
      cout << " " << *hs1_Iter;
   cout << "." << endl;
}

The hash_set has elements: 10 20.

Ayrıca bkz.

C++ Standart Kitaplığında İş Parçacığı Güvenliği
C++ Standart Kitaplığı Başvurusu

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-11-07

Aracılığıyla paylaş

hash_set Sınıfı

Sözdizimi

Parametreler

Açıklamalar

Oluşturucular

Tür tanımları

Üye işlevleri

İşleçler

Gereksinimler

hash_set::allocator_type

Açıklamalar

Örnek

hash_set::begin

Dönüş Değeri

Açıklamalar

Örnek

hash_set::cbegin

Dönüş Değeri

Açıklamalar

Örnek

hash_set::cend

Dönüş Değeri

Açıklamalar

Örnek

hash_set::clear

Örnek

hash_set::const_iterator

Açıklamalar

Örnek

hash_set::const_pointer

Açıklamalar

hash_set::const_reference

Örnek

hash_set::const_reverse_iterator

Açıklamalar

Örnek

hash_set::count

Parametreler

Dönüş Değeri

Açıklamalar

Örnek

hash_set::crbegin

Dönüş Değeri

Açıklamalar

Örnek

hash_set::crend

Dönüş Değeri

Açıklamalar

Örnek

hash_set::d ifference_type

Açıklamalar

Örnek

hash_set::emplace

Parametreler

Dönüş Değeri

Örnek

hash_set::emplace_hint

Parametreler

Dönüş Değeri

Açıklamalar

Örnek

hash_set::empty

Dönüş Değeri

Örnek

hash_set::end

Dönüş Değeri

Açıklamalar

Örnek

hash_set::equal_range

Parametreler

Dönüş Değeri

Örnek

hash_set::erase

Parametreler

Dönüş Değeri

Açıklamalar

Örnek

hash_set::find

Parametreler