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.