std::map::count

std::map::count (tsz. std::map::counts)

1. (informatika) A 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.

A std::map<K, V> egy rendezett asszociatív konténer, amely kulcs-érték (key-value) párokat tárol, ahol:

• Minden kulcs egyedi (unique),
• A kulcsok automatikusan növekvő sorrendben rendeződnek (alapértelmezett: operator< alapján),
• A belső megvalósítás általában piros-fekete fa (red-black tree).

Példa:

std::map<std::string, int> szotar;
szotar = 3;
szotar = 5;

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
}

• find() – 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
}

A 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

• Feltételvizsgálathoz ideális (pl. if (map.count(kulcs)) ...)
• Gyors: O(log n) időben fut (std::map esetén)
• Biztonságos: nem ír bele a map-be (ellentétben pl. operator-tel)

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.

• Időkomplexitás: O(log n) – mivel belsőleg fa szerkezetet használ,
• Térigény: nincs extra memóriaigénye, csak olvasást végez.

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.

• std::map::count - Szótár.net (en-hu)
• std::map::count - Sztaki (en-hu)
• std::map::count - Merriam–Webster
• std::map::count - Cambridge
• std::map::count - WordNet
• std::map::count - Яндекс (en-ru)
• std::map::count - Google (en-hu)
• std::map::count - Wikidata
• std::map::count - Wikipédia (angol)