`multimap` Sınıf

C++ Standart Kitaplığı çoklu eşleme sınıfı, her öğenin hem veri değerine hem de sıralama anahtarına sahip bir çift olduğu bir koleksiyondan veri depolamak ve almak için kullanılır. Anahtarın değerinin benzersiz olması gerekmez ve verileri otomatik olarak sıralamak için kullanılır. Çoklu eşlemdeki bir öğenin değeri doğrudan değiştirilebilir, ancak ilişkili anahtar değeri doğrudan değiştirilemez. Bunun yerine, eski öğelerle ilişkili anahtar değerleri silinmeli ve eklenen yeni öğelerle ilişkili yeni anahtar değerleri eklenmelidir.

Sözdizimi

template <class Key,
    class Type,
    class Traits=less <Key>,
    class Allocator=allocator <pair  <const Key, Type>>>
class multimap;

Parametreler

Key
Çoklu eşlemde depolanacak anahtar veri türü.

Type
Çoklu eşlemde depolanacak öğe veri türü.

Traits
İki öğenin değerlerini çoklu eşlemde 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. İkili 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şkisel Kapsayıcılarda Heterojen Arama

Allocator
Eşlemin 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<pair <const Key, Type> >.

Açıklamalar

C++ Standart Kitaplığı çoklu eşleme sınıfı şudur:

İ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ı.
Çift yönlüdür, çünkü öğelerine erişmek için çift yönlü yineleyiciler 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.
Birden çok, çünkü öğelerinin benzersiz bir anahtara sahip olması gerekmez, böylece bir anahtar değeri onunla ilişkilendirilmiş çok sayıda öğe veri değerine sahip olabilir.
Bir çift ilişkilendirilebilir kapsayıcıdır, çünkü veri öğelerinin değerleri kendi anahtar değerlerinden farklıdır.
Sınıf şablonu, sağladığı işlevsellik genel olduğundan ve öğeler veya anahtarlar olarak yer alan belirli veri türlerinden çok bağımsızdır. Öğ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.

Eşleme sınıfı tarafından sağlanan yineleyici çift yönlü bir yineleyicidir, ancak sınıf üyesi işlevleri insert ve multimap şablon parametresi olarak işlev gereksinimleri çift yönlü yineleyiciler sınıfı tarafından garanti edilenlerden daha düşük olan 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ın üye işlevleri bağlamında bir dizi yineleyici [First, Last) hakkında anlamlı bir şekilde konuşabilmek yeterlidir.

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, işlevlerini kapsayıcıdaki öğelerin sayısının logaritmasına ortalama orantılı bir sürede gerçekleştirir ve verimlidir. Öğ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ılır.

multimap, değerleri anahtarlarıyla ilişkilendiren koşullar uygulama tarafından karşılandığında tercih edilen ilişkilendirilebilir kapsayıcı olmalıdır. Bu tür bir yapı için model, sözcüklerin her zaman benzersiz olarak tanımlanmadığı, örneğin tanımları sağlayan ilişkili dize değerlerine sahip anahtar sözcüklerin sıralı bir listesidir. Bunun yerine anahtar sözcükler benzersiz olarak tanımlanırsa, seçilecek kapsayıcı bir eşlem olurdu. Diğer taraftan, yalnızca sözcüklerin listesi depolanmaktadır, ardından bir küme doğru kapsayıcı olacaktır. Sözcüklerin birden çok örneğine izin verilseydi, multiset uygun kapsayıcı yapısı olacaktır.

türündeki multimap bir saklı işlev nesnesini çağırarak denetlediği sırayı key_comparesıralar. Bu depolanan nesne, üye işlevi çağrılarak erişilebilen bir karşılaştırma işlevidir key_comp. 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, 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şulf(x,y), iki bağımsız değişken nesnesine ve x veya ydönüş değerine sahip bir işlev nesnesidir truefalse. Bir kümeye uygulanan sıralama, ikili koşulun esnek olmayan, antisymetrik ve geçişli olması ve denkliğin geçişli olması durumunda, iki nesnenin ve her ikisi olduğunda xy eşdeğer olarak tanımlandığı katı bir zayıf sıralamadırf(x,y).f(y,x)false 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.

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.

Üyeler

Oluşturucular

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

Tür tanımları

Tür adı	Açıklama
`allocator_type`	Nesnenin sınıfını `allocatormultimap` temsil eden bir tür.
`const_iterator`	içindeki bir öğeyi `const`okuyabilen çift yönlü bir yineleyici sağlayan tür`multimap`.
`const_pointer`	içindeki bir `const` öğeye işaretçi sağlayan tür `multimap`.
`const_reference`	okuma ve gerçekleştirme `const` işlemleri için içinde `multimap` depolanan bir `const` öğeye başvuru sağlayan bir tür.
`const_reverse_iterator`	içindeki `const`herhangi `multimap` 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 `multimap` sayısını göstermek için kullanılabilecek imzalı bir tamsayı türü.
`iterator`	Aynı `multimap`içindeki öğelere başvuran iki yineleyici arasındaki farkı sağlayan bir tür.
`key_compare`	içindeki iki öğeye `multimap`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`	öğesinin her öğesini `multimap`oluşturan sıralama anahtarı nesnesini açıklayan bir tür.
`mapped_type`	içinde depolanan veri türünü temsil eden bir `multimap`tür.
`pointer`	içindeki bir `const` öğeye işaretçi sağlayan tür `multimap`.
`reference`	içinde depolanan bir öğeye başvuru sağlayan tür `multimap`.
`reverse_iterator`	Ters çevrilmiş `multimap`içindeki bir öğeyi okuyabilen veya değiştirebilen çift yönlü bir yineleyici sağlayan tür.
`size_type`	içindeki bir öğeye işaretçi sağlayan işaretsiz bir `const``multimap`tamsayı türü.
`value_type`	içinde göreli düzenlerini `multimap`belirlemek için iki öğeyi sıralama anahtarları olarak karşılaştırabilen bir işlev nesnesi sağlayan tür.

Üye işlevleri

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

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

Gereksinimler

Üstbilgi:<map>

Ad alanı: std

( anahtar, değer) çiftleri türünde multimapnesneler pair olarak depolanır. Pair sınıfı, tarafından <utility>otomatik olarak dahil edilen üst bilgisini <map>gerektirir.

`multimap::allocator_type`

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

typedef Allocator allocator_type;

Örnek

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

`multimap::begin`

içindeki ilk öğeyi multimapele alan bir yineleyici döndürür.

const_iterator begin() const;

iterator begin();

Dönüş Değeri

veya konumundaki ilk öğeyi multimap ele alan ve boş multimapbir öğesinin başarılı olduğu çift yönlü yineleyici.

Örnek

// multimap_begin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: iterator m1_Iter;
   multimap <int, int> :: const_iterator m1_cIter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 0, 0 ) );
   m1.insert ( Int_Pair ( 1, 1 ) );
   m1.insert ( Int_Pair ( 2, 4 ) );

   m1_cIter = m1.begin ( );
   cout << "The first element of m1 is " << m1_cIter -> first << endl;

   m1_Iter = m1.begin ( );
   m1.erase ( m1_Iter );

   // The following 2 lines would err as the iterator is const
   // m1_cIter = m1.begin ( );
   // m1.erase ( m1_cIter );

   m1_cIter = m1.begin( );
   cout << "First element of m1 is now " << m1_cIter -> first << endl;
}

The first element of m1 is 0
First element of m1 is now 1

`multimap::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

