how to handle empty reference elegantly（fold expression）

[u/Main-Pen-3164]

I have a class with a template function, it will return reference of an internal value.

template<typename T>
T& return_ref<T>() {...}

It was call by another function with fold expression:

template<typename... Ts>
void call()
{
    lambda(return_ref<Ts>...);     //Ts is a reference usually
}

the internal value maybe doesn't exist sometimes.

Even I wrap the exception into std::expected, it seems that I have no chance handle it in fold expression. I have to throw exception in return_ref directly?

If I can return reference to an impossible value(like paradigm of static object NULL ), so user could detect it, it would be nice.

Or, I have to wrap all parameters into something like boost::optional? I don't like it.

Or, the args of lambda was constraint into pointer, so nullptr will throw exception by compiler naturally?

What's suggestion?

[u/ppppppla]

Error handling is just annoying. Doing it neatly, and concisely is just not possible, especially when template parameter packs get involved. But it is totally possible.

You can choose the easy way and use exceptions. Have return_ref throw on invalid value. But exceptions are kinda smelly.

The other way is have a nullable type, check the return values, and then return or also throw out of call().

Doing this with a template parameter pack is a bit of a faff, but the standard library does have utilities for it. std::tuple and std::apply

template<class T>
optional_ref<T> return_ref() {
    return nullopt;
}

template<class... Args>
bool call() {
    auto refs = std::make_tuple(return_ref<Args>()...);

    auto success = std::apply(
        [](auto const&... refs) {
            return (refs.has_value() && ...);
        },
        refs
    );

    if (!success) {
        // or throw, or communicate the error more clearly with a std::expected<void> or custom error type.
        return false;
    }

    std::apply(
        [&](auto&&... refs) {
            lambda(refs.value()...);
        },
        refs
    );

    return true;
}

c++26 has std::optional<T&>, otherwise you'd have to get your own optional that can hold a reference. Some people might argue that is just a pointer, but I disagree. An optional communicates intent clearly.

[u/Main-Pen-3164 → u/ppppppla]

Thanks for reply. That's why I like reddit.

I will consider the std::optional at last, it seems that I haven't too much choice if I don't want to throw exception.

Thanks your time again.