How can I safe get a value from STL map or unordered_map?

How can I safe get the value by key from STL map or unordered_map?
The obvious answer is

const auto it = map.find(key);
if (it != std::end(map))
{ 
  myValue = get<1>(*it);
}
else
{
  // no key case ...
}

By this code is used so often, why does not STL contain helper methods something similar to TryGetValue from C# ? STL already contains a lot of helpers, e.g. std::get<>(), std::make_...<>(), std::begin\end() and so on. So std::try_get() would follow this logic.

Something similar to:

namespace std
{
    template<class Key, class T, class Hash = hash<Key>, class KeyEqual = equal_to<Key>, class Allocator = allocator< pair<const Key, T>>>
    bool try_get(const unordered_map<Key, T, Hash, KeyEqual, Allocator>& map, const Key& key, T* value)
    {
        const auto it = map.find(key);
        const bool res = it != end(map);
        if (res && value != nullptr)
        {
            *value = get<1>(*it);
        }

        return res;
    }

    template<class Key, class T, class Compare = less<Key>, class Allocator = allocator<pair<const Key, T>>>
    bool try_get(const map<Key, T, Compare, Allocator>& map, const Key& key, T* value)
    {
        const auto it = map.find(key);
        const bool res = it != end(map);
        if (res && value != nullptr)
        {
            *value = get<1>(*it);
        }

        return res;
    }
}

Examples:
This method would be helpful in case when you have a map of predefined values but default value is also suits you:

std::map<TKey, TValue> settings = /* deserialization */;

...

TValue myValue = /* default value */ ;
std::try_get(settings, key, &myValue);

// use myValue in following code, 
// it contains ether default or predefined value from settings

Another example, you have several caches with initialized objects and you need to use any of them that correspond key or fallback to default implementation when caches do not contain key associated object.

std::map<TKey, TObjKeeper> generalDependecyObjects = /* initialization */;
std::map<TKey, TObjKeeper> specificDependecyObjects = /* initialization */;

TObjKeeper obj;
if (!std::try_get(generalDependecyObjects, objectId, &obj) &&
    !std::try_get(specificDependecyObjects, objectId, &obj))
{
  obj = /*fallback to default implementation*/;
}

First, your try_get does not handle the else, so you would still have to write an if-else, not to check the iterator returned from find but to check the bool returned from try_get.

Moreover you need to consider that there is a conditional init-statment allowed in if statements. Hence you rather need to compare against:

if (auto it = map.find(key); it!=std::end(map))
{ 
  myValue = get<1>(*it);
}
else
{
  // no key case ...
}

And now I am not sure anymore if you can convince others that the following would be so much better:

DataType value;  // must be default constructible!
if (try_get(map,&value))
{ 
  myValue = get<1>(value);
}
else
{
  // no key case ...
}