unario - C#condicional AND(&&) OR(||) precedencia

operador unario c#

Question

Nos metemos en argumentos de codificación innecesarios en mi trabajo todo el tiempo. Hoy pregunté si el condicional Y (&&) o O (||) tenía mayor prioridad. Uno de mis compañeros de trabajo insistió en que tenían la misma prioridad, yo tenía dudas, así que lo busqué.

De acuerdo con MSDN AND (&&) tiene una precedencia mayor que OR (||). Pero, ¿puedes demostrarlo a un compañero de trabajo escéptico?

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

Entonces mi pregunta es ¿cómo se demuestra con el código que AND (&&) tiene una precedencia mayor que OR (||)? Si tu respuesta es que no importa, ¿por qué está construida de esa manera en el idioma?

Answer 1

¿Esto no te daría lo que buscas? O tal vez me estoy perdiendo algo ...

bool result = true || false && false;

Answer 2

Cambiar el primer falso por verdadero Sé que parece estúpido tenerlo (cierto || cierto) pero prueba tu punto.

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

Answer 3

No lo demuestras con código sino con lógica. Y es una multiplicación booleana, mientras que O es una adición booleana. Ahora, ¿cuál tiene mayor precedencia?

Answer 4

No puede mostrar el resultado final cuando sus expresiones booleanas están en cortocircuito. Aquí hay un fragmento que resuelve su caso.

Se basa en la implementación de & y | operadores utilizados por && y ||, como se indica en MSDN 7.11 Operadores lógicos condicionales

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(); 
    }
}

El resultado debe mostrar que && se evalúa primero antes ||.

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

Para mayor diversión, pruébalo con result = t || t && f y vea qué pasa con el cortocircuito.

Answer 5

Si realmente quieres asustarlo, intenta:

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;
}

Esto se imprimirá:

True
False
False
-----
False

Editar:

En respuesta al comentario:

En C #, | es un operador lógico que realiza la misma lógica booleana que || , pero no cortocircuita. También en C #, el | el operador tiene una precedencia mayor que ambos || y && .

Al imprimir los valores, puede ver que si usé el típico || operador, solo se imprimirá el primer True , seguido del resultado de la expresión que también sería True .

Pero debido a la mayor precedencia de | , el true | false true | false se evalúa primero (dando como resultado true ) y luego ese resultado es && ed con false para dar false .

No estaba tratando de mostrar el orden de la evaluación, solo el hecho de que la mitad derecha del | Se evaluó el período cuando normalmente no sería :)

Answer 6

falso || verdad verdad

Rendimientos: verdadero

falso && verdadero || cierto

Rendimientos: verdadero