map (STL/CLR)

Şablon sınıfı, çift yönlü erişime sahip öğelerin değişen uzunlukta dizisini denetleen bir nesneyi açıklar. Kapsayıcıyı map , her biri bir öğeyi depolayarak bir dizi öğeyi (neredeyse) dengeli sıralı düğüm ağacı olarak yönetmek için kullanırsınız. Öğe, sırayı sıralamak için bir anahtardan ve sürüş için birlikte giden eşlenmiş bir değerden oluşur.

Aşağıdaki açıklamada aşağıdakiyle GValue aynıdır:

Microsoft::VisualC::StlClr::GenericPair<GKey, GMapped>

konumu:

GKey , ikinci bir başvuru türü olmadığı sürece aynıdır Key ; bu durumda Key^

GMapped , ikinci bir başvuru türü olmadığı sürece aynıdır Mapped ; bu durumda Mapped^

Sözdizimi

template<typename Key,
    typename Mapped>
    ref class map
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        System::Collections::Generic::IDictionary<Gkey, GMapped>,
        Microsoft::VisualC::StlClr::ITree<Gkey, GValue>
    { ..... };

Parametreler

Key
Denetlenen dizideki bir öğenin anahtar bileşeninin türü.

Mapped
Denetlenen dizideki bir öğenin diğer bileşeninin türü.

Gereksinimler

Üst bilgi:<cliext/map>

Ad alanı: cliext

Bildirimler

Tür tanımı	Açıklama
map::const_iterator	Denetlenen dizi için bir sabit yineleyici türü.
map::const_reference	Bir öğe için sabit bir başvuru türü.
map::const_reverse_iterator	Denetimli sıra için sabit bir ters yineleyici türü.
map::difference_type	İki öğe arasındaki (büyük olasılıkla imzalı) uzaklık türü.
map::generic_container	Kapsayıcı için genel arabirimin türü.
map::generic_iterator	Kapsayıcının genel arabirimi için yineleyici türü.
map::generic_reverse_iterator	Kapsayıcının genel arabirimi için ters yineleyici türü.
map::generic_value	Kapsayıcının genel arabirimi için bir öğenin türü.
map::iterator	Denetlenen dizi için bir yineleyici türü.
map::key_compare	İki anahtar için sıralama temsilcisi.
map::key_type	Bir sıralama anahtarının türü.
map::mapped_type	Her anahtarla ilişkili eşlenmiş değerin türü.
map::reference	Bir öğe için bir başvuru türü.
map::reverse_iterator	Denetimli sıra için ters yineleyicinin türü.
map::size_type	İki öğe arasındaki (negatif olmayan) mesafenin türü.
map::value_compare	İki öğe değeri için sıralama temsilcisi.
map::value_type	Öğenin türü.

Üye işlevi	Açıklama
map::begin	Denetlenen dizinin başlangıcını belirtir.
map::clear	Tüm öğeleri kaldırır.
map::count	Belirtilen anahtarla eşleşen öğeleri sayar.
map::empty	Bir öğe olup olmadığını sınar.
map::end	Denetlenen dizinin bitişini belirtir.
map::equal_range	Belirtilen bir anahtarla eşleşen aralığı bulur.
map::erase	Belirtilen konumlardaki öğeleri kaldırır.
map::find	Belirtilen bir anahtarla eşleşen bir öğeyi bulur.
map::insert	Öğeleri ekler.
map::key_comp	İki anahtar için sıralama temsilcisini kopyalar.
map::lower_bound	Belirtilen anahtarla eşleşen aralığın başlangıcını bulur.
map::make_value	Bir değer nesnesi oluşturur.
map::map	Bir kapsayıcı nesnesi oluşturur.
map::rbegin	Ters denetimli sıranın başlangıcını belirtir.
map::rend	Ters denetimli sıranın sonunu belirtir.
map::size	Öğe sayısını sayar.
map::swap	İki kapsayıcının içeriğinin yerini değiştirir.
map::to_array	Denetimli diziyi yeni bir diziye kopyalar.
map::upper_bound	Belirtilen anahtarla eşleşen aralığın sonunu bulur.
map::value_comp	İki öğe değeri için sıralama temsilcisini kopyalar.

Operator	Açıklama
map::operator=	Denetimli sıranın yerini alır.
map::operator[]	Bir anahtarı ilişkili eşlenmiş değeriyle eşler.
operator!= (harita)	Bir nesnenin başka map bir map nesneye eşit olup olmadığını belirler.
operator< (harita)	Bir nesnenin başka map bir map nesneden küçük olup olmadığını belirler.
operator<= (harita)	Bir nesnenin başka bir nesneden küçük veya başka bir map map nesneye eşit olup olmadığını belirler.
operator== (harita)	Bir nesnenin başka map bir map nesneye eşit olup olmadığını belirler.
operator> (harita)	Bir nesnenin başka map bir map nesneden büyük olup olmadığını belirler.
operator>= (harita)	Bir nesnenin başka bir nesneden büyük veya başka bir map map nesneye eşit olup olmadığını belirler.

Arabirimler

Arabirim	Açıklama
ICloneable	Nesneyi çoğaltma.
IEnumerable	Öğeler arasında sıralama.
ICollection	Öğe grubunu koruyun.
IEnumerable<T>	Yazılan öğeler arasında sıra.
ICollection<T>	Yazılan öğe grubunu koruyun.
IDictionary<TKey,TValue>	{key, value} çiftleri grubunu koruyun.
ITree<Key, Value>	Genel kapsayıcıyı koruyun.

Açıklamalar

nesnesi, tek tek düğümler olarak denetlediği sıra için depolama ayırır ve serbesttir. Hiçbir zaman bir düğümün içeriğini başka bir düğüme kopyalayarak düğümler arasındaki bağlantıları değiştirerek sıralı tuttuğu (neredeyse) dengeli bir ağaca öğe ekler. Bu, kalan öğeleri rahatsız etmeden öğeleri serbestçe ekleyebileceğiniz ve kaldırabileceğiniz anlamına gelir.

nesnesi, türünde map::key_comparebir saklı temsilci nesnesi çağırarak denetlediği sırayı sıralar. Eşlemeyi oluştururken depolanan temsilci nesnesini belirtebilirsiniz; temsilci nesnesi belirtmezseniz, varsayılan karşılaştırmadır operator<(key_type, key_type). Bu depolanan nesneye üye işlevini map::key_compçağırarak erişebilirsiniz.

