Trigger for std::map operation - c++

Question

I want to implement something like maplistner in c++ for std::map. So when a key is added or updated in std::map it should trigger a function or object.
It should be as:
class MapListener : public std::map
{
// ----- MapListener methods---
public:
// Invoked when a map entry has been inserted.
virtual void entryInserted();
// Invoked when a map entry has been updated.
virtual void entryUpdated();
// Invoked when a map entry has been removed.
virtual void entryDeleted();
};
Any help will be appreciated.
Thanks

Answer 1

Solution
(I am not advocating you should do this, just showing how to do so, because this sounds very much like the x-y problem to me).
template<class Key, class T, class Compare = std::less<Key>>
class EventMap final
{
public:
EventMap(): data_{}
{}
// std::map::insert looks like this:
// std::pair<iterator,bool> insert( const value_type& value );
using insert_callback = void (const value_type& inserted);
void on_insert(insert_callback* cb)
{
on_insert_ = cb;
}
// wrapped insert:
void insert(const value_type& value)
{
data_.insert(value);
if(on_insert_)
(*on_insert_)(value);
}
// TODO: add similar code for other methods w/ callbacks
private:
std::map<Key, T, Compare> data_;
insert_callback *on_insert_ = nullptr;
};
client callback:
auto on_insertion(const auto& kv)
{
std::cout << "inserted: " << kv.first << ", " << kv.second << "\n";
}
int main()
{
EventMap<std::string, std::string> map;
map.on_insert(&on_insertion);
map.insert({"123", 123}); // will call on_insertion after inserting
}

Answer 2

I apologise for blatantly ripping off #utnapistim solution, but the original would not compile. Nevertheless I find it interesting and would like to share working version:
#include <iostream>
#include <string>
#include <map>
template<class Key, class T, class Compare = std::less<Key>>
class EventMap final
{
public:
EventMap() : data_{}
{}
// std::map::insert looks like this:
// std::pair<iterator,bool> insert( const value_type& value );
using insert_callback = void(const std::pair<const Key, T> &inserted);
using erase_callback = void(const Key &key);
void on_insert(insert_callback* icb)
{
on_insert_ = icb;
}
void on_erase(erase_callback *ecb)
{
on_erase_ = ecb;
}
// wrapped insert:
void insert(const std::pair<const Key, T>&value)
{
data_.insert(value);
if (on_insert_)
(*on_insert_)(value);
}
// wrapped erase:
void erase(const Key &key)
{
data_.erase(key);
if (on_erase_)
(*on_erase_)(key);
}
// TODO: add similar code for other methods w/ callbacks
private:
std::map<const Key, T, Compare> data_;
insert_callback *on_insert_ = nullptr;
erase_callback *on_erase_ = nullptr;
};
int main()
{
EventMap<const std::string, std::string> map;
auto on_insert_fn = [](std::pair<const std::string, std::string> const &kv)
{
std::cout << "inserted: " << kv.first << ", " << kv.second << "\n";
};
auto on_erase_fn = [](const std::string &key)
{
std::cout << "erased: " << key << "\n";
};
map.on_insert(on_insert_fn);
map.insert({ "123", "456" }); // will call on_insert_fn after inserting
map.insert({ "786", "101112" }); // will call on_insert_fn after inserting
map.on_erase(on_erase_fn);
map.erase("123"); // will call on_erase_fn after erasing
system("pause");
return 0;
}

Answer 3

You absolutely don't want to have : public std::map in your class definition, because then there is no hope of keeping all of the ways of modifying the map contained.
What you will instead find is that you have one type for the client, containing the event handlers, and another type that wraps a map and delegates every action to it, plus calls the relevant handler function.
You won't be able to use this in lots of places where map would work, as to see modifications to values via iterators and operator[] you are forced to use a proxy for your reference member. Thus your iterator and const_iterator members don't satisfy ForwardIterator (and BidirectionalIterator). Thus you don't satisfy Container (and AssociativeContainer).
As an alternative to not being a Container, you could instead have a value_type of std::pair<const Key, const Value>, and simply require that modifications happen with an "erase-modify-insert" sequence.