`multimap::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.

`multimap::clear`

öğesinin multimaptüm öğelerini siler.

void clear();

Örnek

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

// multimap_clear.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap<int, int> m1;
   multimap<int, int>::size_type i;
   typedef pair<int, int> Int_Pair;

   m1.insert(Int_Pair(1, 1));
   m1.insert(Int_Pair(2, 4));

   i = m1.size();
   cout << "The size of the multimap is initially "
        << i << "." << endl;

   m1.clear();
   i = m1.size();
   cout << "The size of the multimap after clearing is "
        << i << "." << endl;
}

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

`multimap::const_iterator`

içindeki bir öğeyi constokuyabilen çift yönlü bir yineleyici sağlayan türmultimap.

typedef implementation-defined const_iterator;

Açıklamalar

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

const_iterator tarafından tanımlananmultimap, türünde value_typeolan nesnelerine pair<const Key, Type>işaret eder. Anahtarın değeri ilk üye çifti aracılığıyla kullanılabilir ve eşlenen öğenin değeri çiftin ikinci üyesi aracılığıyla kullanılabilir.

içindeki bir const_iteratorcIter öğeye işaret eden bir başvuruyu multimapgeri almak için işlecini -> kullanın.

öğesinin anahtarının değerine erişmek için, cIter->firstile eşdeğer (*cIter).firstolan kullanın. öğesinin eşlenmiş veri kümesinin değerine erişmek için öğesine cIter->secondeşdeğer (*cIter).secondolan kullanın.

Örnek

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

`multimap::const_pointer`

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

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, nesnedeki iteratormultimap öğelere erişmek için bir kullanılmalıdır.

`multimap::const_reference`

okuma ve gerçekleştirme const işlemleri için içinde multimap depolanan bir const öğeye başvuru sağlayan bir tür.

typedef typename allocator_type::const_reference const_reference;

Örnek

// multimap_const_ref.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );

   // Declare and initialize a const_reference &Ref1
   // to the key of the first element
   const int &Ref1 = ( m1.begin( ) -> first );

   // The following line would cause an error because the
   // non-const_reference can't be used to access the key
   // int &Ref1 = ( m1.begin( ) -> first );

   cout << "The key of the first element in the multimap is "
        << Ref1 << "." << endl;

   // Declare and initialize a reference &Ref2
   // to the data value of the first element
   int &Ref2 = ( m1.begin( ) -> second );

   cout << "The data value of the first element in the multimap is "
        << Ref2 << "." << endl;
}

The key of the first element in the multimap is 1.
The data value of the first element in the multimap is 10.

`multimap::const_reverse_iterator`

içindeki constherhangi multimap 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 öğesini tersten yinelemek multimap için kullanılır.

const_reverse_iterator tarafından tanımlananmultimap, türünde value_typeolan nesnelerine pair<const Key, Type>işaret eder. Anahtarın değeri ilk üye çifti aracılığıyla kullanılabilir ve eşlenen öğenin değeri çiftin ikinci üyesi aracılığıyla kullanılabilir.

Çoklu haritadaki bir const_reverse_iteratorcrIter öğeye işaret eden bir başvuruyu geri almak için işlecini -> kullanın.

öğesinin anahtarının değerine erişmek için, crIter->firstile eşdeğer (*crIter).firstolan kullanın. öğesinin eşlenmiş veri kümesinin değerine erişmek için öğesine crIter->secondeşdeğer (*crIter).firstolan kullanın.

Örnek

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

`multimap::contains`

içinde multimapbelirtilen 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 kapsayıcıda bulunursa; false yoksa.

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 <map>
#include <string>
#include <iostream>
#include <functional>

int main()
{
    std::multimap<int, bool> m = {{0, false}, {1, true}};

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << m.contains(1) << '\n';
    std::cout << m.contains(2) << '\n';

    // call template function
    std::multimap<std::string, int, std::less<>> m2 = {{"ten", 10}, {"twenty", 20}, {"thirty", 30}};
    std::cout << m2.contains("ten");

    return 0;
}

true
false
true

`multimap::count`

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

size_type count(const Key& key) const;

Parametreler

key
Çoklu eşlemeden eşleştirilecek öğelerin anahtarı.

Dönüş Değeri

Sıralama anahtarları parametre anahtarıyla eşleşen öğelerin sayısı; Çoklu harita eşleşen anahtara sahip bir öğe içermiyorsa 0.

Açıklamalar

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

lower_bound(key), upper_bound(key)

anahtar değerine keysahip.

Örnek

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

// multimap_count.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
    using namespace std;
    multimap<int, int> m1;
    multimap<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    m1.insert(Int_Pair(1, 1));
    m1.insert(Int_Pair(2, 1));
    m1.insert(Int_Pair(1, 4));
    m1.insert(Int_Pair(2, 1));

    // Elements don't need to have unique keys in multimap,
    // so duplicates are allowed and counted
    i = m1.count(1);
    cout << "The number of elements in m1 with a sort key of 1 is: "
         << i << "." << endl;

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

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

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

`multimap::crbegin`

ters çevrilmiş constbir multimap içindeki ilk öğeyi ele alan bir yineleyici döndürür.

const_reverse_iterator crbegin() const;

Dönüş Değeri

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

Açıklamalar

crbegin, ile kullanıldığı gibi multimap ters çevrilmiş begin bir multimapile kullanılır.

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

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

Örnek

// multimap_crbegin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );

   m1_crIter = m1.crbegin( );
   cout << "The first element of the reversed multimap m1 is "
        << m1_crIter -> first << "." << endl;
}

The first element of the reversed multimap m1 is 3.

`multimap::crend`

Ters çevrilmiş constbir multimap içindeki son öğeden sonra gelen konumu ele alan bir yineleyici döndürür.

const_reverse_iterator crend() const;

Dönüş Değeri

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

Açıklamalar

crend, ile kullanıldığı gibi multimap ters çevrilmiş multimap::end bir multimapile kullanılır.

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

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

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

Örnek

// multimap_crend.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );

   m1_crIter = m1.crend( );
   m1_crIter--;
   cout << "The last element of the reversed multimap m1 is "
        << m1_crIter -> first << "." << endl;
}

The last element of the reversed multimap m1 is 1.

`multimap::difference_type`

Yineleyiciler tarafından işaret edilen öğeler arasındaki bir aralıktaki öğelerinin multimap sayısını göstermek için kullanılabilecek imzalı 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 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 ettiği 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

// multimap_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <map>
#include <algorithm>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 3, 20 ) );

   // The following will insert as multimap keys are not unique
   m1.insert ( Int_Pair ( 2, 30 ) );

   multimap <int, int>::iterator m1_Iter, m1_bIter, m1_eIter;
   m1_bIter = m1.begin( );
   m1_eIter = m1.end( );

   // Count the number of elements in a multimap
   multimap <int, int>::difference_type  df_count = 0;
   m1_Iter = m1.begin( );
   while ( m1_Iter != m1_eIter )
   {
      df_count++;
      m1_Iter++;
   }

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

The number of elements in the multimap m1 is: 4.

`multimap::emplace`

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

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

Parametreler

args
içine eklenecek bir öğe oluşturmak için iletilen multimapbağımsız değişkenler.

Dönüş Değeri

Yeni eklenen öğeye bir yineleyici.

Açıklamalar

Bu işlev, kapsayıcı öğelerine yapılan başvurular geçersiz kılınmasa da kapsayıcıdaki tüm yineleyicileri geçersiz kılabilir.

Ekleme sırasında bir özel durum oluşturulursa kapsayıcı değiştirilmeden bırakılır ve özel durum yeniden oluşturulur.

value_type Bir öğenin değeri bir çifttir, böylece bir öğenin değeri ilk bileşen anahtar değerine eşit, ikinci bileşen de öğenin veri değerine eşit olan sıralı bir çift olur.

Örnek

// multimap_emplace.cpp
// compile with: /EHsc
#include <map>
#include <string>
#include <iostream>

using namespace std;

template <typename M> void print(const M& m) {
    cout << m.size() << " elements: " << endl;

    for (const auto& p : m) {
        cout << "(" << p.first <<  "," << p.second << ") ";
    }

    cout << endl;
}

int main()
{
    multimap<string, string> m1;

    m1.emplace("Anna", "Accounting");
    m1.emplace("Bob", "Accounting");
    m1.emplace("Carmine", "Engineering");

    cout << "multimap modified, now contains ";
    print(m1);
    cout << endl;

    m1.emplace("Bob", "Engineering");

    cout << "multimap modified, now contains ";
    print(m1);
    cout << endl;
}

`multimap::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
içine eklenecek bir öğe oluşturmak için iletilen multimapbağımsız değişkenler.

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.

