Compartilhar via

Operadores lógicos boolianos – AND, OR, NOT, XOR

Os operadores bolianos lógicos executam operações lógicas com operandos bool. Os operadores incluem a negação lógica unária (!), AND lógico binário (&), OR (|) e OR exclusivo (^) e os lógicos condicionais binários AND (&&) e OR (||).

Para os operandos dos tipos numéricos integrais, os operadores &, | e ^ executam operações lógicas bit a bit. Para obter mais informações, veja Operadores bit a bit e shift.

A linguagem C# faz referência a documentos da versão mais recentemente lançada da linguagem C#. Ele também contém a documentação inicial para funcionalidades em pré-visualizações públicas para o próximo lançamento do idioma.

A documentação identifica qualquer recurso introduzido pela primeira vez nas três últimas versões do idioma ou nas versões prévias públicas atuais.

Dica

Para descobrir quando um recurso foi introduzido pela primeira vez em C#, consulte o artigo sobre o histórico de versão da linguagem C#.

Operador de negação lógica !

O operador de prefixo ! unário calcula a negação lógica de seu operando. Ele produzirá true se o operando for avaliado falsecomo , e false se o operando for avaliado como true:

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

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

Operador AND lógico &

O operador & computa o AND lógico de seus operandos. O resultado de x & y será true se ambos x e y forem true. Caso contrário, o resultado será false.

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

No exemplo a seguir, o operando à direita do & operador é uma chamada de método, que é executada 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 && também calcula o AND lógico de seus operandos, mas não avalia o operando à direita se o operando à esquerda for false.

Para os operandos de tipos numéricos integrais, o operador & computa o AND lógico bit a bit de seus operandos. O operador & unário é o operador address-of.

Operador OR exclusivo lógico ^

O operador ^ computa o OR exclusivo lógico, também conhecido como o XOR lógico, de seus operandos. O resultado de x ^ y é true se x é true e y é false ou x é false e y é true. Caso contrário, o resultado será false. Para bool operandos, o ^ operador calcula o mesmo resultado que o operador !=.

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 os operandos de tipos numéricos integrais, o operador ^ computa o OR exclusivo lógico bit a bit de seus operandos.

Operador OR lógico |

O operador | computa o OR lógico de seus operandos. O resultado de x | y será true se x ou y for avaliado como true. Caso contrário, o resultado será 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 à direita. No entanto, mesmo assim, o operando à direita é avaliado.

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

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 || também calcula o OR lógico de seus operandos, mas não avalia o operando à direita se o operando esquerdo for avaliado como true.

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

Operador AND lógico condicional &&

O operador AND lógico condicional &&, também conhecido como operador AND lógico de "curto-circuito", computa o AND lógico de seus operandos. O resultado de x && y será true se ambos x e y forem avaliados como true. Caso contrário, o resultado será false. Se x for avaliado como false, y não será avaliado.

No exemplo a seguir, o operando à direita do operador && é uma chamada de método, que não é executada se o operando à esquerda 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 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", computa o OR lógico de seus operandos. O resultado de x || y será true se x ou y for avaliado como true. Caso contrário, o resultado será false. Se x for avaliado como true, y não será avaliado.

No exemplo a seguir, o operando à direita do operador || é uma chamada de método, que não é executada se o operando à esquerda 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 computa o OR lógico de seus operandos, mas sempre avalia os dois operandos.

Operadores lógicos booleanos anuláveis

Para bool? operandos, os & operadores (AND lógico) e | (OR lógico) dão suporte à lógica de três valores da seguinte maneira:

  • O & operador retornará true somente se ambos os operandos forem avaliados como true. Se for x ou y avaliado como false, x & y retornará false (mesmo que outro operando seja avaliado como null). Caso contrário, o resultado de x & y será null.

  • O operador | produz false somente se ambos os operandos forem avaliados como false. Se x ou y forem avaliados como true, x | y produzirá true (mesmo que outro operando seja avaliado como null). Caso contrário, o resultado de x | y será null.

A tabela a seguir apresenta essa semântica:

x a x e y x | Y
verdadeiro verdadeiro verdadeiro verdadeiro
verdadeiro falso falso verdadeiro
verdadeiro nulo nulo verdadeiro
falso verdadeiro falso verdadeiro
falso falso falso falso
falso nulo falso nulo
nulo verdadeiro nulo verdadeiro
nulo falso falso nulo
nulo nulo nulo nulo

O comportamento desses operadores difere do comportamento típico do operador com tipos de valores anuláveis. Normalmente, um operador 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 de seus operandos avaliar para null. No entanto, os operadores & e | podem produzir não nulos, mesmo se um dos operandos avaliar para null. Para obter mais informações sobre o comportamento do operador com tipos de valor nulos, confira a seção Operadores suspensos no artigo Tipos de valor anulável.

Você também pode usar os operadores ! e ^ com os operandos bool?, 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 oferecem suporte a operandos bool?.

Atribuição composta

Para um operador binário op, uma expressão de atribuição composta do formato

x op= y

É equivalente a

x = x op y

Exceto que x é avaliado apenas uma vez.

Os operadores &, | e ^ suportam a atribuição de compostos, conforme mostrado no 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

Observação

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

Precedência do operador

A lista a seguir ordena operadores lógicos em grupos que começam da precedência mais alta para a mais baixa:

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 de operador do artigo Operadores C# .

Capacidade de sobrecarga do operador

Os tipos definidos pelo usuário podem sobrecarregar os operadores !, &, | e ^. Quando um operador binário está sobrecarregado, o operador de atribuição composta 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 manter 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, veja a seção Operadores lógicos condicionais definidos pelo usuário na especificação da linguagem C#.

Especificação da linguagem C#

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

Confira também

  • Last updated on