Cara menemukan jika kunci yang diberikan ada di C ++ std :: map

Saya mencoba memeriksa apakah kunci yang diberikan ada di peta dan agak tidak bisa melakukannya:

typedef map<string,string>::iterator mi;
map<string, string> m;
m.insert(make_pair("f","++--"));
pair<mi,mi> p = m.equal_range("f");//I'm not sure if equal_range does what I want
cout << p.first;//I'm getting error here

jadi bagaimana saya bisa mencetak apa yang ada di p?

Menggunakan map::find

if ( m.find("f") == m.end() ) {
  // not found
} else {
  // found
}

Untuk memeriksa apakah kunci tertentu di peta ada, gunakan countfungsi anggota dalam salah satu cara berikut:

m.count(key) > 0
m.count(key) == 1
m.count(key) != 0

The dokumentasi untuk map::findmengatakan: "fungsi anggota lain, map::count, dapat digunakan untuk hanya memeriksa apakah kunci tertentu ada."

The dokumentasi untuk map::countmengatakan: "Karena semua elemen dalam wadah peta yang unik, fungsi hanya dapat kembali 1 (jika unsur ini ditemukan) atau nol (jika tidak)."

Untuk mengambil nilai dari peta melalui kunci yang Anda tahu ada, gunakan peta :: di :

value = m.at(key)

Tidak seperti map :: operator [] , map::attidak akan membuat kunci baru di peta jika kunci yang ditentukan tidak ada.

C ++ 20 memberi kita std::map::containsuntuk melakukan itu.

#include <iostream>
#include <string>
#include <map>

int main()
{
    std::map<int, std::string> example = {{1, "One"}, {2, "Two"}, 
                                     {3, "Three"}, {42, "Don\'t Panic!!!"}};

    if(example.contains(42)) {
        std::cout << "Found\n";
    } else {
        std::cout << "Not found\n";
    }
}

Anda bisa menggunakan .find():

map<string,string>::iterator i = m.find("f");

if (i == m.end()) { /* Not found */ }
else { /* Found, i->first is f, i->second is ++-- */ }

m.find == m.end() // not found 

Jika Anda ingin menggunakan API lain, cari cari m.count(c)>0

 if (m.count("f")>0)
      cout << " is an element of m.\n";
    else 
      cout << " is not an element of m.\n";

Saya pikir kamu mau map::find. Jika m.find("f")sama dengan m.end(), maka kuncinya tidak ditemukan. Jika tidak, temukan kembalikan iterator yang menunjuk ke elemen yang ditemukan.

Kesalahan ini karena p.firstmerupakan iterator, yang tidak berfungsi untuk penyisipan aliran. Ubah baris terakhir Anda ke cout << (p.first)->first;. padalah sepasang iterator, p.firstadalah iterator, p.first->firstadalah kunci string.

Peta hanya dapat memiliki satu elemen untuk kunci yang diberikan, jadi equal_rangetidak terlalu berguna. Ini ditentukan untuk peta, karena itu ditentukan untuk semua wadah asosiatif, tetapi jauh lebih menarik untuk multimap.

C++17disederhanakan ini sedikit lebih banyak dengan If statement with initializer. Dengan cara ini Anda dapat memiliki kue dan memakannya juga.

if ( auto it{ m.find( "key" ) }; it != std::end( m ) ) 
{
    // Use `structured binding` to get the key
    // and value.
    auto[ key, value ] { *it };

    // Grab either the key or value stored in the pair.
    // The key is stored in the 'first' variable and
    // the 'value' is stored in the second.
    auto mkey{ it->first };
    auto mvalue{ it->second };

    // That or just grab the entire pair pointed
    // to by the iterator.
    auto pair{ *it };
} 
else 
{
   // Key was not found..
}

map<string, string> m;

periksa kunci ada atau tidak, dan kembalikan jumlah yang terjadi (0/1 di peta):

int num = m.count("f");  
if (num>0) {    
    //found   
} else {  
    // not found  
}

periksa kunci ada atau tidak, dan kembalikan iterator:

map<string,string>::iterator mi = m.find("f");  
if(mi != m.end()) {  
    //found  
    //do something to mi.  
} else {  
    // not found  
}  

