c# - tiene - palabras reservadas en c++ y su significado pdf

C#nulo operador coalescente equivalente para c++

Question

¿Existe un equivalente de C ++ para el operador de unión nula de C #? Estoy haciendo demasiadas comprobaciones nulas en mi código. Así que estaba buscando una manera de reducir la cantidad de código nulo.

Answer 1

¿Qué tal esto?

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

Answer 2

Acabo de encontrar esto: El ?? operador también conocido como el operador de unión nula

También lo tiene en C / C ++ como una extensión de GNU utilizando el operador?:

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

Answer 3

No hay una manera de hacer esto por defecto en C ++, pero podría escribir una:

en C # el ?? operador se define como

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

Entonces, el método C ++ se vería como

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

Answer 4

Solo quiero expandir la respuesta de @Samuel Garcia generalizando la plantilla y agregando macros de ayuda para reducir la repetición de lambda:

#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 (

Usando las macros, puedes simplemente:

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

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

Espero que esto ayude.

Answer 5

Utilizando plantillas y lambdas C ++ 11. El primer argumento (lado izquierdo) solo se evalúa una vez. El segundo argumento (lado derecho) solo se evalúa si el primero es falso (tenga en cuenta que ''if'' y ''?'' Convierten de forma estática la expresión proporcionada en bool, y que los punteros tienen el ''operador explícito bool () const'' que es igual a ''! = nullptr'')

template<typename TValue, typename TSpareEvaluator>
TValue
coalesce(TValue mainValue, TSpareEvaluator evaluateSpare) {

    return mainValue ? mainValue : evaluateSpare();
}

Ejemplo de uso

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

std::cout << coalesce(nonZeroPtr, [&] () { std::cout << "Never called"; return otherNonZeroPtr; }) << "/n";

Solo imprimirá ''0xf'' en la consola. Tener que escribir un lambda para el rhs es un poco de repetitivo

[&] () { return <rhs>; }

pero es lo mejor que uno puede hacer si le falta el soporte de la sintaxis del lenguaje.