Açıklamalar

Bu işlev, kapsayıcı öğelerine yapılan başvurular geçersiz kılınmasa da kapsayıcıdaki tüm yineleyicileri geçersiz kılabilir.

Bir özel durum oluşturulursa, yer değiştirme sırasında kapsayıcının durumu değiştirilmez.

value_type Bir öğenin değeri bir çifttir, böylece bir öğenin değeri ilk bileşen anahtar değerine eşit, ikinci bileşen de öğenin veri değerine eşit olan sıralı bir çift olur.

Kod örneği için bkz map::emplace_hint. .

`multimap::empty`

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

bool empty() const;

Dönüş Değeri

true multimap boşsa; falsemultimap yoksa.

Örnek

// multimap_empty.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1, m2;

   typedef pair <int, int> Int_Pair;
   m1.insert ( Int_Pair ( 1, 1 ) );

   if ( m1.empty( ) )
      cout << "The multimap m1 is empty." << endl;
   else
      cout << "The multimap m1 is not empty." << endl;

   if ( m2.empty( ) )
      cout << "The multimap m2 is empty." << endl;
   else
      cout << "The multimap m2 is not empty." << endl;
}

The multimap m1 is not empty.
The multimap m2 is empty.

`multimap::end`

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

const_iterator end() const;

iterator end();

Dönüş Değeri

Son zaman yineleyicisi. multimap boşsa, öğesini seçinmultimap::end() == multimap::begin().

Açıklamalar

end , yineleyicinin sonunu multimapgeç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 multimap::find. .

`multimap::equal_range`

Öğenin anahtarının belirtilen değerle eşleştiği öğeler aralığını bulur.

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

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

Parametreler

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

Dönüş Değeri

Birincisi anahtarın, ikincisi de anahtarın çifti olacak lower_bound şekilde upper_bound bir çift yineleyici.

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

Örnek

// multimap_equal_range.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   typedef multimap <int, int, less<int> > IntMMap;
   IntMMap m1;
   multimap <int, int> :: const_iterator m1_RcIter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );

   pair <IntMMap::const_iterator, IntMMap::const_iterator> p1, p2;
   p1 = m1.equal_range( 2 );

   cout << "The lower bound of the element with "
        << "a key of 2 in the multimap m1 is: "
        << p1.first -> second << "." << endl;

   cout << "The upper bound of the element with "
        << "a key of 2 in the multimap m1 is: "
        << p1.second -> second << "." << endl;

   // Compare the upper_bound called directly
   m1_RcIter = m1.upper_bound( 2 );

   cout << "A direct call of upper_bound( 2 ) gives "
        << m1_RcIter -> second << "," << endl
        << "matching the 2nd element of the pair "
        << "returned by equal_range( 2 )." << endl;

   p2 = m1.equal_range( 4 );

   // If no match is found for the key,
   // both elements of the pair return end( )
   if ( ( p2.first == m1.end( ) ) && ( p2.second == m1.end( ) ) )
      cout << "The multimap m1 doesn't have an element "
           << "with a key less than 4." << endl;
   else
      cout << "The element of multimap m1 with a key >= 40 is: "
           << p1.first -> first << "." << endl;
}

The lower bound of the element with a key of 2 in the multimap m1 is: 20.
The upper bound of the element with a key of 2 in the multimap m1 is: 30.
A direct call of upper_bound( 2 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 2 ).
The multimap m1 doesn't have an element with a key less than 4.

`multimap::erase`

Belirtilen konumlardan bir öğeyi veya bir multimap öğe aralığını 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ı.

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 eşlemenin sonu olan bir öğe.

Üçüncü üye işlevi için, öğesinden multimapkaldırılan öğe sayısını döndürür.

Açıklamalar

Kod örneği için bkz map::erase. .

`multimap::find`

Belirtilen anahtara eşdeğer bir anahtara sahip bir öğenin multimap ilk 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 öğenin multimap 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 (multimap) içindeki multimap::end() son öğenin başarılı olduğu konuma başvuran bir yineleyici.

Açıklamalar

