Блог

Рассмотрим следующий код:

 #include<functional>
#include<iostream>
#include<map>

const std::map<int, std::string> numberToStr{{1, "one"}, {2,"two"}};
int main() {
    auto it = numberToStr.find(2);
    if (it ==numberToStr.end()){
        return 1;
    }
    const autoamp;[_, str] = *it;
    std::cout << str;
}
 

Есть ли у меня какой-нибудь способ развернуть потенциально разыменованные it до 2 опций (_ и str), чтобы я мог затем написать:

 const autoamp;[_, str] = // some magic;
// _ is std::optional<int>, str is std::optional<str>
if (!str){
    return 1;
}
std::cout << *str;
}
 

Я полагаю, что нет, поскольку структурированные привязки — это вещь на уровне языка, а std ::optional — это функция библиотеки, и afaik нет способа настроить взаимодействие.

Примечание: Я предполагаю, что мог бы реализовать свою собственную карту, которая возвращает итераторы, которые знают, указывают ли они на .end() , и «взломать» точки настройки, чтобы выполнять необязательную логику, основанную на этом, я прошу общий вариант использования, когда я не контролирую контейнер.

Вы могли бы добавить вспомогательную функцию, например

 template <typename Key, typename Value, typename... Rest>
std::pair<std::optional<Key>, std::optional<Value>> my_find(const std::map<Key, Value, Rest...>amp; map, const Keyamp; to_find)
{
    auto it = map.find(to_find);
    if (it == map.end())
        return {};
    else
        return {it->first, it->second};
}
 

и тогда вы бы использовали его как

 const autoamp;[_, str] = my_find(numberToStr, 2);
// _ is std::optional<int>, str is std::optional<str>
if (!str){
    return 1;
}
std::cout << *str;
 

Если вас интересует только значение, вы можете немного сократить код, просто вернув его вместо

 template <typename Key, typename Value, typename... Rest>
std::optional<Value> my_find(const std::map<Key, Value, Rest...>amp; map, const Keyamp; to_find)
{
    auto it = map.find(to_find);
    if (it == map.end())
        return {};
    else
        return {it->second};
}
 

и тогда вы бы использовали его как

 auto str = my_find(numberToStr, 2);
// str is std::optional<str>
if (!str){
    return 1;
}
std::cout << *str;
 

Более идиоматичным маршрутом C 20 было бы моделировать итератор как возможно пустой диапазон:

 auto const rng = std::apply(
    [](auto it, auto end) { return std::ranges::subrange(it, end); },
    numberToStr.equal_range(2));
if (rng.empty())
    return 1;
auto constamp; [_, str] = *rng.begin();
std::cout << str;
 

Пример.

Вы можете сделать это до C 20 с помощью Boost.Диапазоны, которые имеют более эргономичный iterator_range :

 auto const rng = boost::make_iterator_range(numberToStr.equal_range(2));
// ditto
 

Желаемый API имеет для меня мало смысла. Зачем вам возвращать две опции? Ключ либо находится на карте, либо нет, это единственное измерение необязательности — это не значит, что вы можете вернуть задействованный ключ, но отключенное значение или отключенный ключ, но задействованное значение.

API должен быть:

 template <typename Map, typename Key>
auto try_find(Mapamp;, Keyamp;amp;) -> optional<range_reference_t<Map>>;
 

Но на самом деле мы не можем написать это с помощью std::optional , потому что он не поддерживает необязательные ссылки. Возврат фактического optional<value_type> значения является расточительным (дополнительные копии) и, вероятно, семантически недопустимым (вы, вероятно, хотели это конкретное значение, а не просто значение).

Итак, первым шагом является получение лучшей реализации optional и ее использование. В этот момент реализация здесь очень проста:

 template <typename Map, typename Key>
auto try_find(Mapamp; m, Keyamp;amp; k) -> optional<range_reference_t<Map>>
{
    auto it = m.find(std::forward<Key>(k));
    if (it != m.end()) {
        return *it;
    } else {
        return nullopt;
    }
}
 

 template <typename Map, typename Key>
auto try_find(Mapamp; m, Key constamp; k) -> subrange<iterator_t<Map>>
{
    auto [f, l] = m.equal_range(key);
    return subrange(f, l);
}
 

 auto r = try_find(m, key);
if (r.empty()) {
    // nope
} else {
    // use r.front()
}