Böyle bir temsilci nesnesi türündeki map::key_typeanahtarlara katı bir zayıf sıralama uygulamalıdır. Başka bir deyişle, iki anahtar X ve Yiçin:

key_comp()(X, Y) her çağrıda aynı Boole sonucunu döndürür.

key_comp()(X, Y) True ise false key_comp()(Y, X) olmalıdır.

True key_comp()(X, Y) ise, X öncesinde Ysıralanmış olduğu söylenir.

True !key_comp()(X, Y) && !key_comp()(Y, X) ise ve X Y eşdeğer sıralamaya sahip olduğu söylenir.

Denetimli diziden key_comp()(Y, X) önce Y gelen herhangi bir öğe X için false değeridir. (Varsayılan temsilci nesnesi için anahtarlar hiçbir zaman değerde azalmaz.) Şablon sınıfı eşlemesinin aksine, şablon sınıfının map bir nesnesi tüm öğeler için anahtarların benzersiz olmasını gerektirmez. (İki veya daha fazla anahtar eşdeğer sıralamaya sahip olabilir.)

Her öğe ayrı bir anahtar ve eşlenmiş bir değer içerir. Sıra, logaritmik sürede rastgele bir öğenin arama, ekleme ve kaldırma işlemlerine izin veren bir şekilde temsil edilir. Yani işlem sayısı, dizideki öğe sayısının logaritmasıyla orantılıdır. Ayrıca, öğe eklemek yineleyicileri geçersiz kılmaz ve bir öğeyi kaldırmak yalnızca kaldırılan öğeyi işaret eden yineleyicileri geçersiz kılabilir.

A map , çift yönlü yineleyicileri destekler. Bu, denetlenen dizideki bir öğeyi belirten bir yineleyici verildiğinde bitişik öğelere adım atabileceğiniz anlamına gelir. Özel bir baş düğümü tarafından end()döndürülen yineleyiciye karşılık gelir. Varsa, denetimli dizideki son öğeye ulaşmak için bu yineleyiciyi geri alabilirsiniz. Baş düğüme ulaşmak için yineleyiciyi map artırabilirsiniz ve ardından eşit olarak karşılaştırır end(). Ancak tarafından end()döndürülen yineleyicinin başvurularını kaldıramazsınız.

Doğrudan sayısal konumu verilen bir map öğeye başvuramazsınız. Bunun için rastgele erişim yineleyicisi gerekir.

map Yineleyici, ilişkili map düğümünde bir tanıtıcı depolar ve bu da ilişkili kapsayıcısında bir tanıtıcı depolar. Yineleyicileri yalnızca ilişkili kapsayıcı nesneleriyle kullanabilirsiniz. Yineleyici map , ilişkili map düğümü bir haritayla ilişkilendirildiğinde geçerli kalır. Ayrıca geçerli bir yineleyicinin başvurusu kaldırılabilir. Eşit olmadığı sürece, öğe değerine erişmek veya değerini değiştirmek için end()kullanabilirsiniz.

Bir öğenin silinmesi veya kaldırılması, depolanmış değeri için yıkıcıyı çağırır. Kapsayıcıyı yok etmek tüm öğeleri siler. Bu nedenle, öğe türü ref sınıfı olan bir kapsayıcı, hiçbir öğenin kapsayıcıdan daha uzun yaşamasını sağlamaz. Ancak, bir tutamaç kapsayıcısı öğelerini yok etmez.

Üyeler

map::begin

Denetlenen dizinin başlangıcını belirtir.

Sözdizimi

iterator begin();

Açıklamalar

Üye işlevi, denetlenen dizinin ilk öğesini veya boş bir dizinin sonunun hemen ötesinde belirten çift yönlü bir yineleyici döndürür. Denetimli sıranın current başlangıcını belirten bir yineleyici elde etmek için bunu kullanırsınız, ancak denetlenen sıranın uzunluğu değişirse durumu değişebilir.

Örnek

// cliext_map_begin.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items
    Mymap::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = [{0} {1}]",
        it->first, it->second);
    ++it;
    System::Console::WriteLine("*++begin() = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*begin() = [a 1]
*++begin() = [b 2]

map::clear

Tüm öğeleri kaldırır.

Sözdizimi

void clear();

Açıklamalar

Üye işlevi etkin bir şekilde öğesini çağırır erase(begin(), end()). Denetimli sıranın boş olduğundan emin olmak için bunu kullanırsınız.

Örnek

// cliext_map_clear.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));

    // display contents " [a 1] [b 2]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

[a 1] [b 2] [c 3]
size() = 0
[a 1] [b 2]
size() = 0

map::const_iterator

Denetlenen dizi için bir sabit yineleyici türü.

Sözdizimi

typedef T2 const_iterator;

Açıklamalar

türü, denetlenen dizi için sabit bir çift yönlü yineleyici görevi görecek belirtilmemiş türdeki T2 bir nesneyi açıklar.

Örnek

// cliext_map_const_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Mymap::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("[{0} {1}] ", cit->first, cit->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

map::const_reference

Bir öğe için sabit bir başvuru türü.

Sözdizimi

typedef value_type% const_reference;

Açıklamalar

türü, bir öğeye sabit başvuruyu açıklar.

Örnek

// cliext_map_const_reference.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Mymap::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        Mymap::const_reference cref = *cit;
        System::Console::Write("[{0} {1}] ", cref->first, cref->second);
        }
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

map::const_reverse_iterator

Denetimli sıra için sabit bir ters yineleyici türü.

Sözdizimi

typedef T4 const_reverse_iterator;

Açıklamalar

türü, denetlenen dizi için sabit bir ters yineleyici görevi görecek belirtilmemiş türdeki T4 bir nesneyi açıklar.

Örnek

// cliext_map_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" reversed
    Mymap::const_reverse_iterator crit = c1.rbegin();
    for (; crit != c1.rend(); ++crit)
        System::Console::Write("[{0} {1}] ", crit->first, crit->second);
    System::Console::WriteLine();
    return (0);
    }

[c 3] [b 2] [a 1]

map::count

Belirtilen bir anahtar ile eşleşen öğe sayısını bulur.

Sözdizimi

size_type count(key_type key);

Parametreler

key
Aranacak anahtar değeri.

Açıklamalar

üye işlevi, ile eşdeğer sıralamaya keysahip denetimli dizideki öğelerin sayısını döndürür. Belirtilen bir anahtarla eşleşen denetimli sırada bulunan öğelerin sayısını belirlemek için bunu kullanırsınız.

Örnek