Üye işlevi, sıralama anahtarı, karşılaştırılabilirlikten küçük bir ilişkiyi temel alan bir sıralamaya neden olan ikili koşul altındaki bağımsız değişken anahtarına eşdeğer olan bir öğeye multimap başvuran bir yineleyici döndürür.

değerinin dönüş değeri find bir const_iteratormultimap öğesine atanmışsa nesnesi değiştirilemez. dönüş değeri find bir iteratormultimap öğesine atanmışsa nesnesi değiştirilebilir.

Örnek

// compile with: /EHsc /W4 /MTd
#include <map>
#include <iostream>
#include <vector>
#include <string>
#include <utility>  // make_pair()

using namespace std;

template <typename A, typename B> void print_elem(const pair<A, B>& p) {
    cout << "(" << p.first << ", " << p.second << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

template <typename C, class T> void findit(const C& c, T val) {
    cout << "Trying find() on value " << val << endl;
    auto result = c.find(val);
    if (result != c.end()) {
        cout << "Element found: "; print_elem(*result); cout << endl;
    } else {
        cout << "Element not found." << endl;
    }
}

int main()
{
    multimap<int, string> m1({ { 40, "Zr" }, { 45, "Rh" } });
    cout << "The starting multimap m1 is (key, value):" << endl;
    print_collection(m1);

    vector<pair<int, string>> v;
    v.push_back(make_pair(43, "Tc"));
    v.push_back(make_pair(41, "Nb"));
    v.push_back(make_pair(46, "Pd"));
    v.push_back(make_pair(42, "Mo"));
    v.push_back(make_pair(44, "Ru"));
    v.push_back(make_pair(44, "Ru")); // attempt a duplicate

    cout << "Inserting the following vector data into m1:" << endl;
    print_collection(v);

    m1.insert(v.begin(), v.end());

    cout << "The modified multimap m1 is (key, value):" << endl;
    print_collection(m1);
    cout << endl;
    findit(m1, 45);
    findit(m1, 6);
}

`multimap::get_allocator`

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

allocator_type get_allocator() const;

Dönüş Değeri

tarafından multimapkullanılan ayırıcı.

Açıklamalar

sınıfı için ayırıcılar, sınıfın multimap 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

// multimap_get_allocator.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int>::allocator_type m1_Alloc;
   multimap <int, int>::allocator_type m2_Alloc;
   multimap <int, double>::allocator_type m3_Alloc;
   multimap <int, int>::allocator_type m4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   multimap <int, int> m1;
   multimap <int, int, allocator<int> > m2;
   multimap <int, double, allocator<double> > m3;

   m1_Alloc = m1.get_allocator( );
   m2_Alloc = m2.get_allocator( );
   m3_Alloc = m3.get_allocator( );

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

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

   // The following line creates a multimap m4
   // with the allocator of multimap m1.
   map <int, int> m4( less<int>( ), m1_Alloc );

   m4_Alloc = m4.get_allocator( );

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

`multimap::insert`

içine bir öğe veya öğe multimaparalığı 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
içine eklenecek multimapöğenin değeri.

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

ValTy
Eşlemenin öğesini value_typeoluşturmak için kullanabileceği bağımsız değişken türünü belirten şablon parametresi ve bağımsız değişken olarak kusursuz iletme.Val

First
Kopyalanacak ilk öğenin konumu.

Last
Kopyalanacak son öğenin hemen ötesindeki konum.

InputIterator
Nesneleri oluşturmak input için kullanılabilecek türde gereksinimlerini karşılayan şablon işlevi bağımsız değişkeni.

IList
initializer_list Öğelerin kopyalandığı yer.

Dönüş Değeri

(1) ve (2) tek öğeli ekleme üye işlevleri, yeni öğenin içine eklendiği multimapkonuma bir yineleyici döndürür.

İpucuyla tek öğeli üye işlevleri (3) ve (4), yeni öğenin içine multimapeklendiği konumu gösteren bir yineleyici döndürür.

Açıklamalar

Bu işlev tarafından hiçbir işaretçi veya başvuru geçersiz kılınmamış, ancak kapsayıcıdaki tüm yineleyicileri geçersiz kılabilir.

Yalnızca bir öğenin eklenmesi sırasında özel durum oluşturulursa 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.

value_type Kapsayıcının türü, kapsayıcıya ait olan bir tür tanımıdır ve eşleme multimap<K, V>::value_type için ise şeklindedirpair<const K, V>. Öğenin değeri, ilk bileşenin anahtar değerine, ikinci bileşenin ise öğenin veri değerine eşit olduğu sıralı bir çifttir.

Aralık üye işlevi (5), öğe değerlerinin dizisini aralıktaki multimapbir [First, Last) yineleyici tarafından adreslenen her öğeye karşılık gelen öğesine ekler; bu nedenle Last eklenmez. Kapsayıcı üyesi işlevi end() , kapsayıcıdaki son öğeden hemen sonraki konuma başvurur; örneğin, deyimi m.insert(v.begin(), v.end()); tüm öğelerini v içine mekler.

Başlatıcı listesi üye işlevi (6), öğeleri eşlem içine 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 multimap::emplace . ve multimap::emplace_hint.

Örnek

// multimap_insert.cpp
// compile with: /EHsc
#include <map>
#include <iostream>
#include <string>
#include <vector>
#include <utility>  // make_pair()

using namespace std;

template <typename M> void print(const M& m) {
    cout << m.size() << " elements: ";

    for (const auto& p : m) {
        cout << "(" << p.first << ", " << p.second << ") ";
    }

    cout << endl;
}

int main()
{
    // insert single values
    multimap<int, int> m1;
    // call insert(const value_type&) version
    m1.insert({ 1, 10 });
    // call insert(ValTy&&) version
    m1.insert(make_pair(2, 20));

    cout << "The original key and mapped values of m1 are:" << endl;
    print(m1);

    // intentionally attempt a duplicate, single element
    m1.insert(make_pair(1, 111));

    cout << "The modified key and mapped values of m1 are:" << endl;
    print(m1);

    // single element, with hint
    m1.insert(m1.end(), make_pair(3, 30));
    cout << "The modified key and mapped values of m1 are:" << endl;
    print(m1);
    cout << endl;

    // The templatized version inserting a jumbled range
    multimap<int, int> m2;
    vector<pair<int, int>> v;
    v.push_back(make_pair(43, 294));
    v.push_back(make_pair(41, 262));
    v.push_back(make_pair(45, 330));
    v.push_back(make_pair(42, 277));
    v.push_back(make_pair(44, 311));

    cout << "Inserting the following vector data into m2:" << endl;
    print(v);

    m2.insert(v.begin(), v.end());

    cout << "The modified key and mapped values of m2 are:" << endl;
    print(m2);
    cout << endl;

    // The templatized versions move-constructing elements
    multimap<int, string>  m3;
    pair<int, string> ip1(475, "blue"), ip2(510, "green");

    // single element
    m3.insert(move(ip1));
    cout << "After the first move insertion, m3 contains:" << endl;
    print(m3);

    // single element with hint
    m3.insert(m3.end(), move(ip2));
    cout << "After the second move insertion, m3 contains:" << endl;
    print(m3);
    cout << endl;

    multimap<int, int> m4;
    // Insert the elements from an initializer_list
    m4.insert({ { 4, 44 }, { 2, 22 }, { 3, 33 }, { 1, 11 }, { 5, 55 } });
    cout << "After initializer_list insertion, m4 contains:" << endl;
    print(m4);
    cout << endl;
}

`multimap::iterator`

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

typedef implementation-defined iterator;

Açıklamalar

iterator tarafından tanımlananmultimap, türünde value_typeolan nesnelerine pair<const Key, Type>işaret eder. Anahtarın değeri ilk üye çifti aracılığıyla kullanılabilir ve eşlenen öğenin değeri çiftin ikinci üyesi aracılığıyla kullanılabilir.

içindeki bir iteratorIter öğeye işaret eden bir multimapbaşvuruyu geri almak için işlecini -> kullanın.

öğesinin anahtarının değerine erişmek için, Iter->firstile eşdeğer (*Iter).firstolan kullanın. öğesinin eşlenmiş veri kümesinin değerine erişmek için öğesine Iter->secondeşdeğer (*Iter).secondolan kullanın.

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

Örnek

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

`multimap::key_comp`

içindeki anahtarları sıralamak için kullanılan karşılaştırma nesnesinin bir multimapkopyasını alır.

key_compare key_comp() const;

Dönüş Değeri

öğesinin multimap öğelerini sıralamak için kullandığı işlev nesnesini döndürür.

Açıklamalar

Depolanan nesne üye işlevini tanımlar

bool operator( const Key& x, const Key& y);

sıralama düzeninden önce x gelirse y true döndürür.

Örnek

// multimap_key_comp.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;

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

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

kc1( 2,3 ) returns value of true, where kc1 is the function object of m1.
kc2( 2,3 ) returns value of false, where kc2 is the function object of m2.

`multimap::key_compare`

içindeki iki öğeye multimapgöre sırasını belirlemek için iki sıralama anahtarını karşılaştırabilen bir işlev nesnesi sağlayan 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ıfmultimap bakın.

Örnek

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

`multimap::key_type`

öğesinin her öğesini multimapoluşturan sıralama anahtarı nesnesini açıklayan bir 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ıfmultimap bakın.

Örnek

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

`multimap::lower_bound`

Belirtilen anahtara eşit veya bundan büyük bir multimap anahtara sahip olan bir içindeki ilk öğeye bir yineleyici döndürür.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

Parametreler

key
Aranmakta olan öğenin multimap 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 içindeki bir öğenin multimap 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 içindeki multimap son öğeyi tamamlayan konumu ele alan bir yineleyici.

değerinin dönüş değeri lower_bound bir const_iteratormultimap öğesine atanmışsa nesnesi değiştirilemez. değerinin dönüş değeri lower_bound bir yineleyiciye atanmışsa, multimap nesnesi değiştirilebilir.

Örnek

// multimap_lower_bound.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   multimap <int, int> :: const_iterator m1_AcIter, m1_RcIter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );

   m1_RcIter = m1.lower_bound( 2 );
   cout << "The element of multimap m1 with a key of 2 is: "
        << m1_RcIter -> second << "." << endl;

   m1_RcIter = m1.lower_bound( 3 );
   cout << "The first element of multimap m1 with a key of 3 is: "
        << m1_RcIter -> second << "." << endl;

   // If no match is found for the key, end( ) is returned
   m1_RcIter = m1.lower_bound( 4 );

   if ( m1_RcIter == m1.end( ) )
      cout << "The multimap m1 doesn't have an element "
              << "with a key of 4." << endl;
   else
      cout << "The element of multimap m1 with a key of 4 is: "
                << m1_RcIter -> second << "." << endl;

   // The element at a specific location in the multimap can be
   // found using a dereferenced iterator addressing the location
   m1_AcIter = m1.end( );
   m1_AcIter--;
   m1_RcIter = m1.lower_bound( m1_AcIter -> first );
   cout << "The first element of m1 with a key matching\n"
        << "that of the last element is: "
        << m1_RcIter -> second << "." << endl;

   // Note that the first element with a key equal to
   // the key of the last element is not the last element
   if ( m1_RcIter == --m1.end( ) )
      cout << "This is the last element of multimap m1."
           << endl;
   else
      cout << "This is not the last element of multimap m1."
           << endl;
}

