Logické logické operátory (Referenční dokumentace jazyka C#)Boolean logical operators (C# reference)

Následující operátory provádějí logické operace s logickými operandy:The following operators perform logical operations with bool operands:

Pro operandy integrálních číselných typů, & operátory, | a ^ provádějí bitové logické operace.For operands of the integral numeric types, the &, |, and ^ operators perform bitwise logical operations. Další informace naleznete v tématu operátory bitových a posunutí.For more information, see Bitwise and shift operators.

Logický operátor negace!Logical negation operator !

Unární operátor prefixu ! vypočítá logickou negaci svého operandu.The unary prefix ! operator computes logical negation of its operand. To znamená, že je true -li operand vyhodnocen false , a false , pokud je operand vyhodnocen jako true :That is, it produces true, if the operand evaluates to false, and false, if the operand evaluates to true:

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

Počínaje jazykem C# 8,0, unární příponový ! operátor je operátor null-striktní.Beginning with C# 8.0, the unary postfix ! operator is the null-forgiving operator.

Logický operátor AND&Logical AND operator &

&Operátor vypočítá logickou a jeho operandy.The & operator computes the logical AND of its operands. Výsledek je, x & y true Pokud je x a y vyhodnocen jako true .The result of x & y is true if both x and y evaluate to true. V opačném případě je výsledkem false .Otherwise, the result is false.

&Operátor vyhodnocuje oba operandy i v případě, že je levý operand vyhodnocen tak false , aby výsledek operace byl false bez ohledu na hodnotu operandu na pravé straně.The & operator evaluates both operands even if the left-hand operand evaluates to false, so that the operation result is false regardless of the value of the right-hand operand.

V následujícím příkladu je pravý operand & operátoru volání metody, která je provedena bez ohledu na hodnotu operandu na levé straně:In the following example, the right-hand operand of the & operator is a method call, which is performed regardless of the value of the left-hand operand:

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

Podmíněný logický operátor and && také VYPOČÍTÁ logickou a jeho operandy, ale nevyhodnotí pravý operand, pokud je levý operand vyhodnocen jako false .The conditional logical AND operator && also computes the logical AND of its operands, but doesn't evaluate the right-hand operand if the left-hand operand evaluates to false.

Pro operandy integrálních číselných typů & operátor vypočítá bitovou logickou a jeho operandy.For operands of the integral numeric types, the & operator computes the bitwise logical AND of its operands. Unární & operátor je operátor address-of.The unary & operator is the address-of operator.

Logický exkluzivní operátor OR ^Logical exclusive OR operator ^

^Operátor vypočítá logickou výlučnou nebo, označovanou také jako logická XOR, z operandů.The ^ operator computes the logical exclusive OR, also known as the logical XOR, of its operands. Výsledkem x ^ y je true , pokud je x vyhodnocena jako true a y false x false y true vyhodnocena jako nebo vyhodnocena jako a vyhodnocena jako.The result of x ^ y is true if x evaluates to true and y evaluates to false, or x evaluates to false and y evaluates to true. V opačném případě je výsledkem false .Otherwise, the result is false. To znamená, že pro bool operandy ^ vypočítá operátor stejný výsledek jako operátor nerovnosti != .That is, for the bool operands, the ^ operator computes the same result as the inequality operator !=.

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

Pro operandy integrálních číselných typů ^ operátor vypočítá BITOVÝ logický typ Exclusive nebo jeho operandů.For operands of the integral numeric types, the ^ operator computes the bitwise logical exclusive OR of its operands.

Logický operátor OR |Logical OR operator |

|Operátor vypočítá logický nebo jeho operandy.The | operator computes the logical OR of its operands. Výsledek je v x | y případě, že je true buď x nebo y vyhodnocen jako true .The result of x | y is true if either x or y evaluates to true. V opačném případě je výsledkem false .Otherwise, the result is false.

|Operátor vyhodnocuje oba operandy i v případě, že je levý operand vyhodnocen tak true , aby výsledek operace byl true bez ohledu na hodnotu operandu na pravé straně.The | operator evaluates both operands even if the left-hand operand evaluates to true, so that the operation result is true regardless of the value of the right-hand operand.

V následujícím příkladu je pravý operand | operátoru volání metody, která je provedena bez ohledu na hodnotu operandu na levé straně:In the following example, the right-hand operand of the | operator is a method call, which is performed regardless of the value of the left-hand operand:

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

Podmíněný logický operátor OR || také vypočítá logické nebo jeho operandy, ale nevyhodnotí operand pravého operandu, je-li operand na levé straně vyhodnocen true .The conditional logical OR operator || also computes the logical OR of its operands, but doesn't evaluate the right-hand operand if the left-hand operand evaluates to true.

Pro operandy integrálních číselných typů | operátor vypočítá bitovou logickou nebo jeho operandy.For operands of the integral numeric types, the | operator computes the bitwise logical OR of its operands.

Podmíněný logický operátor AND&&Conditional logical AND operator &&

Podmíněný logický operátor AND && , označovaný také jako "" krátkodobého okruhu ", je vypočítán logický operátor a jeho operandů.The conditional logical AND operator &&, also known as the "short-circuiting" logical AND operator, computes the logical AND of its operands. Výsledek je, x && y true Pokud je x a y vyhodnocen jako true .The result of x && y is true if both x and y evaluate to true. V opačném případě je výsledkem false .Otherwise, the result is false. Pokud se x vyhodnotí jako false , y nevyhodnotí se.If x evaluates to false, y is not evaluated.

V následujícím příkladu je pravý operand && operátoru volání metody, které není provedeno, je-li operand na levé straně vyhodnocen jako false :In the following example, the right-hand operand of the && operator is a method call, which isn't performed if the left-hand operand evaluates to 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

Logický operátor and & také VYPOČÍTÁ logickou a jeho operandy, ale vždy vyhodnotí oba operandy.The logical AND operator & also computes the logical AND of its operands, but always evaluates both operands.

Podmíněný logický operátor OR | |Conditional logical OR operator ||

Podmíněný logický operátor OR || , označovaný také jako "" krátkodobého "logického okruhu, vypočítá logické nebo jeho operandy.The conditional logical OR operator ||, also known as the "short-circuiting" logical OR operator, computes the logical OR of its operands. Výsledek je v x || y případě, že je true buď x nebo y vyhodnocen jako true .The result of x || y is true if either x or y evaluates to true. V opačném případě je výsledkem false .Otherwise, the result is false. Pokud se x vyhodnotí jako true , y nevyhodnotí se.If x evaluates to true, y is not evaluated.

V následujícím příkladu je pravý operand || operátoru volání metody, které není provedeno, je-li operand na levé straně vyhodnocen jako true :In the following example, the right-hand operand of the || operator is a method call, which isn't performed if the left-hand operand evaluates to 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

Logický operátor OR | také vypočítá logické nebo jeho operandy, ale vždy vyhodnotí oba operandy.The logical OR operator | also computes the logical OR of its operands, but always evaluates both operands.

Logické operátory s možnou hodnotou nullNullable Boolean logical operators

U bool? operandů operátory & (Logical a) a | (Logical a) podporují logiku se třemi hodnotami takto:For bool? operands, the & (logical AND) and | (logical OR) operators support the three-valued logic as follows:

  • &Operátor vytvoří true pouze v případě, že se na jeho operandy vyhodnotí true .The & operator produces true only if both its operands evaluate to true. Pokud je x nebo y vyhodnocena jako false , x & y vytvoří (i když se false jiný operand vyhodnocuje null ).If either x or y evaluates to false, x & y produces false (even if another operand evaluates to null). V opačném případě výsledek x & y je null .Otherwise, the result of x & y is null.

  • |Operátor vytvoří false pouze v případě, že se na jeho operandy vyhodnotí false .The | operator produces false only if both its operands evaluate to false. Pokud je x nebo y vyhodnocena jako true , x | y vytvoří (i když se true jiný operand vyhodnocuje null ).If either x or y evaluates to true, x | y produces true (even if another operand evaluates to null). V opačném případě výsledek x | y je null .Otherwise, the result of x | y is null.

Následující tabulka uvádí sémantiku:The following table presents that semantics:

xx yy x&yx&y x|yx|y
truetrue truetrue truetrue truetrue
truetrue false (nepravda)false false (nepravda)false truetrue
truetrue nullnull nullnull truetrue
false (nepravda)false truetrue false (nepravda)false truetrue
false (nepravda)false false (nepravda)false false (nepravda)false false (nepravda)false
false (nepravda)false nullnull false (nepravda)false nullnull
nullnull truetrue nullnull truetrue
nullnull false (nepravda)false false (nepravda)false nullnull
nullnull nullnull nullnull nullnull

Chování těchto operátorů se liší od typického chování operátoru s typy s možnou hodnotou null.The behavior of those operators differs from the typical operator behavior with nullable value types. Obvykle operátor, který je definován pro operandy typu hodnoty, lze také použít s operandy odpovídajícího typu hodnoty s možnou hodnotou null.Typically, an operator which is defined for operands of a value type can be also used with operands of the corresponding nullable value type. Takový operátor vytvoří, null Pokud se některý z jeho operandů vyhodnotí jako null .Such an operator produces null if any of its operands evaluates to null. Nicméně & | operátory a mohou vygenerovat jinou hodnotu než null, i když je jeden z operandů vyhodnocen jako null .However, the & and | operators can produce non-null even if one of the operands evaluates to null. Další informace o chování operátora s povolenými typy hodnot s možnou hodnotou null naleznete v části "předané operátory " v článku typy s možnou hodnotou null .For more information about the operator behavior with nullable value types, see the Lifted operators section of the Nullable value types article.

Operátory a lze také použít ! ^ s bool? operandy, jak ukazuje následující příklad:You can also use the ! and ^ operators with bool? operands, as the following example shows:

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

Podmíněné logické operátory && a || nepodporují bool? operandy.The conditional logical operators && and || don't support bool? operands.

Složené přiřazeníCompound assignment

Pro binární operátor op , výraz složeného přiřazení formulářeFor a binary operator op, a compound assignment expression of the form

x op= y

je ekvivalentemis equivalent to

x = x op y

s výjimkou, že x je vyhodnocena pouze jednou.except that x is only evaluated once.

&Operátory, | a ^ podporují složené přiřazení, jak ukazuje následující příklad:The &, |, and ^ operators support compound assignment, as the following example shows:

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

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

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

Poznámka

Podmíněné logické operátory && a || nepodporují složené přiřazení.The conditional logical operators && and || don't support compound assignment.

Priorita operátorůOperator precedence

Následující seznam uvádí logické operátory od nejvyšší priority k nejnižší:The following list orders logical operators starting from the highest precedence to the lowest:

  • Logický operátor negace!Logical negation operator !
  • Logický operátor AND&Logical AND operator &
  • Logický exkluzivní operátor OR^Logical exclusive OR operator ^
  • Logický operátor OR|Logical OR operator |
  • Podmíněný logický operátor AND&&Conditional logical AND operator &&
  • Podmíněný logický operátor OR||Conditional logical OR operator ||

Pomocí závorek () můžete změnit pořadí vyhodnocování stanovené předností operátorů:Use parentheses, (), to change the order of evaluation imposed by operator precedence:

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

Úplný seznam operátorů jazyka C# seřazených podle priority úrovně naleznete v části Priorita operátorů v článku operátory jazyka c# .For the complete list of C# operators ordered by precedence level, see the Operator precedence section of the C# operators article.

Přetížení operátoruOperator overloadability

Uživatelsky definovaný typ může přetížit ! & operátory,, a | ^ .A user-defined type can overload the !, &, |, and ^ operators. Při přetížení binárního operátoru je také implicitně přetížen odpovídající operátor složeného přiřazení.When a binary operator is overloaded, the corresponding compound assignment operator is also implicitly overloaded. Uživatelsky definovaný typ nemůže explicitně přetížit operátor složeného přiřazení.A user-defined type cannot explicitly overload a compound assignment operator.

Uživatelsky definovaný typ nemůže přetížit Podmíněné logické operátory && a || .A user-defined type cannot overload the conditional logical operators && and ||. Pokud však uživatelsky definovaný typ přetěžuje operátory true a false a & | operátor OR určitým způsobem, && || může být operace nebo v uvedeném pořadí vyhodnocena pro operandy daného typu.However, if a user-defined type overloads the true and false operators and the & or | operator in a certain way, the && or || operation, respectively, can be evaluated for the operands of that type. Další informace naleznete v části Podmíněné logické operátory definované uživatelem v tématu specifikace jazyka C#.For more information, see the User-defined conditional logical operators section of the C# language specification.

specifikace jazyka C#C# language specification

Další informace naleznete v následujících oddílech specifikace jazyka C#:For more information, see the following sections of the C# language specification:

Viz takéSee also