// cliext_map_count.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("count(L'A') = {0}", c1.count(L'A'));
    System::Console::WriteLine("count(L'b') = {0}", c1.count(L'b'));
    System::Console::WriteLine("count(L'C') = {0}", c1.count(L'C'));
    return (0);
    }

[a 1] [b 2] [c 3]
count(L'A') = 0
count(L'b') = 1
count(L'C') = 0

map::difference_type

İki öğe arasındaki imzalı uzaklık türleri.

Sözdizimi

typedef int difference_type;

Açıklamalar

Türü, büyük olasılıkla negatif öğe sayısını açıklar.

Örnek

// cliext_map_difference_type.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // compute positive difference
    Mymap::difference_type diff = 0;
    for (Mymap::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (Mymap::iterator it = c1.end(); it != c1.begin(); --it)
        --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }

[a 1] [b 2] [c 3]
end()-begin() = 3
begin()-end() = -3

map::empty

Bir öğe olup olmadığını sınar.

Sözdizimi

bool empty();

Açıklamalar

Üye işlevi boş denetimli bir dizi için true döndürür. ile eşdeğerdir size() == 0. Boş olup olmadığını map test etmek için bunu kullanırsınız.

Örnek

// cliext_map_empty.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }

[a 1] [b 2] [c 3]
size() = 3
empty() = False
size() = 0
empty() = True

map::end

Denetlenen dizinin bitişini belirtir.

Sözdizimi

iterator end();

Açıklamalar

Üye işlevi, denetlenen sıranın sonunun hemen ötesine işaret eden çift yönlü bir yineleyici döndürür. Bunu, denetlenen sıranın sonunu belirten bir yineleyici elde etmek için kullanırsınız; denetlenen sıranın uzunluğu değişirse durumu değişmez.

Örnek

// cliext_map_end.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect last two items
    Mymap::iterator it = c1.end();
    --it;
    --it;
    System::Console::WriteLine("*-- --end() = [{0} {1}]",
        it->first, it->second);
    ++it;
    System::Console::WriteLine("*--end() = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

map::equal_range

Belirtilen bir anahtarla eşleşen aralığı bulur.

Sözdizimi

cliext::pair<iterator, iterator> equal_range(key_type key);

Parametreler

key
Aranacak anahtar değeri.

Açıklamalar

Üye işlevi bir çift yineleyici cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key))döndürür. Bunu, şu anda denetimli dizide belirtilen bir anahtarla eşleşen öğe aralığını belirlemek için kullanırsınız.

Örnek

