Operadores lógicos booleanos - E, OU, NÃO, XOR

  • Artigo

Os operadores booleanos lógicos executam operações lógicas com operandos bool . Os operadores incluem a negação lógica unária (!), lógica binária AND (&), OR (|), e exclusiva OR (^), e a lógica condicional binária AND (&&) e OR (||).

Para operandos dos tipos numéricos integrais, os &operadores , |e ^ executam operações lógicas bitwise. Para obter mais informações, consulte Bitwise e operadores de turno.

Operador de negação lógica!

O operador de prefixo ! unário calcula a negação lógica de seu operando. Ou seja, produz true, se o operando avalia a false, e false, se o operando avalia a true:

bool passed = false;
Console.WriteLine(!passed);  // output: True
Console.WriteLine(!true);    // output: False

O operador postfix ! unário é o operador de perdão nulo.

Operador lógico AND &

O & operador calcula o E lógico de seus operandos. O resultado de x & y é true se ambos x e y avaliar a true. Caso contrário, o resultado é false.

O & operador sempre avalia ambos os operandos. Quando o operando esquerdo é avaliado como false, o resultado da operação é false independentemente do valor do operando direito. No entanto, mesmo assim, o operando direito é avaliado.

No exemplo a seguir, o operando direito do & operador é uma chamada de método, que é executada independentemente do valor do operando esquerdo:

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = false & SecondOperand();
Console.WriteLine(a);
// Output:
// Second operand is evaluated.
// False

bool b = true & SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

O operador&& AND lógico condicional também calcula o AND lógico de seus operandos, mas não avalia o operando direito se o operando esquerdo for avaliado como false.

Para operandos dos tipos numéricos integrais, o operador calcula & a lógica bit a bit E de seus operandos. O operador unário & é o endereço do operador.

Operador OR exclusivo lógico ^

O ^ operador calcula o OR lógico exclusivo, também conhecido como XOR lógico, de seus operandos. O resultado de x ^ y é true se x avalia e ytrue avalia para false, ou x avalia para false e y avalia para true. Caso contrário, o resultado é false. Ou seja, para os bool operandos, o operador calcula ^ o mesmo resultado que o operador!= de desigualdade.

Console.WriteLine(true ^ true);    // output: False
Console.WriteLine(true ^ false);   // output: True
Console.WriteLine(false ^ true);   // output: True
Console.WriteLine(false ^ false);  // output: False

Para operandos dos tipos numéricos integrais, o operador calcula ^ o OR lógico exclusivo bit a bit de seus operandos.

Operador lógico OR |

O | operador calcula o OR lógico de seus operandos. O resultado de x | y é true se um ou yx avalia a true. Caso contrário, o resultado é false.

O | operador sempre avalia ambos os operandos. Quando o operando esquerdo é avaliado como true, o resultado da operação é true independentemente do valor do operando direito. No entanto, mesmo assim, o operando direito é avaliado.

No exemplo a seguir, o operando direito do | operador é uma chamada de método, que é executada independentemente do valor do operando esquerdo:

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = true | SecondOperand();
Console.WriteLine(a);
// Output:
// Second operand is evaluated.
// True

bool b = false | SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

O operador|| OR lógico condicional também calcula o OR lógico de seus operandos, mas não avalia o operando direito se o operando esquerdo for avaliado como true.

Para operandos dos tipos numéricos integrais, o operador calcula | o OR lógico bit a bit de seus operandos.

Operador lógico condicional AND &&

O operador &&lógico condicional AND , também conhecido como operador lógico AND de "curto-circuito", calcula o E lógico de seus operandos. O resultado de x && y é true se ambos x e y avaliar a true. Caso contrário, o resultado é false. Se x avalia para false, y não é avaliado.

No exemplo a seguir, o operando direito do operador é uma chamada de && método, que não é executada se o operando esquerdo for avaliado como false:

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = false && SecondOperand();
Console.WriteLine(a);
// Output:
// False

bool b = true && SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

O operador lógico AND também calcula o AND& lógico de seus operandos, mas sempre avalia ambos os operandos.

Operador OR lógico condicional ||

O operador ||OR lógico condicional, também conhecido como operador OR lógico de "curto-circuito", calcula o OR lógico de seus operandos. O resultado de x || y é true se um ou yx avalia a true. Caso contrário, o resultado é false. Se x avalia para true, y não é avaliado.

No exemplo a seguir, o operando direito do operador é uma chamada de || método, que não é executada se o operando esquerdo for avaliado como true:

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = true || SecondOperand();
Console.WriteLine(a);
// Output:
// True

bool b = false || SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

