std::map::find în C++

iterator find(const Cheie& cheie);
size_type count(const Cheie& cheie) const;
bool contains(const Cheie& cheie) const;   // C++20

Ce face std::map::find

find(cheie) caută cheia în O(log n) și returnează un iterator la perechea găsită, sau end() dacă nu există. Folosește-l când ai nevoie și de valoare: verifici o dată și apoi citești it->second, fără a doua căutare.

contains(cheie) (C++20) returnează true sau false și este cea mai clară verificare. count(cheie) returnează 0 sau 1 la std::map (la std::multimap poate fi mai mare) și era metoda obișnuită înainte de C++20. Niciuna dintre ele nu adaugă cheia, spre deosebire de operator[].

Parametri

Parametru	Descriere
cheie	Cheia căutată.

Ce returnează

find: iterator la element sau end(). count: numărul de elemente cu cheia. contains: bool.

Exemple

Exemplul 1: Căutare cu find

#include <map>
#include <print>
#include <string>

int main() {
    std::map<std::string, int> coduri{{"Iași", 700000}, {"Cluj", 400000}, {"Brașov", 500000}};
    for (std::string oras : {"Cluj", "Arad"}) {
        auto it = coduri.find(oras);
        if (it != coduri.end()) {
            std::println("{}: cod poștal începe cu {}", it->first, it->second);
        } else {
            std::println("{}: nu este în listă", oras);
        }
    }
}

Rezultat

Cluj: cod poștal începe cu 400000
Arad: nu este în listă

Exemplul 2: contains și count

#include <map>
#include <print>
#include <string>

int main() {
    std::map<std::string, int> stoc{{"mere", 10}, {"pere", 0}};
    std::println("contains(\"mere\"): {}", stoc.contains("mere"));
    std::println("contains(\"kiwi\"): {}", stoc.contains("kiwi"));
    std::println("count(\"pere\"):    {}", stoc.count("pere"));
    std::println("count(\"kiwi\"):    {}", stoc.count("kiwi"));
    std::println("Chei: {} (niciuna adăugată)", stoc.size());
}

Rezultat

contains("mere"): true
contains("kiwi"): false
count("pere"):    1
count("kiwi"):    0
Chei: 2 (niciuna adăugată)

Greșeli frecvente

• Faci if (m.contains(k)) { x = m[k]; }: două căutări. Cu auto it = m.find(k); if (it != m.end()) x = it->second; cauți o singură dată.
• Folosești std::find(m.begin(), m.end(), ...) din <algorithm>. Acesta caută element cu element (O(n)) și cere o pereche întreagă; funcția membră m.find(cheie) este mult mai rapidă.
• Citești it->second fără să verifici it != m.end(): comportament nedefinit dacă cheia lipsește.

Comenzi înrudite

• std::map: Dicționar ordonat: asociază fiecărei chei unice o valoare și păstrează cheile sortate.
• std::map::at: Returnează valoarea unei chei existente; aruncă std::out_of_range dacă cheia nu există, fără să o adauge.
• std::set::find: Caută o valoare în set: find() returnează un iterator (sau end()), contains() și count() spun dacă există.
• std::map::lower_bound: lower_bound() găsește prima cheie mai mare sau egală cu valoarea dată, upper_bound() prima cheie strict mai mare.
• std::find: Caută prima apariție a unei valori într-un interval și returnează un iterator către ea.