// cliext_map_equal_range.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
typedef Mymap::pair_iter_iter Pairii;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // display results of failed search
    Pairii pair1 = c1.equal_range(L'x');
    System::Console::WriteLine("equal_range(L'x') empty = {0}",
        pair1.first == pair1.second);

    // display results of successful search
    pair1 = c1.equal_range(L'b');
    for (; pair1.first != pair1.second; ++pair1.first)
        System::Console::Write("[{0} {1}] ",
            pair1.first->first, pair1.first->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
equal_range(L'x') empty = True
[b 2]

map::erase

Belirtilen konumlardaki öğeleri kaldırır.

Sözdizimi

iterator erase(iterator where);
iterator erase(iterator first, iterator last);
bool erase(key_type key)

Parametreler

first
Silinecek aralığın başlangıcı.

key
Silinecek anahtar değeri.

last
Silinecek aralığın sonu.

where
Silinecek öğe.

Açıklamalar

İlk üye işlevi tarafından whereişaret edilen denetlenen dizinin öğesini kaldırır ve kaldırılan öğenin ötesinde kalan ilk öğeyi belirten veya end() böyle bir öğe yoksa bir yineleyici döndürür. Tek bir öğeyi kaldırmak için bunu kullanırsınız.

İkinci üye işlevi , [first, last) aralığındaki denetlenen dizinin öğelerini kaldırır ve kaldırılan öğelerin ötesinde kalan ilk öğeyi belirten veya end() böyle bir öğe yoksa bir yineleyici döndürür. Sıfır veya daha fazla bitişik öğeyi kaldırmak için bunu kullanırsınız.

Üçüncü üye işlevi, anahtarı ile eşdeğer sıralamaya keysahip denetimli dizinin herhangi bir öğesini kaldırır ve kaldırılan öğe sayısının sayısını döndürür. Bunu, belirtilen bir anahtarla eşleşen tüm öğeleri kaldırmak ve saymak için kullanırsınız.

Her öğe silme işlemi, denetlenen dizideki öğe sayısının logaritmasıyla orantılı olarak zaman alır.

Örnek

// cliext_map_erase.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    cliext::map<wchar_t, int> c1;
    c1.insert(cliext::map<wchar_t, int>::make_value(L'a', 1));
    c1.insert(cliext::map<wchar_t, int>::make_value(L'b', 2));
    c1.insert(cliext::map<wchar_t, int>::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (cliext::map<wchar_t, int>::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // erase an element and reinspect
    cliext::map<wchar_t, int>::iterator it =
        c1.erase(c1.begin());
    System::Console::WriteLine("erase(begin()) = [{0} {1}]",
        it->first, it->second);

    // add elements and display " b c d e"
    c1.insert(cliext::map<wchar_t, int>::make_value(L'd', 4));
    c1.insert(cliext::map<wchar_t, int>::make_value(L'e', 5));
    for each (cliext::map<wchar_t, int>::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // erase all but end
    it = c1.end();
    it = c1.erase(c1.begin(), --it);
    System::Console::WriteLine("erase(begin(), end()-1) = [{0} {1}]",
        it->first, it->second);
    System::Console::WriteLine("size() = {0}", c1.size());

    // erase end
    System::Console::WriteLine("erase(L'x') = {0}", c1.erase(L'x'));
    System::Console::WriteLine("erase(L'e') = {0}", c1.erase(L'e'));
    return (0);
    }

[a 1] [b 2] [c 3]
erase(begin()) = [b 2]
[b 2] [c 3] [d 4] [e 5]
erase(begin(), end()-1) = [e 5]
size() = 1
erase(L'x') = 0
erase(L'e') = 1

map::find

Belirtilen bir anahtarla eşleşen bir öğeyi bulur.

Sözdizimi

iterator find(key_type key);

Parametreler

key
Aranacak anahtar değeri.

Açıklamalar

Denetlenen dizideki en az bir öğe ile keyeşdeğer sıralamaya sahipse, üye işlevi bu öğelerden birini belirten bir yineleyici döndürür; aksi takdirde döndürür end(). Şu anda denetimli dizide belirtilen bir anahtarla eşleşen bir öğeyi bulmak için bu öğeyi kullanırsınız.

Örnek

// cliext_map_find.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("find {0} = {1}",
        L'A', c1.find(L'A') != c1.end());

    Mymap::iterator it = c1.find(L'b');
    System::Console::WriteLine("find {0} = [{1} {2}]",
        L'b', it->first, it->second);

    System::Console::WriteLine("find {0} = {1}",
        L'C', c1.find(L'C') != c1.end());
    return (0);
    }

[a 1] [b 2] [c 3]
find A = False
find b = [b 2]
find C = False

map::generic_container

Kapsayıcı için genel arabirimin türü.

Sözdizimi

typedef Microsoft::VisualC::StlClr::
    ITree<GKey, GValue>
    generic_container;

Açıklamalar

türü, bu şablon kapsayıcı sınıfı için genel arabirimi açıklar.

Örnek

// cliext_map_generic_container.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Mymap::generic_container^ gc1 = %c1;
    for each (Mymap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->insert(Mymap::make_value(L'd', 4));
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // modify original and display generic
    c1.insert(Mymap::make_value(L'e', 5));
    for each (Mymap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3] [d 4]
[a 1] [b 2] [c 3] [d 4] [e 5]

map::generic_iterator

Kapsayıcının genel arabirimiyle kullanılacak bir yineleyicinin türü.

Sözdizimi

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerBidirectionalIterator<generic_value>
    generic_iterator;

Açıklamalar

türü, bu şablon kapsayıcı sınıfı için genel arabirimle kullanılabilecek genel bir yineleyiciyi açıklar.

Örnek

// cliext_map_generic_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Mymap::generic_container^ gc1 = %c1;
    for each (Mymap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Mymap::generic_iterator gcit = gc1->begin();
    Mymap::generic_value gcval = *gcit;
    System::Console::Write("[{0} {1}] ", gcval->first, gcval->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1]

map::generic_reverse_iterator

Kapsayıcının genel arabirimiyle kullanılacak ters yineleyicinin türü.

Sözdizimi

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseRandomAccessIterator<generic_value>
    generic_reverse_iterator;

Açıklamalar

türü, bu şablon kapsayıcı sınıfı için genel arabirimle kullanılabilecek genel bir ters yineleyiciyi açıklar.

Örnek

// cliext_map_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Mymap::generic_container^ gc1 = %c1;
    for each (Mymap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Mymap::generic_reverse_iterator gcit = gc1->rbegin();
    Mymap::generic_value gcval = *gcit;
    System::Console::WriteLine("[{0} {1}] ", gcval->first, gcval->second);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[c 3]

map::generic_value

Kapsayıcının genel arabirimiyle kullanılacak bir öğenin türü.

Sözdizimi

typedef GValue generic_value;

Açıklamalar

türü, bu şablon kapsayıcı sınıfı için genel arabirimle kullanılmak üzere depolanan öğe değerini açıklayan türdeki GValue bir nesneyi açıklar.

Örnek

// cliext_map_generic_value.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Mymap::generic_container^ gc1 = %c1;
    for each (Mymap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Mymap::generic_iterator gcit = gc1->begin();
    Mymap::generic_value gcval = *gcit;
    System::Console::WriteLine("[{0} {1}] ", gcval->first, gcval->second);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1]

map::insert

Öğeleri ekler.

Sözdizimi

cliext::pair<iterator, bool> insert(value_type val);
iterator insert(iterator where, value_type val);
template<typename InIter>
    void insert(InIter first, InIter last);
void insert(System::Collections::Generic::IEnumerable<value_type>^ right);

Parametreler

first
Eklenecek aralığın başlangıcı.

last
Eklenecek aralık sonu.

right
Eklenecek numaralandırma.

val
Eklenecek anahtar değeri.

where
Eklenecek kapsayıcının neresinde (yalnızca ipucu).

Açıklamalar

Üye işlevlerin her biri, kalan işlenenler tarafından belirtilen bir dizi ekler.

İlk üye işlevi, değerine valsahip bir öğe eklemeye çalışır ve bir değer Xçifti döndürür. X.second True ise, X.first yeni eklenen öğeyi atar; aksi takdirde X.first zaten var olan ve yeni öğe eklenmemiş eşdeğer sıralamaya sahip bir öğe atar. Tek bir öğe eklemek için bunu kullanırsınız.

İkinci üye işlevi, ipucu olarak kullanarak where (performansı geliştirmek için) değerine valsahip bir öğe ekler ve yeni eklenen öğeyi belirten bir yineleyici döndürür. Bunu, bildiğiniz bir öğenin yanına olabilecek tek bir öğe eklemek için kullanırsınız.

Üçüncü üye işlevi [first, last) dizisini ekler. Başka bir diziden kopyalanan sıfır veya daha fazla öğe eklemek için bunu kullanırsınız.

Dördüncü üye işlevi tarafından belirlenen diziyi rightekler. Bunu bir numaralandırıcı tarafından açıklanan bir dizi eklemek için kullanırsınız.

Her öğe ekleme işlemi, denetlenen dizideki öğe sayısının logaritmasıyla orantılı olarak zaman alır. Ekleme işlemi amorti edilmiş sabit süre içinde gerçekleşebilir ancak ekleme noktasının yanında bir öğeyi belirten bir ipucu verilir.

Örnek

// cliext_map_insert.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
typedef Mymap::pair_iter_bool Pairib;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert a single value, unique and duplicate
// insert a single value, success and failure
    Pairib pair1 = c1.insert(Mymap::make_value(L'x', 24));
    System::Console::WriteLine("insert([L'x' 24]) = [[{0} {1}] {2}]",
        pair1.first->first, pair1.first->second, pair1.second);

    pair1 = c1.insert(Mymap::make_value(L'b', 2));
    System::Console::WriteLine("insert([L'b' 2]) = [[{0} {1}] {2}]",
        pair1.first->first, pair1.first->second, pair1.second);

    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert a single value with hint
    Mymap::iterator it =
        c1.insert(c1.begin(), Mymap::make_value(L'y', 25));
    System::Console::WriteLine("insert(begin(), [L'y' 25]) = [{0} {1}]",
        it->first, it->second);
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert an iterator range
    Mymap c2;
    it = c1.end();
    c2.insert(c1.begin(), --it);
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert an enumeration
    Mymap c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::
            IEnumerable<Mymap::value_type>^)%c1);
    for each (Mymap::value_type elem in c3)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
insert([L'x' 24]) = [[x 24] True]
insert([L'b' 2]) = [[b 2] False]
[a 1] [b 2] [c 3] [x 24]
insert(begin(), [L'y' 25]) = [y 25]
[a 1] [b 2] [c 3] [x 24] [y 25]
[a 1] [b 2] [c 3] [x 24]
[a 1] [b 2] [c 3] [x 24] [y 25]

map::iterator

Denetlenen dizi için bir yineleyici türü.

Sözdizimi

typedef T1 iterator;

Açıklamalar

türü, denetlenen dizi için çift yönlü yineleyici görevi görecek belirtilmemiş türdeki T1 bir nesneyi açıklar.

Örnek

// cliext_map_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Mymap::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("[{0} {1}] ", it->first, it->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

map::key_comp

İki anahtar için sıralama temsilcisini kopyalar.

Sözdizimi

key_compare^key_comp();

Açıklamalar

Üye işlevi, denetlenen sırayı sıralamak için kullanılan sıralama temsilcisini döndürür. bunu iki anahtarı karşılaştırmak için kullanırsınız.

Örnek

// cliext_map_key_comp.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    Mymap::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Mymap c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

map::key_compare

İki anahtar için sıralama temsilcisi.

Sözdizimi

Microsoft::VisualC::StlClr::BinaryDelegate<GKey, GKey, bool>
    key_compare;

Açıklamalar

türü, temsilcinin anahtar bağımsız değişkenlerinin sırasını belirleyen bir eş anlamlıdır.

Örnek

// cliext_map_key_compare.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    Mymap::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Mymap c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

map::key_type

Bir sıralama anahtarının türü.

Sözdizimi

typedef Key key_type;

Açıklamalar

türü, şablon parametresi Keyiçin bir eş anlamlıdır.

Örnek

// cliext_map_key_type.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using key_type
    for (Mymap::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in key_type object
        Mymap::key_type val = it->first;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

map::lower_bound

Belirtilen anahtarla eşleşen aralığın başlangıcını bulur.

Sözdizimi

iterator lower_bound(key_type key);

Parametreler

key
Aranacak anahtar değeri.

Açıklamalar

üye işlevi, denetlenen dizideki ile eşdeğer sıralamaya sahip ilk öğeyi X keybelirler. Böyle bir öğe yoksa döndürür end(); aksi takdirde öğesini belirten Xbir yineleyici döndürür. Bunu, şu anda belirli bir anahtarla eşleşen denetimli dizide bulunan bir öğe dizisinin başlangıcını bulmak için kullanırsınız.

Örnek

// cliext_map_lower_bound.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("lower_bound(L'x')==end() = {0}",
        c1.lower_bound(L'x') == c1.end());

    Mymap::iterator it = c1.lower_bound(L'a');
    System::Console::WriteLine("*lower_bound(L'a') = [{0} {1}]",
        it->first, it->second);
    it = c1.lower_bound(L'b');
    System::Console::WriteLine("*lower_bound(L'b') = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
lower_bound(L'x')==end() = True
*lower_bound(L'a') = [a 1]
*lower_bound(L'b') = [b 2]

map::make_value

Bir değer nesnesi oluşturur.

Sözdizimi

static value_type make_value(key_type key, mapped_type mapped);

Parametreler

key
Kullanılacak anahtar değeri.

mapped
Aranacak eşlenmiş değer.

Açıklamalar

Üye işlevi, anahtarı key olan ve eşlenen değeri mappedolan bir value_type nesnesi döndürür. Bunu, diğer birkaç üye işleviyle kullanıma uygun bir nesne oluşturmak için kullanırsınız.

Örnek

// cliext_map_make_value.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

map::map

Bir kapsayıcı nesnesi oluşturur.

Sözdizimi

map();
explicit map(key_compare^ pred);
map(map<Key, Mapped>% right);
map(map<Key, Mapped>^ right);
template<typename InIter>
    mapmap(InIter first, InIter last);
template<typename InIter>
    map(InIter first, InIter last,
        key_compare^ pred);
map(System::Collections::Generic::IEnumerable<GValue>^ right);
map(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred);

Parametreler

first
Eklenecek aralığın başlangıcı.

last
Eklenecek aralık sonu.

pred
Denetlenen sıra için sıralama koşulu.

right
Eklenecek nesne veya aralık.

Açıklamalar

Oluşturucu:

map();

, denetimli diziyi varsayılan sıralama koşuluyla key_compare()hiçbir öğe olmadan başlatır. Varsayılan sıralama koşuluyla boş bir ilk denetimli sıra belirtmek için bunu kullanırsınız.

Oluşturucu:

explicit map(key_compare^ pred);

, denetimli diziyi öğe olmadan, sıralama koşuluyla predbaşlatır. Belirtilen sıralama koşuluyla boş bir ilk denetimli sıra belirtmek için bunu kullanırsınız.

Oluşturucu:

map(map<Key, Mapped>% right);

, denetimli sırayı varsayılan sıralama koşuluyla [right.begin(), right.end()) dizisiyle başlatır. Bunu, varsayılan sıralama koşuluyla nesnesi righttarafından map denetlenen dizinin bir kopyası olan ilk denetimli bir dizi belirtmek için kullanırsınız.

Oluşturucu:

map(map<Key, Mapped>^ right);

, denetimli sırayı varsayılan sıralama koşuluyla [right->begin(), right->end()) dizisiyle başlatır. Bunu, varsayılan sıralama koşuluyla nesnesi righttarafından map denetlenen dizinin bir kopyası olan ilk denetimli bir dizi belirtmek için kullanırsınız.

Oluşturucu:

template<typename InIter> map(InIter first, InIter last);

, denetimli sırayı varsayılan sıralama koşuluyla [first, last) dizisiyle başlatır. Denetimli sırayı, varsayılan sıralama koşuluyla başka bir sıranın bir kopyası yapmak için kullanırsınız.

Oluşturucu:

template<typename InIter> map(InIter first, InIter last, key_compare^ pred);

denetimli diziyi sıralama koşuluyla pred[first, last) ile başlatır. Denetimli sırayı, belirtilen sıralama koşuluyla başka bir sıranın bir kopyası yapmak için kullanırsınız.

Oluşturucu:

map(System::Collections::Generic::IEnumerable<Key>^ right);

, varsayılan sıralama koşuluyla, numaralandırıcı righttarafından belirlenen diziyle denetimli diziyi başlatır. Denetimli sırayı, varsayılan sıralama koşuluyla bir numaralandırıcı tarafından açıklanan başka bir sıranın kopyası yapmak için kullanırsınız.

Oluşturucu:

map(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred);

, numaralandırıcı righttarafından belirlenen sıra ile denetimli diziyi, sıralama koşuluyla predbaşlatır. Denetimli sırayı, belirtilen sıralama koşuluyla bir numaralandırıcı tarafından açıklanan başka bir dizinin kopyası yapmak için kullanırsınız.

Örnek

// cliext_map_construct.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
// construct an empty container
    Mymap c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an ordering rule
    Mymap c2 = cliext::greater_equal<wchar_t>();
    System::Console::WriteLine("size() = {0}", c2.size());

    c2.insert(c1.begin(), c1.end());
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an iterator range
    Mymap c3(c1.begin(), c1.end());
    for each (Mymap::value_type elem in c3)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule
    Mymap c4(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>());
    for each (Mymap::value_type elem in c4)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an enumeration
    Mymap c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Mymap::value_type>^)%c3);
    for each (Mymap::value_type elem in c5)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule
    Mymap c6(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Mymap::value_type>^)%c3,
                cliext::greater_equal<wchar_t>());
    for each (Mymap::value_type elem in c6)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct by copying another container
    Mymap c7(c4);
    for each (Mymap::value_type elem in c7)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct by copying a container handle
    Mymap c8(%c3);
    for each (Mymap::value_type elem in c8)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
