Partilhar via

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

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.

A referência da linguagem C# documenta a versão mais recentemente lançada da linguagem C#. Contém também documentação inicial para funcionalidades em versões preliminares públicas para a próxima versão da linguagem.

A documentação identifica qualquer funcionalidade introduzida pela primeira vez nas últimas três versões da língua ou em pré-visualizações públicas atuais.

Sugestão

Para saber quando uma funcionalidade foi introduzida pela primeira vez em C#, consulte o artigo sobre o histórico de versões da linguagem C#.

Operador de negação lógica!

O operador prefixo ! unário calcula a negação lógica do seu operando. Produz true se o operando avalia para false, e false se o operando avalia para 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 da x & y é true se tanto x como y forem true. Caso contrário, o resultado é false.

O & operador sempre avalia ambos os operandos. Quando o operando da mão esquerda é false, o resultado da operação é false independentemente do valor do operando da mão direita. No entanto, o operando da mão direita ainda é avaliado.

No exemplo seguinte, o operando direito do & operador é uma chamada de método, que corre independentemente do valor do operando à esquerda:

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 dos seus operandos, mas não avalia o operando da direita se o operando da esquerda for 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 da x ^ y é true se x é true e y é false, ou x é false e y é true. Caso contrário, o resultado é false. Para 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 xy 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 dos seus operandos, mas não avalia o operando da direita se o operando da esquerda avaliar para true.

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

Operador E lógico condicional &&

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& AND lógico também calcula o AND lógico dos seus operandos, mas avalia sempre 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 xy 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 (AND lógico) e | (OR lógico) suportam lógica de três valores da seguinte forma:

  • O & operador retorna true apenas se ambos os seus operandos avaliarem para true. Se ou xy avalia para false, x & y retorna 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 falso falso verdadeiro
verdadeiro null null verdadeiro
falso verdadeiro falso verdadeiro
falso falso falso falso
falso null falso null
null verdadeiro null verdadeiro
null falso falso null
null null null null

O comportamento desses operadores difere do comportamento típico do operador com tipos de valor anulável. Tipicamente, um operador definido para operandos de um tipo de valor também pode ser usado com operandos do tipo correspondente de valor nulo. 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 x só é avaliada 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. A partir do C# 14, um tipo definido pelo usuário pode sobrecarregar explicitamente os operadores de atribuição composta para fornecer uma implementação mais eficiente. Normalmente, um tipo sobrecarrega esses operadores porque o valor pode ser atualizado no local, em vez de alocar uma nova instância para armazenar o resultado da operação binária. Se um tipo não fornecer uma sobrecarga explícita, o compilador gerará a sobrecarga implícita.

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

  • Last updated on