C# null coalescing operator equivalent for c++

Question

Is there a C++ equivalent for C# null coalescing operator? I am doing too many null checks in my code. So was looking for a way to reduce the amount of null code.

Answer 1

I just found this: The ?? operator aka the Null Coalescing Operator

You also have it in C/C++ as a GNU extension using the ?: operator :

string pageTitle = getTitle() ?: "Default Title";

Answer 2

There isn't a way to do this by default in C++, but you could write one:

in C# the ?? operator is defined as

a ?? b === (a != null ? a : b)

So, the C++ method would look like

Coalesce(a, b) // put your own types in, or make a template
{
    return a != null ? a : b;
}

Answer 3

Using templates and C++11 lambdas:

template<typename TValue, typename TRhsEvaluator>
TValue coalesce(TValue lhsValue, TRhsEvaluator evaluateRhs) {
     return lhsValue ? lhsValue : evaluateRhs();
}

• The first argument (left-hand side) is only evaluated once.
• The second argument (right-hand side) is only evaluated if the first argument is false.

Note that if and ? statically cast the provided expression to bool, and that pointers have a built-in explicit operator bool() const operator which is equalivent to != nullptr

Example usage:

void * const      nonZeroPtr = reinterpret_cast<void *>(0xF);
void * const otherNonZeroPtr = reinterpret_cast<void *>(0xA);

std::cout << coalesce(nonZeroPtr, [&] () {
    std::cout << "Side-effect. Should never be printed" << std::endl;
    return otherNonZeroPtr;
}) << std::endl;

The code above will only print 0xf to the console.

The right-hand side needs to be wrapped inside a lambda - we cannot avoid that boilerplate. Really the language should provide a null coalescing operator out of the box.

Answer 4

Just want to expand @Samuel Garcia's answer by generalising the template and adding helper macros to cut down on lambda boilerplate:

#include <utility>

namespace coalesce_impl
{
    template<typename LHS, typename RHS>
    auto coalesce(LHS lhs, RHS rhs) ->
        typename std::remove_reference<decltype(lhs())>::type&&
    {
        auto&& initialValue = lhs();
        if (initialValue)
            return std::move(initialValue);
        else
            return std::move(rhs());
    }

    template<typename LHS, typename RHS, typename ...RHSs>
    auto coalesce(LHS lhs, RHS rhs, RHSs ...rhss) ->
        typename std::remove_reference<decltype(lhs())>::type&&
    {
        auto&& initialValue = lhs();
        if (initialValue)
            return std::move(initialValue);
        else
            return std::move(coalesce(rhs, rhss...));
    }
}

#define COALESCE(x) (::coalesce_impl::coalesce([&](){ return ( x ); }))
#define OR_ELSE     ); }, [&](){ return (

Using the macros, you can just:

int* f();
int* g();
int* h();

int* x = COALESCE( f() OR_ELSE g() OR_ELSE h() );

I hope this helps.

Answer 5

Here are two macros to replicate the ?? and ?. operators. These macros ensure:

• Arguments are evaluated only once.
• The second param is only evaluated if the first param is null.
• Macro variables are internally scoped using compile-time-removed lambda syntax. This avoids macro variable collisions.

Example usage:

    COA( nullPtr, goodPtr )->sayHello();
    COA( nullPtr, COA( nullPtr, goodPtr ) )->sayHello();

    COACALL( goodPtr, sayHello() );
    COACALL( nullPtr, sayHello() );

    COACALL( COA( nullPtr, goodPtr ), sayHello() );

Definitions:

    #define COA(a, b) ([&](){ auto val = (a); return ((val) == NULL ? (b) : (val)); }())
    #define COACALL(a, b) ([&](){ auto val = (a); if (val) (val->b); }());

Note: COACALL does not return results. Only use with void calls or alter to fit your needs.

Answer 6

How about this?

#define IFNULL(a,b) ((a) == null ? (b) : (a))

Answer 7

There is a GNU GCC extension that allows using ?: operator with middle operand missing, see Conditionals with Omitted Operands.

The middle operand in a conditional expression may be omitted. Then if the first operand is nonzero, its value is the value of the conditional expression.

Therefore, the expression

x ? : y

has the value of x if that is nonzero; otherwise, the value of y.

This example is perfectly equivalent to

x ? x : y

In this simple case, the ability to omit the middle operand is not especially useful. When it becomes useful is when the first operand does, or may (if it is a macro argument), contain a side effect. Then repeating the operand in the middle would perform the side effect twice. Omitting the middle operand uses the value already computed without the undesirable effects of recomputing it.

This extension is also supported by clang. However, you should check with the compiler you're using and portability requirements for your code before using the extension. Notably, MSVC C++ compilers do not support omitted operands in ?:.

See also related StackOverflow discussion here.

Answer 8

Just to add to the answers mentioning the ?: operator (the "Elvis operator"): I sometimes use a helper function together with this operator that gets the underlying value of a pointer or std::optional or similar types that "wrap" a value and have a boolean conversion to indicate the presence of a value. For example:

template <typename T>
constexpr T coalesce (std::optional<T> opt) {
    return *opt;
}
template <typename T>
constexpr T coalesce (T fallback) {
    return fallback;
}

std::optional<int> opt1{5};
std::optional<int> opt2;
int val1 = coalesce(opt1 ?: 0);
int val2 = coalesce(opt2 ?: 0);

The only drawback is that this must be used carefully and won't give you a static check of correct use. E.g. you could just do coalesce(opt2) without the ?: fallback and that would be the same as doing *opt2 without first checking whether it contains anything. So the name coalesce is sort of misleading, but when used correctly it looks self-explanatory (and pretty neat) in my opinion.

Answer 9

Reminder: C# coalesce semantics

The semantics of ??, the coalescing operator of C#, are:

p ?? q

Here, p is the left and q is the right operand of [the] ?? operator. The value of p can be nullable type, but the value of q must be non-nullable type. If the value of p is null, then it returns the value of q. Otherwise, it will return the value of p.

A C++ implementation

We first note that C++ cannot use ?? as an identifier; nor is the preprocessor willing to let us define a macro with this name. So, lets use coalesce as the identifier instead.

We need to define coalesce somehow as an infix operator with the requested semantics. This is doable with a combination of operator overloading and a macro for tying things together, so that we can write:

int* p = // whatever
int* q = // whatever
int* result = p coalesce q;

Here's an implementation:

#include <functional>

namespace detail {

struct coalesce_op {};

template <typename T>
struct coalesce_op_primed { 
    T&& lhs; 

    constexpr T&& operator+(T&& rhs) {
        return (lhs == nullptr) ? rhs : lhs;
    }
};

template <typename T>
constexpr coalesce_op_primed<T> operator+(T&& t, coalesce_op)
{
    return coalesce_op_primed<T>{std::forward<T>(t)};
}

} // namespace detail

#define coalesce + detail::coalesce_op{} +

See it in action on GodBolt.

Notes:

• There isn't any short-circuit logic, i.e. q is evaluated even if it isn't used. One could write a macro with short-circuit logic, but it wouldn't be an infix operator.
• We cannot use the GNU C extensions' ?: Elvis-operator, as its semantics are different. It will consider a non-null false value as reason to choose the RHS operand, i.e. false ?: 123 will yield 123, while false ?? 123 is false using the C# coalesce semantics.
• I did not try to make this work for std::optional's, detecting nullopt. If that is required, it should also be possible with some if-constexpr or tagged-dispatch TMP.