Question C # conditionnel ET (&&) OR (||) précédence


Nous entrons dans des arguments de codage inutiles à mon travail tout le temps. Aujourd'hui, j'ai demandé si conditionnel AND (&&) ou OR (||) avait une priorité plus élevée. Un de mes collègues a insisté sur le fait qu'ils avaient la même priorité, j'avais des doutes, alors j'ai cherché.

Selon MSDN AND (&&) a une priorité supérieure à OR (||). Mais pouvez-vous le prouver à un collègue sceptique?

http://msdn.microsoft.com/en-us/library/aa691323(VS.71).aspx

bool result = false || true && false; // --> false
// is the same result as
bool result = (false || true) && false; // --> false
// even though I know that the first statement is evaluated as 
bool result = false || (true && false); // --> false

Donc, ma question est de savoir comment prouver avec un code que AND (&&) a une priorité plus élevée que OR (||)? Si votre réponse est que ce n'est pas grave, alors pourquoi est-ce construit de cette façon dans la langue?


62
2017-07-28 21:00


origine


Réponses:


Changez le premier faux par vrai. Je sais que cela semble stupide d'avoir (true || true) mais cela prouve votre point de vue.

bool result = true || true && false;   // --> true 
     result = (true || true) && false; // --> false
     result = true || (true && false); // --> true

92
2017-07-28 21:06



Si vous voulez vraiment lui faire peur, essayez:

bool result = True() | False() && False();

Console.WriteLine("-----");
Console.WriteLine(result);

static bool True()
{
    Console.WriteLine(true);
    return true;
}

static bool False()
{
    Console.WriteLine(false);
    return false;
}

Cela va imprimer:

True
False
False
-----
False

Modifier:

En réponse au commentaire:

En C #, | est un opérateur logique qui effectue la même logique booléenne que ||, mais ne court-circuite pas. Toujours en C #, le | l'opérateur a une priorité plus élevée que les deux || et &&.

En imprimant les valeurs, vous pouvez voir que si j'utilisais le type || opérateur, seul le premier True serait imprimé - suivi du résultat de l'expression qui aurait été True aussi.

Mais à cause de la plus haute priorité de |, la true | false est évalué en premier (résultant en true) et puis ce résultat est &&ed avec false produire false.

Je n'essayais pas de montrer l'ordre d'évaluation, juste le fait que la moitié droite de la | a été évalué période alors qu'il ne serait normalement pas :)


10
2017-07-28 21:35



Vous ne le prouvez pas avec du code mais avec de la logique. AND est une multiplication booléenne alors que OR est une addition booléenne. Maintenant, lequel a la plus haute priorité?


7
2017-07-28 21:08



Est-ce que cela ne vous donnerait pas ce que vous êtes après? Ou peut-être que je manque quelque chose ...

bool result = true || false && false;

4
2017-07-28 21:05



false || vrai vrai

Rendements: vrais

false && true || vrai

Rendements: vrais


0
2017-07-28 21:07



Vous ne pouvez pas simplement afficher le résultat final lorsque vos expressions booléennes sont court-circuitées. Voici un extrait qui règle votre cas.

Il repose sur la mise en œuvre de & et | opérateurs utilisés par && et ||, comme indiqué dans MSDN 7.11 Opérateurs logiques conditionnels

public static void Test()
{
    B t = new B(true);
    B f = new B(false);

    B result = f || t && f;

    Console.WriteLine("-----");
    Console.WriteLine(result);
}

public class B {
    bool val;
    public B(bool val) { this.val = val; }
    public static bool operator true(B b) { return b.val; }
    public static bool operator false(B b) { return !b.val; }
    public static B operator &(B lhs, B rhs) { 
        Console.WriteLine(lhs.ToString() + " & " + rhs.ToString());
        return new B(lhs.val & rhs.val); 
    }
    public static B operator |(B lhs, B rhs) { 
        Console.WriteLine(lhs.ToString() + " | " + rhs.ToString());
        return new B(lhs.val | rhs.val); 
    }
    public override string ToString() { 
        return val.ToString(); 
    }
}

La sortie doit montrer que && est évalué en premier avant ||.

True & False
False | False
-----
False

Pour plus de plaisir, essayez-le avec result = t || t && f et voir ce qui se passe avec les courts-circuits.


-3
2017-07-28 23:38