[a 1] [b 2] [c 3]
size() = 0
[c 3] [b 2] [a 1]
[a 1] [b 2] [c 3]
[c 3] [b 2] [a 1]
[a 1] [b 2] [c 3]
[c 3] [b 2] [a 1]
[c 3] [b 2] [a 1]
[a 1] [b 2] [c 3]

map::mapped_type

Her bir anahtar ile ilişkili bir eşlenen değer türü.

Sözdizimi

typedef Mapped mapped_type;

Açıklamalar

türü, şablon parametresi Mappediçin bir eş anlamlıdır.

Örnek

// cliext_map_mapped_type.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using mapped_type
    for (Mymap::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in mapped_type object
        Mymap::mapped_type val = it->second;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

1 2 3

map::operator=

Denetimli sıranın yerini alır.

Sözdizimi

map<Key, Mapped>% operator=(map<Key, Mapped>% right);

Parametreler

right
Kopyalanacak kapsayıcı.

Açıklamalar

Üye işleci nesnesine kopyalanır right ve döndürür *this. Denetimli sırayı içindeki rightdenetimli sıranın bir kopyasıyla değiştirmek için kullanırsınız.

Örnek

// cliext_map_operator_as.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymap c2;
    c2 = c1;
    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]

map::operator[]

Bir anahtarı ilişkili eşlenmiş değeriyle eşler.

