struktura do przechowyania wielu rekordów i szybkiego wyszukowania po kluczu

Mam strukturę do przechowywania danych

struct TData
{
    std::string key;
    int data;
};

oraz jakiś kontener do przechowywania wielu obiektów na początek std::vector

std::vector<TData> data;

Chciałbym dodawać do kontenera kolejne dane z uwzględnieniem zasady że "key" jest unikalny w filozofii bazodanowej PRIMARY KEY , jak "key" istnieje to aktualizuje istniejący rekord

Dodanie kolejnego rekordu wymaga przeszukania wszystkich rekordów

Jak poprawić złożoność obliczeniową ?

TData * find(TData &whatFind)
{
    for(auto &one: data)
    {
        if(one.key == whatFind.key)
        {
            return &one;
        }
    }
    return nullptr;
}


void addRect(TData &rec)
{
    TData *tmp=find(rec);
    if(!tmp)
    {
        data.emplace_back(rec);
    }
    else
    {
        tmp->data = rec.data;
    }

}

int main()
{
    TData data1{"key1",1};

    addRect(data1);

    TData data2{"key2",2};
   
   
    addRect(data2);


    TData data1prim{"key1",11};
    addRect(data1prim);

    for (auto &one: data)
    {
        printf("key=%s data=%d\n", one.key.c_str(), one.data);
    }
}

https://godbolt.org/z/TWETqadn3

W pascal to bym użył posortowanej TStringList

Właśnie mi się wydało, ze nawyk zaczynania od wielkiego T ....

Do zagadnień klucz-wartość jest std::map<K,V> - czy ja czegoś nie zrozumiałem ?

TData * find(TData &whatFind)

Nie widzi mi się szukanie kontenera typu X po typie X, już prędzej po K zawartym w X. A jak już referencja, to const jest jeszcze lepsza

Nie drukuj w C++ przez printf .... x.c_str(), to strasznie źle wygląda

map<K,V> - koszt dodawania - O(log(n))
unordered_map<K,V> - koszt dodawania - O(1)

Z tym że należy rozumieć że poniżej 1000 (to tak pi razy drzwi) rekordów map<K,V> - wygrywa

Może rzeczywiście za bardzo kombinuje !
std::map<K,V> jest tym czego szukam