Am'm încercarea de a verifica dacă o cheie dată este într-o hartă și oarecum poate't face:
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
deci, cum pot imprima ceea ce este în p?
Pentru a verifica dacă o anumită cheie de pe hartă există, utilizați "count" funcția de membru în unul din următoarele moduri:
m.count(key) > 0
m.count(key) == 1
m.count(key) != 0
De documentația pentru harta::găsiți spune: "un Alt membru funcție, harta::count
, poate fi folosit pentru a verifica dacă o anumită cheie există."
De documentația pentru harta::count
spune: "Pentru că toate elementele într-o hartă container sunt unice, funcția poate returna doar 1 (dacă elementul este găsit) sau zero (în caz contrar)."
Pentru a extrage o valoare de pe hartă printr-o cheie care știi să existe, utilizarea harta::la:
value = m.at(key)
Spre deosebire de harta::operator[], harta::la
nu va crea o nouă cheie de pe hartă dacă cheia specificată nu există.
C++20 ne dă std::map::conține
să fac asta.
#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";
}
}
Cred că vrei hartă::găsi. Dacă m.găsi("f")
este egal cu m.end()
, atunci cheia nu a fost găsit. În caz contrar, find returnează un iterator îndreptat la element găsit.
Eroarea este din cauza p.primul este un iterator, care nu't de lucru pentru flux de inserție. Schimba-ti ultima linie a
cout << (p.în primul rând)->primul;. " p " este o pereche de iteratori,
p.primul este un iterator, `p.primul->primul este cheia șir.
O hartă poate fi un element pentru o cheie dată, așa equal_range` e't foarte util. L's definite pentru harta, deoarece's definită pentru toate asociative containere, dar's mult mai interesant pentru multimap.
template <typename T, typename Key>
bool key_exists(const T& container, const Key& key)
{
return (container.find(key) != std::end(container));
}
Desigur, dacă ai vrut pentru a obține crescator ai putea întotdeauna șablon o funcție care, de asemenea, a avut o găsit funcție și nu a fost găsit funcție, ceva de genul asta:
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);
}
}
Și de a folosi astfel:
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; });
Dezavantajul la acest lucru este de a veni cu un nume bun, "find_and_execute" este ciudat și nu pot't vin cu nimic mai bun pe partea de sus a capul meu...
map<string, string> m;
verifica cheie există sau nu, și să se întoarcă numărul de apare(0/1 în hartă):
int num = m.count("f");
if (num>0) {
//found
} else {
// not found
}
verifica cheie există sau nu, și să se întoarcă iterator:
map<string,string>::iterator mi = m.find("f");
if(mi != m.end()) {
//found
//do something to mi.
} else {
// not found
}
în întrebarea dumneavoastră, eroarea cauzată de rău operatorul<<suprasarcină, pentru că
p.prima "este" harta<string, string>`, nu puteți să-l imprimați. încercați acest lucru:
if(p.first != p.second) {
cout << p.first->first << " " << p.first->second << endl;
}
C++17simplificat acest lucru un pic mai mult cu un
Dacă declarație cu inițializare`.
În acest fel puteți avea tort și mănânci prea.
if ( auto it{ m.find( "key" ) }; it != std::end( m ) )
{
// Destructure the returned pair in to
// its sub components. Get them by reference.
// You can also get them by 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..
}
Fii atent în compararea rezultatului cu sfârșitul ca pentru harta 'm' ca toate au răspuns făcut de mai sus harta<string,string>::iterator i = m.găsi("f");
if (i == m.end())
{
}
else
{
}
tu nu ar trebui să încercați și de a efectua orice operațiune, cum ar fi imprimarea cheie sau o valoare cu iterator i dacă își egal cu m.end() va duce la eroare de segmentare.
Stiu ca aceasta intrebare are deja niște răspunsuri bune, dar cred că soluția mea este în valoare de partajare.
Acesta funcționează atât pentru `std::map " și " std::vector<std::pair<T, U>> și este disponibil de la C++11.
``c++
șablon <typename ForwardIterator, typename Cheie>
bool contains_key(ForwardIterator în primul rând, ForwardIterator trecută, Cheie const cheie) {
folosind ValueType = typename std::iterator_traits
auto search_result = std::find_if( în primul rând, ultimul, [&cheie](ValueType const& element) { elementul retur.prima == cheie; } );
dacă (search_result == ultim) { return false; } else { return true; } } ``
Compararea codului de std::map::găsi și std::map::conta, I'd spune că primul poate produce un avantaj de performanță:
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);
}
Dacă doriți să comparați pereche de hartă, puteți utiliza această metodă:
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;
}
}
Aceasta este o tehnică utilă.