The element of multimap m1 with a key of 2 is: 20.
The first element of multimap m1 with a key of 3 is: 20.
The multimap m1 doesn't have an element with a key of 4.
The first element of m1 with a key matching
that of the last element is: 20.
This is not the last element of multimap m1.

`multimap::mapped_type`

içinde depolanan veri türünü temsil eden bir multimaptür.

typedef Type mapped_type;

Açıklamalar

mapped_type , şablon parametresinin Typeeş anlamlısıdır.

hakkında Typedaha fazla bilgi için Sınıfmultimap bakın.

Örnek

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

`multimap::max_size`

değerinin uzunluk üst sınırını multimapdöndürür.

size_type max_size() const;

Dönüş Değeri

mümkün olan en uzun uzunluk multimap.

Örnek

// multimap_max_size.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   multimap <int, int> :: size_type i;

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

`multimap::multimap`

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

multimap();

explicit multimap(
    const Traits& Comp);

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

map(
    const multimap& Right);

multimap(
    multimap&& Right);

multimap(
    initializer_list<value_type> IList);

multimap(
    initializer_list<value_type> IList,
    const Compare& Comp);

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

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

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

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

Parametreler

Al
Varsayılan olarak Ayırıcı olan bu çoklu harita nesnesi için kullanılacak depolama ayırıcı sınıfı.

Comp
Eşlemedeki öğeleri sıralamak için kullanılan ve varsayılan olarak constTraitsolarak olan karşılaştırma Traits işlevi.

Right
Oluşturulacak kümenin bir kopyası olduğu harita.

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 için multimap bellek depolamayı yöneten ve daha sonra çağrılarak get_allocatordöndürülebilen bir ayırıcı nesnesi türünü 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 kendi öğesini multimapbaşlatır.

Tüm oluşturucular, anahtarları Traits arasında bir düzen oluşturmak için kullanılan ve daha sonra çağrılarak multimapdöndürülebilecek türde key_comp bir işlev nesnesi depolar.

