我只是在看一些代码与下面的粗略大纲。

#include <iostream>

template<typename T, typename F>
decltype(auto) do_something(T&& object, F f) {
    return f(std::forward<T>(object));
}

struct object {
    int x;
    int& ref() { return x; }
    int const& ref() const { return x; } 
};

struct f {
template<typename T>
decltype(auto) operator()(T&& x) {
   return x.ref();
}
};

int main(int argc, char** argv) {

    auto & x = do_something(object{}, f{});

    return 0;
}

如果我这样打电话

auto& do_something(object{}, f{);

围绕这一点的一些问题是，如果f返回一个引用，并且f通过移动语义取得object的所有权，我们是否会遇到生存期问题？
通过decltype(auto)返回的潜在问题是什么？
还是这样更好

#include <iostream>
#include <type_traits>

struct object {
    int x{};
    
    int const& ref() const noexcept { return x; }
    int& ref() noexcept { return x; }
};

struct functor {
    
    template<typename T>
    decltype(auto) operator()(T&& arg) {
        return arg.ref();
    }
};

template<typename T, typename F>
decltype(auto) apply(T&& o, F f) {
    if constexpr(std::is_lvalue_reference_v<T>) {
        return f(std::forward<T>(o)); 
    }else {
        auto result = f(std::forward<T>(o));
        return result;
    }
}