C ++ sélectionne le premier élément non nul

Question

[Mise à jour de la question en fonction des exigences mises à jour]
J'ai implémenté la fonction suivante qui devrait renvoyer soit le premier élément non null, soit une exception.
Aussi, pourriez-vous inventer des noms plus classiques et plus courts tels que "max", "min", "paire"?

template <typename T>
T select_first_not_empty( const T& a, const T&b )
{
    static T null = T();

    if ( a == null && b == null )
        throw std::runtime_error( "null" );

    return
        a != null ? a : b;
}

int main()
{
    const int a1 = 2;
    const int b1 = 0;

    const int* a2 = 0;
    const int* b2 = new int(5);

    const std::string a3 = "";
    const std::string b3 = "";

    std::cout << select_first_not_empty( a1, b1 ) << std::endl;
    std::cout << select_first_not_empty( a2, b2 ) << std::endl;
    std::cout << select_first_not_empty( a3, b3 ) << std::endl;

    return 0;
}

Answer 1

vous pouvez essayer de faire ensuite

template < typename T >
T get_valuable( const T& firstValue, 
                const T& alternateValue, 
                const T& zerroValue = T() )
{
    return firstValue != zerroValue ? firstValue : alternateValue;
}

// usage
char *str = "Something"; // sometimes can be NULL
std::string str2 ( get_valuable( str,  "" ) );

// your function
template <typename T>
T select_first_not_empty( const T& a, 
                          const T& b, 
                          const T& zerroValue = T() )
{
    const T result = get_valuable( a, b, zerroValue );
    if ( result == zerroValue )
    {
        throw std::runtime_error( "null" );
    }
    return result;
}

Answer 2

C # a un opérateur intégré fonctionnant de la même manière, ?? , qui s'appelle, je crois, coalesce.

L'opérateur || de Perl (OR logique par court-circuit) a également une fonctionnalité similaire: au lieu de renvoyer 0 ou 1, il renvoie la valeur du premier argument évalué à true:

0 || 7

renvoie 7, et non 1 ou true comme le programmeur C \ C ++ ou C # s'y attendrait.

La chose la plus proche que C ++ a intégrée est l'algorithme find_if:

vector<int> vec;
vec.push_back(0);
vec.push_back(0);
vec.push_back(7);

vector<int>::iterator first_non_0 = 
    find_if(vec.begin(), vec.end(), bind2nd(not_equal_to<int>(), 0));

Answer 3

Si l'acteur de T fait quelque chose de significatif, il semble que vous le fassiez trois fois à chaque fois via "select_first_not_empty".

Oracle appelle quelque chose de similaire "COALESCE" si vous cherchez un meilleur nom.

Je ne suis toutefois pas sûr de comprendre le problème. Si je voulais vraiment savoir si quelque chose était réglé ou non, j'utiliserais des pointeurs nullables plutôt que des références. " NULL " est un indicateur bien meilleur de l’intention de ne pas définir la variable que d’utiliser une valeur dans la bande telle que 0 ou ".".