Sözdizimi

mapped_type operator[](key_type key);

Parametreler

key
Aranacak anahtar değeri.

Açıklamalar

Üye işlevleri, ile eşdeğer sıralamaya keysahip bir öğe bulmaya çalışır. Bir tane bulursa, ilişkili eşlenmiş değeri döndürür; aksi takdirde, ilişkili (varsayılan) eşlenmiş değeri ekler value_type(key, mapped_type()) ve döndürür. İlişkili anahtarı verilen eşlenmiş bir değeri aramak veya hiçbir anahtar bulunamazsa anahtar için bir girdinin mevcut olduğundan emin olmak için bunu kullanırsınız.

Örnek

// cliext_map_operator_sub.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("c1[{0}] = {1}",
        L'A', c1[L'A']);
    System::Console::WriteLine("c1[{0}] = {1}",
        L'b', c1[L'b']);

    // redisplay altered contents
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // alter mapped values and redisplay
    c1[L'A'] = 10;
    c1[L'c'] = 13;
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
c1[A] = 0
c1[b] = 2
[A 0] [a 1] [b 2] [c 3]
[A 10] [a 1] [b 2] [c 13]

map::rbegin

Ters denetimli sıranın başlangıcını belirtir.

Sözdizimi

reverse_iterator rbegin();

Açıklamalar

Üye işlevi, denetlenen dizinin son öğesini veya boş bir dizinin başlangıcının hemen ötesinde belirten bir ters yineleyici döndürür. Bu nedenle, ters sıranın öğesini belirtir beginning . Ters sırada görülen denetimli sıranın current başlangıcını belirten bir yineleyici elde etmek için bunu kullanırsınız, ancak denetlenen sıranın uzunluğu değişirse durumu değişebilir.

Örnek

// cliext_map_rbegin.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Mymap::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = [{0} {1}]",
        rit->first, rit->second);
    ++rit;
    System::Console::WriteLine("*++rbegin() = [{0} {1}]",
        rit->first, rit->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*rbegin() = [c 3]
*++rbegin() = [b 2]

map::reference

Bir öğe için bir başvuru türü.

Sözdizimi

typedef value_type% reference;

Açıklamalar

türü, bir öğeye başvuruyu açıklar.

Örnek

// cliext_map_reference.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Mymap::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        Mymap::reference ref = *it;
        System::Console::Write("[{0} {1}] ", ref->first, ref->second);
        }
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

map::rend

Ters denetimli sıranın sonunu belirtir.

Sözdizimi

reverse_iterator rend();

Açıklamalar

Üye işlevi, denetlenen sıranın başlangıcının hemen ötesine işaret eden bir ters yineleyici döndürür. Bu nedenle, ters sıranın öğesini belirtir end . Ters sırada görülen denetimli sıranın current sonunu belirten bir yineleyici elde etmek için bunu kullanırsınız, ancak denetlenen sıranın uzunluğu değişirse durumu değişebilir.

Örnek

// cliext_map_rend.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Mymap::reverse_iterator rit = c1.rend();
    --rit;
    --rit;
    System::Console::WriteLine("*-- --rend() = [{0} {1}]",
        rit->first, rit->second);
    ++rit;
    System::Console::WriteLine("*--rend() = [{0} {1}]",
        rit->first, rit->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*-- --rend() = [b 2]
*--rend() = [a 1]

map::reverse_iterator

Denetimli sıra için ters yineleyicinin türü.

Sözdizimi

typedef T3 reverse_iterator;

Açıklamalar

türü, denetlenen dizi için ters yineleyici görevi görecek belirtilmemiş türdeki T3 bir nesneyi açıklar.

Örnek

// cliext_map_reverse_iterator.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" reversed
    Mymap::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("[{0} {1}] ", rit->first, rit->second);
    System::Console::WriteLine();
    return (0);
    }

