std::map::count (tsz. std::map::counts)
std::map::count
függvény a C++ Standard Template Library (STL) egyik tagfüggvénye, amely egy adott kulcs előfordulásainak számát adja vissza egy std::map
vagy std::multimap
típusú tárolóban.
std::map
?A std::map<K, V>
egy rendezett asszociatív konténer, amely kulcs-érték (key-value
) párokat tárol, ahol:
unique
),operator<
alapján),Példa:
std::map<std::string, int> szotar;
szotar = 3;
szotar = 5;
count()
szerepe?A count()
függvény megmondja, hogy létezik-e egy adott kulcs a map-ben.
size_t count(const Key& k) const;
0
, ha a kulcs nem szerepel a map-ben,1
, ha a kulcs benne van (mert std::map
-ben legfeljebb egyszer lehet jelen).Megjegyzés: std::map
→ 0 vagy 1
, std::multimap
→ 0 vagy több
(ott a count()
számolja az összes előfordulást is).
#include <iostream>
#include <map>
int main() {
std::map<std::string, int> gyumolcsok;
gyumolcsok = 2;
gyumolcsok = 4;
if (gyumolcsok.count("alma") > 0) {
std::cout << "Van alma.\n";
} else {
std::cout << "Nincs alma.\n";
}
std::cout << "Narancs: " << gyumolcsok.count("narancs") << " darab\n";
}
Van alma. Narancs: 0 darab
A count()
belsőleg a find()
függvényt használja:
return find(k) == end() ? 0 : 1;
Ez logikai szempontból hasonló a következőhöz:
if (map.find(kulcs) != map.end()) {
// kulcs megtalálva
}
count()
helyettfind()
– visszaadja az iterator-t, ha létezik a kulcs.contains()
(C++20-tól!) – sokkal olvashatóbb:if (map.contains("korte")) {
// C++20: gyorsabb és elegánsabb
}
std::multimap
eseténA count()
megmondja, hányszor szerepel egy kulcs.
std::multimap<std::string, int> jegyek;
jegyek.insert({"Anna", 5});
jegyek.insert({"Anna", 4});
jegyek.insert({"Bela", 3});
std::cout << "Anna jegyeinek száma: " << jegyek.count("Anna") << "\n";
Anna jegyeinek száma: 2
count()
?if (map.count(kulcs)) ...
)std::map
esetén)operator
-tel)
operator
-tel teszteléshez:if (map) { ... } // HIBA, ha nem volt benne, most bekerült!
Ez automatikusan beszúrja a kulcsot alapértelmezett értékkel!
if (map.count("kulcs")) { ... } // Nem szúr be semmit
A count()
működéséhez fontos, hogy a megadott kulcs típus kompatibilis legyen a map kulcsával.
std::map<int, std::string> m;
m = "negyvenketto";
// m.count("42") // HIBÁS: nem int típus
#include <iostream>
#include <map>
#include <string>
void kerdezes(const std::map<std::string, std::string>& szotar, const std::string& szo) {
if (szotar.count(szo)) {
std::cout << szo << " jelentése: " << szotar.at(szo) << "\n";
} else {
std::cout << "Nincs ilyen szó a szótárban.\n";
}
}
int main() {
std::map<std::string, std::string> szotar = {
{"alma", "apple"},
{"korte", "pear"},
{"szilva", "plum"}
};
kerdezes(szotar, "alma");
kerdezes(szotar, "barack");
}
alma jelentése: apple Nincs ilyen szó a szótárban.
Tulajdonság | std::map::count
|
---|---|
Visszatérési érték | 0 vagy 1 (std::map ), tetszőleges n (std::multimap )
|
Bemenet | Kulcs típus (const K& )
|
Használat célja | Kulcs létezésének ellenőrzése |
Komplexitás | O(log n) |
Alternatívák | find() , contains() (C++20)
|
Veszély | Ne keverd össze operator -tel, az módosít!
|
A count()
egy kicsi, de fontos funkció az STL-ben, amely segít elkerülni a kulcsok akaratlan beszúrását. Különösen jól használható ellenőrzésekre, keresések előtti szűrésre, valamint több példányt kezelő multimap
-ek esetén gyakorisági elemzésre.