İlk üç oluşturucu, öğelerin sırasını belirlerken kullanılacak karşılaştırma işlevinin türünü () ve kullanılacak ayırıcı türünü (multimap) açıkça belirten üçüncü bir ilki CompbelirtinAl. Anahtar sözcük explicit , belirli tür otomatik tür dönüştürmelerini gizler.

Dördüncü oluşturucu, öğesinin multimapRightbir kopyasını belirtir.

Beşinci oluşturucu, Sağ'amultimapöğesinin bir kopyasını belirtir.

6., 7. ve 8. oluşturucular bir initializer_listöğesinin üyelerini kopyalar.

Sonraki üç oluşturucu, sınıfın [First, Last) ve ayırıcının karşılaştırma işlevinin türünü belirtirken açıklığı artırarak bir eşleme aralığını Traits kopyalar.

Örnek

// multimap_ctor.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main()
{
    using namespace std;
    typedef pair <int, int> Int_Pair;

    // Create an empty multimap m0 of key type integer
    multimap <int, int> m0;

    // Create an empty multimap m1 with the key comparison
    // function of less than, then insert 4 elements
    multimap <int, int, less<int> > m1;
    m1.insert(Int_Pair(1, 10));
    m1.insert(Int_Pair(2, 20));
    m1.insert(Int_Pair(3, 30));
    m1.insert(Int_Pair(4, 40));

    // Create an empty multimap m2 with the key comparison
    // function of greater than, then insert 2 elements
    multimap <int, int, less<int> > m2;
    m2.insert(Int_Pair(1, 10));
    m2.insert(Int_Pair(2, 20));

    // Create a multimap m3 with the
    // allocator of multimap m1
    multimap <int, int>::allocator_type m1_Alloc;
    m1_Alloc = m1.get_allocator();
    multimap <int, int> m3(less<int>(), m1_Alloc);
    m3.insert(Int_Pair(3, 30));

    // Create a copy, multimap m4, of multimap m1
    multimap <int, int> m4(m1);

    // Create a multimap m5 by copying the range m1[ first,  last)
    multimap <int, int>::const_iterator m1_bcIter, m1_ecIter;
    m1_bcIter = m1.begin();
    m1_ecIter = m1.begin();
    m1_ecIter++;
    m1_ecIter++;
    multimap <int, int> m5(m1_bcIter, m1_ecIter);

    // Create a multimap m6 by copying the range m4[ first,  last)
    // and with the allocator of multimap m2
    multimap <int, int>::allocator_type m2_Alloc;
    m2_Alloc = m2.get_allocator();
    multimap <int, int> m6(m4.begin(), ++m4.begin(), less<int>(), m2_Alloc);

    cout << "m1 =";
    for (auto i : m1)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m2 =";
    for (auto i : m2)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m3 =";
    for (auto i : m3)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m4 =";
    for (auto i : m4)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m5 =";
    for (auto i : m5)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m6 =";
    for (auto i : m6)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a multimap m8 by copying in an initializer_list
    multimap<int, int> m8{ { { 1, 1 }, { 2, 2 }, { 3, 3 }, { 4, 4 } } };
    cout << "m8: = ";
    for (auto i : m8)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a multimap m9 with an initializer_list and a comparator
    multimap<int, int> m9({ { 5, 5 }, { 6, 6 }, { 7, 7 }, { 8, 8 } }, less<int>());
    cout << "m9: = ";
    for (auto i : m9)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a multimap m10 with an initializer_list, a comparator, and an allocator
    multimap<int, int> m10({ { 9, 9 }, { 10, 10 }, { 11, 11 }, { 12, 12 } }, less<int>(), m9.get_allocator());
    cout << "m10: = ";
    for (auto i : m10)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

}

`multimap::operator=`

öğesinin multimap öğelerini başka multimapbir kopyasının kopyasıyla değiştirir.

multimap& operator=(const multimap& right);

multimap& operator=(multimap&& right);

Parametreler

right
içine multimap kopyalanan multimap.

Açıklamalar

bir multimapiçindeki mevcut öğeleri sildikten sonra içindekileri operator=right kopyalar veya içine multimaptaşır.

Örnek

// multimap_operator_as.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
   {
   using namespace std;
   multimap<int, int> v1, v2, v3;
   multimap<int, int>::iterator iter;

   v1.insert(pair<int, int>(1, 10));

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << iter->second << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << iter->second << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << iter->second << " ";
   cout << endl;
   }

`multimap::pointer`

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

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, nesnedeki iteratormultimap öğelere erişmek için bir kullanılmalıdır.

`multimap::rbegin`

ters çevrilmiş multimapiç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ş multimap bir içindeki ilk öğeyi veya ters çevrilmemiş multimapiçindeki son öğeyi ele alan ters çift yönlü yineleyici.

Açıklamalar

rbegin, ile kullanıldığı gibi multimap ters çevrilmiş begin bir multimapile kullanılır.

değerinin dönüş değeri rbegin öğesine const_reverse_iteratormultimap atanmışsa nesnesi değiştirilemez. değerinin dönüş değeri rbegin bir reverse_iteratormultimap öğesine atanmışsa nesnesi değiştirilebilir.

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

Örnek

// multimap_rbegin.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: iterator m1_Iter;
   multimap <int, int> :: reverse_iterator m1_rIter;
   multimap <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );

   m1_rIter = m1.rbegin( );
   cout << "The first element of the reversed multimap m1 is "
        << m1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a multimap in a forward order
   cout << "The multimap is: ";
   for ( m1_Iter = m1.begin( ) ; m1_Iter != m1.end( ); m1_Iter++)
      cout << m1_Iter -> first << " ";
      cout << "." << endl;

   // rbegin can be used to start an iteration
   // through a multimap in a reverse order
   cout << "The reversed multimap is: ";
   for ( m1_rIter = m1.rbegin( ) ; m1_rIter != m1.rend( ); m1_rIter++)
      cout << m1_rIter -> first << " ";
      cout << "." << endl;

   // A multimap element can be erased by dereferencing its key
   m1_rIter = m1.rbegin( );
   m1.erase ( m1_rIter -> first );

   m1_rIter = m1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed multimap is "
        << m1_rIter -> first << "." << endl;
}

The first element of the reversed multimap m1 is 3.
The multimap is: 1 2 3 .
The reversed multimap is: 3 2 1 .
After the erasure, the first element in the reversed multimap is 2.

`multimap::reference`

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

typedef typename allocator_type::reference reference;

Örnek

