is `return_if_null(T* ptr)` possible? - c++

Question

I'm finding myself doing a lot of
void doSomethingCool(CoolObject* coolObject) {
if (coolObject == nullptr) {
return;
}
// now _actually_ do something cool
}
I thought about macros, but it felt a bit gross...
// plus some other templating for other return types, but besides the point
#define RETURN_IF_NULL(nullable) if (nullable == null) { return; }
void doSomethingCool(CoolObject* coolObject) {
RETURN_IF_NULL(coolObject)
// now _actually_ do something cool
}
It would be cool to have something like std::return_if_null<T>, like this
#include <early_return>
void doSomethingCool(CoolObject* coolObject) {
std::return_if_null(coolObject);
// now _actually_ do something cool
}
I don't think this is possible with C++ as it is now, but would be keen to hear if you think this could work, or if you think it would be an interesting language feature.
Edit, full context, what I would looove to see is something like this.
template <typename T, typename ReturnType>
std::early_return<ReturnType> return_if_null(T* ptr, ReturnType defaultValue = {}) {
static_assert(std::is_default_constructible<T>());
if (ptr == nullptr) {
return std::early_return::abort{defaultValue};
}
return std::early_return::continue;
}

Answer 1

is return_if_null(T* ptr) possible?
No.
I thought about macro
Ok, that is possible. But don't.
It's somewhat unclear why you want this, but if you're exploring different styles, you can write the function like this:
void doSomethingCool(CoolObject* coolObject) {
if (coolObject) {
// now _actually_ do something cool
}
}
But it's of course a matter of taste.

Answer 2

Well, this probably isn't what you are looking for, but coroutines are malleable enough to largely mimic this.
First we define a wrapper type for pointers that you want a null-check for:
template<class T>
struct return_if_null {
return_if_null(T ptr) : ptr(ptr) {}
T ptr;
operator T() const { return ptr; }
};
And a way to identify that wrapper:
template<class T>
constexpr bool is_return_if_null = false;
template<class T>
constexpr bool is_return_if_null<return_if_null<T>> = true;
Next we specialize coroutine_traits for coroutines that return void and has at least one return_if_null parameter:
template<class...Ts>
requires (is_return_if_null<std::remove_cvref_t<Ts>> || ...)
struct std::coroutine_traits<void, Ts...> {
struct promise_type {
/* ... */
bool return_early;
};
};
And then we use the parameter preview to fill return_early in the promise type constructor:
template<class T>
bool is_null_return_if_null(T& t){
if constexpr (is_return_if_null<std::remove_cv_t<T>>){
return t.ptr == nullptr;
}
else {
return false;
}
}
template<class... Us>
promise_type(Us&&... args) {
return_early = (is_null_return_if_null(args) || ...);
}
Now initial_suspend: if we need to return early, we suspend the coroutine, destroy the coroutine frame, and return to the caller. Otherwise, we let the coroutine continue execution:
auto initial_suspend() {
struct A {
void await_resume() {}
bool await_ready() {
return not return_early;
}
void await_suspend(std::coroutine_handle<> h) {
h.destroy();
}
bool return_early;
};
return A{return_early};
}
The remaining coroutine boilerplate:
std::suspend_never final_suspend() noexcept { return {}; }
void unhandled_exception() { throw; }
void await_transform() = delete; // don't allow co_await
void return_void(){}
And now to use it:
void f(return_if_null<int*> ptr) {
// won't get here if ptr is null
std::cout << "function body here\n";
co_return;
}
(You do need at least one co_return in the body to make it an actual coroutine.)
Demo.
It is also possible to make co_await return_if_null(ptr); work (instead of having everything magically happen at the initial suspension point), but you'll still need some kind of hook in the signature so that you can provide a special promise type.