只要引用不超过对象，存储对（可能）临时对象的引用是否合法？

Question

在阅读了std::variant和方便的overloaded技巧之后，我给自己设定了一个挑战（一个练习）来编写一个帮助我编写的帮助程序

visit(variant).with([](int){}, [](char){});

代替

std::visit(overloaded{[](int){}, [](char){}}, variant);

我也希望它在其他情况下工作，比如

VariantT variant;
VisitorT visitor;

visit(variant).with(visitor);
visit(VariantT{std::in_place_type<int>, 1}).with(visitor);

const VariantT constVariant;
visit(constVariant).with([](auto&&){});

你明白了。

这是我想出的（请注意，我已将名称从overloaded更改为Visitor ：

#include <iostream>
#include <string>
#include <utility>
#include <variant>

template <typename... T>
struct Visitor : public T...
{
    using T::operator()...;
};

template <typename... T>
Visitor(T...)->Visitor<T...>;

template <typename VariantT>
struct Helper
{
    Helper(VariantT& variant)
    : m_variant{variant}
    {}
    Helper(const Helper&) = delete;
    Helper(Helper&&) = delete;
    Helper& operator=(const Helper&) = delete;
    Helper& operator=(Helper&&) = delete;
    ~Helper() = default;

    template <typename VisitorT, typename... VisitorsT>
    decltype(auto) with(VisitorT&& visitor,
                        VisitorsT&&... visitors) && // this function is ref-qualified so we can only call this on a temp object and we can
                                                    // be sure that the variant lives at least as long as us
    {
        if constexpr (sizeof...(visitors) == 0)
        {
            return std::visit(std::forward<VisitorT>(visitor), m_variant);
        }
        else
        {
            return std::visit(Visitor{visitor, visitors...}, m_variant);
        }
    }

private:
    VariantT& m_variant;
};

template <typename VariantT>
decltype(auto) visit(VariantT&& variant)
{
    // no forwarding here, even if an rvalue was passed, pass an lvalue ref
    return Helper{variant};
}

int main()
{
    visit(std::variant<int>{std::in_place_type<int>, -7})
        .with([](int i) { std::cout << "got an int: " << i << std::endl; },
              [](std::string str) { std::cout << "got a string: " << str << std::endl; });

    std::variant<int, std::string> v = "String";

    visit(v).with([](int i) { std::cout << "got an int: " << i << std::endl; },
                  [](std::string str) { std::cout << "got a string: " << str << std::endl; });

    visit(v).with([](int& i) { i += 7; },
                  [](std::string& str) { str += "modified"; });

    std::cout << visit(v).with([](int i) { return std::to_string(i); },
                               [](std::string str) { return str; }) << std::endl;
}

问题是：在Helper存储引用是否完全合法？ 我的理解是临时对象一直存在到表达式结束，所以我想这可以吗？ 它会做正确的事吗？ 该代码中有任何陷阱吗？

我已经在 msvc 和 gcc 上测试了这段代码，我没有发现任何问题，但这并不意味着这在所有情况下都可以正常工作。

Answer 1

唯一明显的问题是你可以拥有像

decltype(auto) silly() {
    std::variant<int, std::string> v = "String";
    return visit(v);
}

int main()
{
    silly().with([](auto){ std::cout << "dangling" << std::endl; };
}

但是这样的事情在审查中相对容易发现。