// multimap_ref.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );

   // Declare and initialize a const_reference &Ref1
   // to the key of the first element
   const int &Ref1 = ( m1.begin( ) -> first );

   // The following line would cause an error because the
   // non-const_reference can't be used to access the key
   // int &Ref1 = ( m1.begin( ) -> first );

   cout << "The key of first element in the multimap is "
        << Ref1 << "." << endl;

   // Declare and initialize a reference &Ref2
   // to the data value of the first element
   int &Ref2 = ( m1.begin( ) -> second );

   cout << "The data value of first element in the multimap is "
        << Ref2 << "." << endl;

   // The non-const_reference can be used to modify the
   // data value of the first element
   Ref2 = Ref2 + 5;
   cout << "The modified data value of first element is "
        << Ref2 << "." << endl;
}

The key of first element in the multimap is 1.
The data value of first element in the multimap is 10.
The modified data value of first element is 15.

`multimap::rend`

Ters çevrilmiş multimapbir içindeki son öğeyi başaran konumu ele alan bir yineleyici döndürür.

const_reverse_iterator rend() const;

reverse_iterator rend();

Dönüş Değeri

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

Açıklamalar

rend, ile kullanıldığı gibi multimap ters çevrilmiş end bir multimapile kullanılır.

değerinin dönüş değeri rend öğesine const_reverse_iteratormultimap atanmışsa nesnesi değiştirilemez. değerinin dönüş değeri rend bir reverse_iteratormultimap öğesine atanmışsa nesnesi değiştirilebilir.

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

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

Örnek

// multimap_rend.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;

   multimap <int, int> :: iterator m1_Iter;
   multimap <int, int> :: reverse_iterator m1_rIter;
   multimap <int, int> :: const_reverse_iterator m1_crIter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );

   m1_rIter = m1.rend( );
   m1_rIter--;
   cout << "The last element of the reversed multimap m1 is "
        << m1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a multimap in a forward order
   cout << "The multimap is: ";
   for ( m1_Iter = m1.begin( ) ; m1_Iter != m1.end( ); m1_Iter++)
      cout << m1_Iter -> first << " ";
      cout << "." << endl;

   // rbegin can be used to start an iteration
   // through a multimap in a reverse order
   cout << "The reversed multimap is: ";
   for ( m1_rIter = m1.rbegin( ) ; m1_rIter != m1.rend( ); m1_rIter++)
      cout << m1_rIter -> first << " ";
      cout << "." << endl;

   // A multimap element can be erased by dereferencing to its key
   m1_rIter = --m1.rend( );
   m1.erase ( m1_rIter -> first );

   m1_rIter = m1.rend( );
   m1_rIter--;
   cout << "After the erasure, the last element "
        << "in the reversed multimap is "
        << m1_rIter -> first << "." << endl;
}

The last element of the reversed multimap m1 is 1.
The multimap is: 1 2 3 .
The reversed multimap is: 3 2 1 .
After the erasure, the last element in the reversed multimap is 2.

`multimap::reverse_iterator`

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

typedef std::reverse_iterator<iterator> reverse_iterator;

Açıklamalar

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

reverse_iterator tarafından tanımlananmultimap, türünde value_typeolan nesnelerine pair<const Key, Type>işaret eder. Anahtarın değeri ilk üye çifti aracılığıyla kullanılabilir ve eşlenen öğenin değeri çiftin ikinci üyesi aracılığıyla kullanılabilir.

içindeki bir reverse_iteratorrIter öğeye işaret eden bir başvuruyu multimapgeri almak için işlecini -> kullanın.

öğesinin anahtarının değerine erişmek için, rIter->firstile eşdeğer (*rIter).firstolan kullanın. öğesinin eşlenmiş veri kümesinin değerine erişmek için öğesine rIter->secondeşdeğer (*rIter).secondolan kullanın.

Örnek

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

`multimap::size`

içindeki multimapöğe sayısını döndürür.

size_type size() const;

Dönüş Değeri

geçerli uzunluğu multimap.

Örnek

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

// multimap_size.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main()
{
    using namespace std;
    multimap<int, int> m1, m2;
    multimap<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    m1.insert(Int_Pair(1, 1));
    i = m1.size();
    cout << "The multimap length is " << i << "." << endl;

    m1.insert(Int_Pair(2, 4));
    i = m1.size();
    cout << "The multimap length is now " << i << "." << endl;
}

The multimap length is 1.
The multimap length is now 2.

`multimap::size_type`

içindeki öğe sayısını sayan işaretsiz bir multimaptamsayı 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

`multimap::swap`

İki multimapöğesinin öğelerini değiştirir.

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

Parametreler

right
multimap Değiştirilecek öğeleri sağlayan veya multimap öğeleri ile değiştirilecek multimapleftöğeleri.

Açıklamalar

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

Örnek

// multimap_swap.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1, m2, m3;
   multimap <int, int>::iterator m1_Iter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );
   m2.insert ( Int_Pair ( 10, 100 ) );
   m2.insert ( Int_Pair ( 20, 200 ) );
   m3.insert ( Int_Pair ( 30, 300 ) );

   cout << "The original multimap m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout   << "." << endl;

   // This is the member function version of swap
   m1.swap( m2 );

   cout << "After swapping with m2, multimap m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( m1, m3 );

   cout << "After swapping with m3, multimap m1 is:";
   for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
      cout << " " << m1_Iter -> second;
   cout   << "." << endl;
}

The original multimap m1 is: 10 20 30.
After swapping with m2, multimap m1 is: 100 200.
After swapping with m3, multimap m1 is: 300.

`multimap::upper_bound`

Belirtilen anahtardan iterator daha büyük bir multimap anahtara sahip olan içindeki ilk öğeye bir döndürür.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

Parametreler

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

Dönüş Değeri

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

Dönüş değeri bir const_iteratormultimap öğesine atanmışsa nesne değiştirilemez. Dönüş değeri bir iteratormultimap öğesine atanmışsa, nesne değiştirilebilir.

Örnek

// multimap_upper_bound.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   multimap <int, int> m1;
   multimap <int, int> :: const_iterator m1_AcIter, m1_RcIter;
   typedef pair <int, int> Int_Pair;

   m1.insert ( Int_Pair ( 1, 10 ) );
   m1.insert ( Int_Pair ( 2, 20 ) );
   m1.insert ( Int_Pair ( 3, 30 ) );
   m1.insert ( Int_Pair ( 3, 40 ) );

   m1_RcIter = m1.upper_bound( 1 );
   cout << "The 1st element of multimap m1 with "
        << "a key greater than 1 is: "
        << m1_RcIter -> second << "." << endl;

   m1_RcIter = m1.upper_bound( 2 );
   cout << "The first element of multimap m1 with a key "
        << " greater than 2 is: "
        << m1_RcIter -> second << "." << endl;

   // If no match is found for the key, end( ) is returned
   m1_RcIter = m1.lower_bound( 4 );

   if ( m1_RcIter == m1.end( ) )
      cout << "The multimap m1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of multimap m1 with a key of 4 is: "
           << m1_RcIter -> second << "." << endl;

   // The element at a specific location in the multimap can be
   // found using a dereferenced iterator addressing the location
   m1_AcIter = m1.begin( );
   m1_RcIter = m1.upper_bound( m1_AcIter -> first );
   cout << "The first element of m1 with a key greater than\n"
        << "that of the initial element of m1 is: "
        << m1_RcIter -> second << "." << endl;
}