O operador| OR lógico também calcula o OR lógico de seus operandos, mas sempre avalia ambos os operandos.

Operadores lógicos booleanos anuláveis

Para bool? operandos, os & operadores (lógico E) e | (lógico OR) suportam a lógica de três valores da seguinte maneira:

  • O & operador produz true somente se ambos os seus operandos avaliarem a true. Se um ou xy avalia para false, x & y produz false (mesmo que outro operando avalie para null). Caso contrário, o resultado de x & y é null.

  • O | operador produz false somente se ambos os seus operandos avaliarem a false. Se um ou xy avalia para true, x | y produz true (mesmo que outro operando avalie para null). Caso contrário, o resultado de x | y é null.

A tabela a seguir apresenta essa semântica:

x S x&y x|y
verdadeiro verdadeiro verdadeiro verdadeiro
verdadeiro false false verdadeiro
verdadeiro nulo nulo verdadeiro
false verdadeiro false verdadeiro
false false false false
false nulo false nulo
nulo verdadeiro nulo verdadeiro
nulo false false nulo
nulo nulo nulo nulo

O comportamento desses operadores difere do comportamento típico do operador com tipos de valor anulável. Normalmente, um operador que é definido para operandos de um tipo de valor também pode ser usado com operandos do tipo de valor anulável correspondente. Esse operador produz null se algum dos seus operandos for avaliado como null. No entanto, os & operadores e | podem produzir não-nulo mesmo se um dos operandos for avaliado como null. Para obter mais informações sobre o comportamento do operador com tipos de valor anuláveis, consulte a seção Operadores suspensos do artigo Tipos de valor anuláveis.

Você também pode usar os ! operadores e ^ com bool? operandos, como mostra o exemplo a seguir:

bool? test = null;
Display(!test);         // output: null
Display(test ^ false);  // output: null
Display(test ^ null);   // output: null
Display(true ^ null);   // output: null

void Display(bool? b) => Console.WriteLine(b is null ? "null" : b.Value.ToString());

Os operadores && lógicos condicionais e || não suportam bool? operandos.

Atribuição composta

Para um operador opbinário , uma expressão de atribuição composta do formulário

x op= y

é equivalente a

x = x op y

só que só é x avaliado uma vez.

Os &operadores , |e ^ suportam atribuição composta, como mostra o exemplo a seguir:

bool test = true;
test &= false;
Console.WriteLine(test);  // output: False

test |= true;
Console.WriteLine(test);  // output: True

test ^= false;
Console.WriteLine(test);  // output: True

Nota

Os operadores && lógicos condicionais e || não suportam atribuição composta.

Precedência dos operadores

A lista a seguir ordena os operadores lógicos a partir da maior precedência para a mais baixa:

  • Operador de negação lógica !
  • Operador lógico E &
  • Operador lógico exclusivo das RUP ^
  • Operador lógico OR |
  • Operador E lógico condicional &&
  • Operador OR lógico condicional ||

Use parênteses, (), para alterar a ordem de avaliação imposta pela precedência do operador:

Console.WriteLine(true | true & false);   // output: True
Console.WriteLine((true | true) & false); // output: False

bool Operand(string name, bool value)
{
    Console.WriteLine($"Operand {name} is evaluated.");
    return value;
}

var byDefaultPrecedence = Operand("A", true) || Operand("B", true) && Operand("C", false);
Console.WriteLine(byDefaultPrecedence);
// Output:
// Operand A is evaluated.
// True

var changedOrder = (Operand("A", true) || Operand("B", true)) && Operand("C", false);
Console.WriteLine(changedOrder);
// Output:
// Operand A is evaluated.
// Operand C is evaluated.
// False

Para obter a lista completa de operadores C# ordenados por nível de precedência, consulte a seção Precedência do operador do artigo Operadores C#.

Capacidade de sobrecarga do operador

Um tipo definido pelo usuário pode sobrecarregar os !operadores , &, |e ^ . Quando um operador binário está sobrecarregado, o operador de atribuição composto correspondente também é implicitamente sobrecarregado. Um tipo definido pelo usuário não pode sobrecarregar explicitamente um operador de atribuição composta.

Um tipo definido pelo usuário não pode sobrecarregar os operadores && lógicos condicionais e ||. No entanto, se um tipo definido pelo usuário sobrecarregar os operadores true e false e o & operador ou de | uma determinada maneira, a && operação ou || , respectivamente, pode ser avaliada para os operandos desse tipo. Para obter mais informações, consulte a seção Operadores lógicos condicionais definidos pelo usuário da especificação da linguagem C#.

Especificação da linguagem C#

Para obter mais informações, consulte as seguintes seções da especificação da linguagem C#:

Consulte também