[c 3] [b 2] [a 1]

map::size

Öğe sayısını sayar.

Sözdizimi

size_type size();

Açıklamalar

Üye işlevi, denetlenen sıranın uzunluğunu döndürür. Şu anda denetimli dizideki öğelerin sayısını belirlemek için bunu kullanırsınız. Tek ilgilendiğiniz dizinin sıfır olmayan boyuta sahip olup olmadığıysa, bkz empty(). .

Örnek

// cliext_map_size.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

    // add elements and clear again
    c1.insert(Mymap::make_value(L'd', 4));
    c1.insert(Mymap::make_value(L'e', 5));
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

[a 1] [b 2] [c 3]
size() = 0 after clearing
size() = 2 after adding 2

map::size_type

İki öğe arasındaki işaretli mesafenin türü.

Sözdizimi

typedef int size_type;

Açıklamalar

Türü negatif olmayan öğe sayısını açıklar.

Örnek

// cliext_map_size_type.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // compute positive difference
    Mymap::size_type diff = 0;
    for (Mymap::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

[a 1] [b 2] [c 3]
end()-begin() = 3

map::swap

İki kapsayıcının içeriğinin yerini değiştirir.

Sözdizimi

void swap(map<Key, Mapped>% right);

Parametreler

right
İçindekileri değiştirecek kapsayıcı.

Açıklamalar

Üye işlevi, ve arasında this rightdenetlenen dizileri değiştirir. Bunu sürekli olarak yapar ve hiçbir özel durum oluşturmaz. bunu, iki kapsayıcının içeriğini değiştirmek için hızlı bir yol olarak kullanırsınız.

Örnek

// cliext_map_swap.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct another container with repetition of values
    Mymap c2;
    c2.insert(Mymap::make_value(L'd', 4));
    c2.insert(Mymap::make_value(L'e', 5));
    c2.insert(Mymap::make_value(L'f', 6));
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
[d 4] [e 5] [f 6]
[d 4] [e 5] [f 6]
[a 1] [b 2] [c 3]

map::to_array

Denetimli diziyi yeni bir diziye kopyalar.

Sözdizimi

cli::array<value_type>^ to_array();

Açıklamalar

üye işlevi, denetlenen diziyi içeren bir dizi döndürür. Denetimli sıranın bir kopyasını dizi biçiminde almak için bunu kullanırsınız.

Örnek

// cliext_map_to_array.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // copy the container and modify it
    cli::array<Mymap::value_type>^ a1 = c1.to_array();

    c1.insert(Mymap::make_value(L'd', 4));
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (Mymap::value_type elem in a1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3] [d 4]
[a 1] [b 2] [c 3]

map::upper_bound

Belirtilen anahtarla eşleşen aralığın sonunu bulur.

Sözdizimi

iterator upper_bound(key_type key);

Parametreler

key
Aranacak anahtar değeri.

Açıklamalar

üye işlevi, denetlenen dizide ile eşdeğer sıralamaya sahip olan son öğeyi X keybelirler. Böyle bir öğe yoksa veya denetlenen dizideki son öğeyse X döndürür end(); aksi takdirde, öğesinin ötesindeki Xilk öğeyi belirten bir yineleyici döndürür. Bunu, şu anda denetimli dizide belirtilen bir anahtarla eşleşen bir öğe dizisinin sonunu bulmak için kullanırsınız.

Örnek

// cliext_map_upper_bound.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("upper_bound(L'x')==end() = {0}",
        c1.upper_bound(L'x') == c1.end());

    Mymap::iterator it = c1.upper_bound(L'a');
    System::Console::WriteLine("*upper_bound(L'a') = [{0} {1}]",
        it->first, it->second);
    it = c1.upper_bound(L'b');
    System::Console::WriteLine("*upper_bound(L'b') = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
upper_bound(L'x')==end() = True
*upper_bound(L'a') = [b 2]
*upper_bound(L'b') = [c 3]

map::value_comp

İki öğe değeri için sıralama temsilcisini kopyalar.

Sözdizimi

value_compare^ value_comp();

Açıklamalar

Üye işlevi, denetlenen sırayı sıralamak için kullanılan sıralama temsilcisini döndürür. bunu iki öğe değerini karşılaştırmak için kullanırsınız.

Örnek

// cliext_map_value_comp.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    Mymap::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
        kcomp(Mymap::make_value(L'a', 1),
            Mymap::make_value(L'a', 1)));
    System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
        kcomp(Mymap::make_value(L'a', 1),
            Mymap::make_value(L'b', 2)));
    System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
        kcomp(Mymap::make_value(L'b', 2),
            Mymap::make_value(L'a', 1)));
    System::Console::WriteLine();
    return (0);
    }

compare([L'a', 1], [L'a', 1]) = False
compare([L'a', 1], [L'b', 2]) = True
compare([L'b', 2], [L'a', 1]) = False

map::value_compare

İki öğe değeri için sıralama temsilcisi.

Sözdizimi

Microsoft::VisualC::StlClr::BinaryDelegate<generic_value, generic_value, bool>
    value_compare;

Açıklamalar

türü, temsilcinin değer bağımsız değişkenlerinin sırasını belirleyen bir eş anlamlıdır.

Örnek

// cliext_map_value_compare.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    Mymap::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
        kcomp(Mymap::make_value(L'a', 1),
            Mymap::make_value(L'a', 1)));
    System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
        kcomp(Mymap::make_value(L'a', 1),
            Mymap::make_value(L'b', 2)));
    System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
        kcomp(Mymap::make_value(L'b', 2),
            Mymap::make_value(L'a', 1)));
    System::Console::WriteLine();
    return (0);
    }

compare([L'a', 1], [L'a', 1]) = False
compare([L'a', 1], [L'b', 2]) = True
compare([L'b', 2], [L'a', 1]) = False

map::value_type

Öğenin türü.

Sözdizimi

typedef generic_value value_type;

Açıklamalar

türü, için generic_valuebir eş anlamlıdır.

Örnek

// cliext_map_value_type.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using value_type
    for (Mymap::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in value_type object
        Mymap::value_type val = *it;
        System::Console::Write("[{0} {1}] ", val->first, val->second);
        }
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

operator!= (map) (STL/CLR)

Liste eşit değil karşılaştırması.

Sözdizimi

template<typename Key,
    typename Mapped>
    bool operator!=(map<Key, Mapped>% left,
        map<Key, Mapped>% right);