The 1st element of multimap m1 with a key greater than 1 is: 20.
The first element of multimap m1 with a key  greater than 2 is: 30.
The multimap m1 doesn't have an element with a key of 4.
The first element of m1 with a key greater than
that of the initial element of m1 is: 20.

`multimap::value_comp`

üye işlevi, anahtar değerlerini karşılaştırarak içindeki öğelerin sırasını belirleyen bir multimap işlev nesnesi döndürür.

value_compare value_comp() const;

Dönüş Değeri

Bir öğesinin multimap öğelerini sıralamak için kullandığı karşılaştırma işlevi nesnesini döndürür.

Açıklamalar

bir multimapmiçin, iki öğe e1(k1, d1) ve e2(k2, d2) türünde value_typenesnelerse, burada k1 ve k2 türüne ait anahtarlarıdır key_type ve d1d2 bunların türüne mapped_typeait veriler ise, m.value_comp(e1, e2) ile eşdeğerdir m.key_comp(k1, k2).

Örnek

// multimap_value_comp.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;

   multimap <int, int, less<int> > m1;
   multimap <int, int, less<int> >::value_compare vc1 = m1.value_comp( );
   multimap<int,int>::iterator Iter1, Iter2;

   Iter1= m1.insert ( multimap <int, int> :: value_type ( 1, 10 ) );
   Iter2= m1.insert ( multimap <int, int> :: value_type ( 2, 5 ) );

   if( vc1( *Iter1, *Iter2 ) == true )
   {
      cout << "The element ( 1,10 ) precedes the element ( 2,5 )."
           << endl;
   }
   else
   {
      cout << "The element ( 1,10 ) does "
           << "not precede the element ( 2,5 )."
           << endl;
   }

   if( vc1( *Iter2, *Iter1 ) == true )
   {
      cout << "The element ( 2,5 ) precedes the element ( 1,10 )."
           << endl;
   }
   else
   {
      cout << "The element ( 2,5 ) does "
           << "not precede the element ( 1,10 )."
           << endl;
   }
}

The element ( 1,10 ) precedes the element ( 2,5 ).
The element ( 2,5 ) does not precede the element ( 1,10 ).

`multimap::value_type`

Bir eşlemede öğe olarak depolanan nesne türünü temsil eden bir tür.

typedef pair<const Key, Type> value_type;

Örnek

// multimap_value_type.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main( )
{
   using namespace std;
   typedef pair <const int, int> cInt2Int;
   multimap <int, int> m1;
   multimap <int, int> :: key_type key1;
   multimap <int, int> :: mapped_type mapped1;
   multimap <int, int> :: value_type value1;
   multimap <int, int> :: iterator pIter;

   // value_type can be used to pass the correct type
   // explicitly to avoid implicit type conversion
   m1.insert ( multimap <int, int> :: value_type ( 1, 10 ) );

   // Compare another way to insert objects into a hash_multimap
   m1.insert ( cInt2Int ( 2, 20 ) );

   // Initializing key1 and mapped1
   key1 = ( m1.begin( ) -> first );
   mapped1 = ( m1.begin( ) -> second );

   cout << "The key of first element in the multimap is "
        << key1 << "." << endl;

   cout << "The data value of first element in the multimap is "
        << mapped1 << "." << endl;

   // The following line would cause an error because
   // the value_type is not assignable
   // value1 = cInt2Int ( 4, 40 );

   cout  << "The keys of the mapped elements are:";
   for ( pIter = m1.begin( ) ; pIter != m1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( pIter = m1.begin( ) ; pIter != m1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;
}

The key of first element in the multimap is 1.
The data value of first element in the multimap is 10.
The keys of the mapped elements are: 1 2.
The values of the mapped elements are: 10 20.

Ayrıca bkz.

Konteynerler
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ş

multimap Sınıf

Sözdizimi

Parametreler

Açıklamalar

Üyeler

Oluşturucular

Tür tanımları

Üye işlevleri

Gereksinimler

multimap::allocator_type

Örnek

multimap::begin

Dönüş Değeri

Örnek

multimap::cbegin

Dönüş Değeri

Açıklamalar

multimap::cend

Dönüş Değeri

Açıklamalar

multimap::clear

Örnek

multimap::const_iterator

Açıklamalar

Örnek

multimap::const_pointer

Açıklamalar

multimap::const_reference

Örnek

multimap::const_reverse_iterator

Açıklamalar

Örnek

multimap::contains

Parametreler

Dönüş Değeri

Açıklamalar

Örnek

multimap::count

Parametreler

Dönüş Değeri

Açıklamalar

Örnek

multimap::crbegin

Dönüş Değeri

Açıklamalar

Örnek

multimap::crend

Dönüş Değeri

Açıklamalar

Örnek

multimap::difference_type

Açıklamalar

Örnek

multimap::emplace

Parametreler

Dönüş Değeri

Açıklamalar

Örnek

multimap::emplace_hint

Parametreler

Dönüş Değeri

Açıklamalar

multimap::empty

Dönüş Değeri

Örnek

multimap::end

Dönüş Değeri

Açıklamalar

multimap::equal_range

Parametreler

Dönüş Değeri

Örnek

multimap::erase

Parametreler

Dönüş Değeri

Açıklamalar

multimap::find

Parametreler

Dönüş Değeri

`multimap` Sınıf

`multimap::allocator_type`

`multimap::begin`

`multimap::cbegin`

`multimap::cend`

`multimap::clear`

`multimap::const_iterator`

`multimap::const_pointer`

`multimap::const_reference`

`multimap::const_reverse_iterator`

`multimap::contains`

`multimap::count`

`multimap::crbegin`

`multimap::crend`

`multimap::difference_type`

`multimap::emplace`

`multimap::emplace_hint`

`multimap::empty`

`multimap::end`

`multimap::equal_range`

`multimap::erase`

`multimap::find`

`multimap::get_allocator`

`multimap::insert`

`multimap::iterator`

`multimap::key_comp`

`multimap::key_compare`

`multimap::key_type`

`multimap::lower_bound`

`multimap::mapped_type`

`multimap::max_size`

`multimap::multimap`

`multimap::operator=`

`multimap::pointer`

`multimap::rbegin`

`multimap::reference`

`multimap::rend`

`multimap::reverse_iterator`

`multimap::size`

`multimap::size_type`

`multimap::swap`

`multimap::upper_bound`