dalam pertanyaan Anda, kesalahan yang disebabkan oleh buruk operator<<yang berlebihan, karena p.firstini map<string, string>, Anda tidak dapat mencetak keluar. coba ini:

if(p.first != p.second) {
    cout << p.first->first << " " << p.first->second << endl;
}

template <typename T, typename Key>
bool key_exists(const T& container, const Key& key)
{
    return (container.find(key) != std::end(container));
}

Tentu saja jika Anda ingin menjadi pelamun Anda selalu bisa templat keluar fungsi yang juga mengambil fungsi ditemukan dan fungsi tidak ditemukan, seperti ini:

template <typename T, typename Key, typename FoundFunction, typename NotFoundFunction>
void find_and_execute(const T& container, const Key& key, FoundFunction found_function, NotFoundFunction not_found_function)
{
    auto& it = container.find(key);
    if (it != std::end(container))
    {
        found_function(key, it->second);
    }
    else
    {
        not_found_function(key);
    }
}

Dan gunakan seperti ini:

    std::map<int, int> some_map;
    find_and_execute(some_map, 1,
        [](int key, int value){ std::cout << "key " << key << " found, value: " << value << std::endl; },
        [](int key){ std::cout << "key " << key << " not found" << std::endl; });

Kelemahan dari ini adalah datang dengan nama yang bagus, "find_and_execute" canggung dan saya tidak dapat menemukan sesuatu yang lebih baik dari atas kepala saya ...

Hati-hati dalam membandingkan hasil pencarian dengan akhir seperti untuk peta 'm' karena semua jawaban telah dilakukan di atas peta :: iterator i = m.find ("f");

 if (i == m.end())
 {
 }
 else
 {
 }  

Anda tidak boleh mencoba dan melakukan operasi apa pun seperti mencetak kunci atau nilai dengan iterator i jika sama dengan m.end () jika tidak maka akan menyebabkan kesalahan segmentasi.

Membandingkan kode std :: map :: find dan std :: map :: count, saya katakan yang pertama dapat menghasilkan beberapa keuntungan kinerja:

const_iterator find(const key_type& _Keyval) const
    {   // find an element in nonmutable sequence that matches _Keyval
    const_iterator _Where = lower_bound(_Keyval); // Here one looks only for lower bound
    return (_Where == end()
        || _DEBUG_LT_PRED(this->_Getcomp(),
            _Keyval, this->_Key(_Where._Mynode()))
                ? end() : _Where);
    }

size_type count(const key_type& _Keyval) const
    {   // count all elements that match _Keyval
    _Paircc _Ans = equal_range(_Keyval); // Here both lower and upper bounds are to be found, which is presumably slower.
    size_type _Num = 0;
    _Distance(_Ans.first, _Ans.second, _Num);
    return (_Num);
    }

Saya tahu pertanyaan ini sudah memiliki beberapa jawaban yang baik tetapi saya pikir solusi saya layak untuk dibagikan.

Ia bekerja untuk keduanya std::mapdan std::vector<std::pair<T, U>>dan tersedia dari C ++ 11.

template <typename ForwardIterator, typename Key>
bool contains_key(ForwardIterator first, ForwardIterator last, Key const key) {
    using ValueType = typename std::iterator_traits<ForwardIterator>::value_type;

    auto search_result = std::find_if(
        first, last,
        [&key](ValueType const& item) {
            return item.first == key;
        }
    );

    if (search_result == last) {
        return false;
    } else {
        return true;
    }
}

Jika Anda ingin membandingkan pasangan peta, Anda dapat menggunakan metode ini:

typedef map<double, double> TestMap;
TestMap testMap;
pair<map<double,double>::iterator,bool> controlMapValues;

controlMapValues= testMap.insert(std::pair<double,double>(x,y));
if (controlMapValues.second == false )
{
    TestMap::iterator it;
    it = testMap.find(x);

    if (it->second == y)
    {
        cout<<"Given value is already exist in Map"<<endl;
    }
}

Ini adalah teknik yang berguna.

map <int , char>::iterator itr;
    for(itr = MyMap.begin() ; itr!= MyMap.end() ; itr++)
    {
        if (itr->second == 'c')
        {
            cout<<itr->first<<endl;
        }
    }