Parametreler

left
Karşılaştırmak için sol kapsayıcı.

right
Karşılaştırmak için doğru kapsayıcı.

Açıklamalar

işleç işlevi döndürür !(left == right). İki eşleme öğeye göre karşılaştırıldığında aynı sıralı right olup olmadığını left test etmek için bunu kullanırsınız.

Örnek

// cliext_map_operator_ne.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymap c2;
    c2.insert(Mymap::make_value(L'a', 1));
    c2.insert(Mymap::make_value(L'b', 2));
    c2.insert(Mymap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] != [a b c] is {0}",
        c1 != c1);
    System::Console::WriteLine("[a b c] != [a b d] is {0}",
        c1 != c2);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] != [a b c] is False
[a b c] != [a b d] is True

operator< (harita)

Küçüktür karşılaştırması listeleyin.

Sözdizimi

template<typename Key,
    typename Mapped>
    bool operator<(map<Key, Mapped>% left,
        map<Key, Mapped>% right);

Parametreler

left
Karşılaştırmak için sol kapsayıcı.

right
Karşılaştırmak için doğru kapsayıcı.

Açıklamalar

işleç işlevi, aynı zamanda doğru olduğu en düşük konum i için !(right[i] < left[i]) ise true left[i] < right[i]döndürür. Aksi takdirde döndürür left->size() < right->size(). İki eşleme öğeye göre karşılaştırıldığında önce right sıralanıp sıralı olmadığını left test etmek için bu işleci kullanın.

Örnek

// cliext_map_operator_lt.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymap c2;
    c2.insert(Mymap::make_value(L'a', 1));
    c2.insert(Mymap::make_value(L'b', 2));
    c2.insert(Mymap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] < [a b c] is {0}",
        c1 < c1);
    System::Console::WriteLine("[a b c] < [a b d] is {0}",
        c1 < c2);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] < [a b c] is False
[a b c] < [a b d] is True

operator<= (harita)

Küçük veya eşit karşılaştırmayı listeleyin.

Sözdizimi

template<typename Key,
    typename Mapped>
    bool operator<=(map<Key, Mapped>% left,
        map<Key, Mapped>% right);

Parametreler

left
Karşılaştırmak için sol kapsayıcı.

right
Karşılaştırmak için doğru kapsayıcı.

Açıklamalar

işleç işlevi döndürür !(right < left). İki eşleme öğeye göre karşılaştırıldıktan sonra right sıralanıp left sıralı olmadığını test etmek için bunu kullanırsınız.

Örnek

// cliext_map_operator_le.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymap c2;
    c2.insert(Mymap::make_value(L'a', 1));
    c2.insert(Mymap::make_value(L'b', 2));
    c2.insert(Mymap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] <= [a b c] is {0}",
        c1 <= c1);
    System::Console::WriteLine("[a b d] <= [a b c] is {0}",
        c2 <= c1);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] <= [a b c] is True
[a b d] <= [a b c] is False

operator== (harita)

Eşit karşılaştırmayı listeleyin.

Sözdizimi

template<typename Key,
    typename Mapped>
    bool operator==(map<Key, Mapped>% left,
        map<Key, Mapped>% right);

Parametreler

left
Karşılaştırmak için sol kapsayıcı.

right
Karşılaştırmak için doğru kapsayıcı.

Açıklamalar

işleç işlevi yalnızca tarafından left denetlenen ve right her konum ileft[i] == right[i]için aynı uzunluğa sahip olan diziler için true döndürür. İki eşleme öğeye göre karşılaştırıldığında aynı sıralanmış right olup olmadığını left test etmek için bunu kullanırsınız.

Örnek

// cliext_map_operator_eq.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymap c2;
    c2.insert(Mymap::make_value(L'a', 1));
    c2.insert(Mymap::make_value(L'b', 2));
    c2.insert(Mymap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] == [a b c] is {0}",
        c1 == c1);
    System::Console::WriteLine("[a b c] == [a b d] is {0}",
        c1 == c2);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] == [a b c] is True
[a b c] == [a b d] is False

operator> (harita)

Karşılaştırmadan daha büyük bir liste.

Sözdizimi

template<typename Key,
    typename Mapped>
    bool operator>(map<Key, Mapped>% left,
        map<Key, Mapped>% right);

Parametreler

left
Karşılaştırmak için sol kapsayıcı.

right
Karşılaştırmak için doğru kapsayıcı.

Açıklamalar

işleç işlevi döndürür right < left. İki eşleme öğeye göre karşılaştırıldıktan sonra right sıralanıp sıralı olmadığını left test etmek için bunu kullanırsınız.

Örnek

// cliext_map_operator_gt.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymap c2;
    c2.insert(Mymap::make_value(L'a', 1));
    c2.insert(Mymap::make_value(L'b', 2));
    c2.insert(Mymap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] > [a b c] is {0}",
        c1 > c1);
    System::Console::WriteLine("[a b d] > [a b c] is {0}",
        c2 > c1);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] > [a b c] is False
[a b d] > [a b c] is True

operator>= (harita)

Büyük veya eşit karşılaştırmayı listeleyin.

Sözdizimi

template<typename Key,
    typename Mapped>
    bool operator>=(map<Key, Mapped>% left,
        map<Key, Mapped>% right);

Parametreler

left
Karşılaştırmak için sol kapsayıcı.

right
Karşılaştırmak için doğru kapsayıcı.

Açıklamalar

işleç işlevi döndürür !(left < right). İki eşleme öğeye göre karşılaştırıldığında önce right sıralanıp left sıralı olmadığını test etmek için bunu kullanırsınız.

Örnek

// cliext_map_operator_ge.cpp
// compile with: /clr
#include <cliext/map>

typedef cliext::map<wchar_t, int> Mymap;
int main()
    {
    Mymap c1;
    c1.insert(Mymap::make_value(L'a', 1));
    c1.insert(Mymap::make_value(L'b', 2));
    c1.insert(Mymap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Mymap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Mymap c2;
    c2.insert(Mymap::make_value(L'a', 1));
    c2.insert(Mymap::make_value(L'b', 2));
    c2.insert(Mymap::make_value(L'd', 4));

    // display contents " [a 1] [b 2] [d 4]"
    for each (Mymap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] >= [a b c] is {0}",
        c1 >= c1);
    System::Console::WriteLine("[a b c] >= [a b d] is {0}",
        c1 >= c2);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [d 4]
[a b c] >= [a b c] is True
[a b c] >= [a b d] is False