Logické operátory logických hodnot (Referenční informace k jazyku C#)
Následující operátory provádějí logické operace s logickými operandy:
- Unární operátor (logická negace).
- Binární operátory (logické operátory AND), logické operátory OR a (logické výhradní operátory OR). Tyto operátory vždy vyhodnotí oba operandy.
- Binární (podmíněné logické operátory AND) a (podmíněné logické operátory OR). Tyto operátory vyhodnotí operand na pravé straně pouze v případě, že je to nezbytné.
Pro operandy integrálních číselných typů provádějí operátory , |
^
a bitové logické operace. Další informace najdete v tématu Bitové operátory a operátory posunutí.
Logický operátor negace !
Operátor unární předpony !
vypočítá logickou negaci svého operandu. To znamená, že vytvoří true
, pokud se operand vyhodnotí false
jako , false
a , pokud se operand vyhodnotí jako true
:
bool passed = false;
Console.WriteLine(!passed); // output: True
Console.WriteLine(!true); // output: False
Počínaje jazykem C# 8.0 je unární !
příponový operátor operátorem s nulou!
Logický operátor AND &
Operátor &
vypočítá logický operátor AND svých operandů. Výsledkem je , x & y
pokud jsou true
obě a x
vyhodnoceny y
jako true
. V opačném případě je výsledkem false
.
Operátor &
vyhodnotí oba operandy i v případě, že je levý operand false
vyhodnocen jako , false
takže výsledek operace je bez ohledu na hodnotu operandu pravé strany.
V následujícím příkladu je pravý operand &
operátoru volání metody, které se provádí bez ohledu na hodnotu levého operandu:
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á logický operátor AND svých operandů, ale nevyhodnotí pravý operand, pokud se levý operand vyhodnotí jako false
.
Pro operandy integrálních číselných typů vypočítá operátor bitový logický operátor AND svých operandů. Unární operátor &
je &
.
Logický exkluzivní operátor OR ^
Operátor ^
vypočítá logický exkluzivní operátor OR, označované také jako logický XOR, svých operandů. Výsledkem je , x ^ y
pokud true
se x
vyhodnotí true
y
false
jako a jako , x
nebo se vyhodnotí jako y
false
a vyhodnocuje jako true
. V opačném případě je výsledkem false
. To znamená, že bool
pro operandy operátor ^
vypočítá stejný výsledek jako bool
!=
.
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ů vypočítá operátor bitový logický exkluzivní operátor OR svých operandů.
Logický operátor OR |
Operátor |
vypočítá logický operátor OR svých operandů. Výsledkem je , x | y
pokud true
je nebo x
y
vyhodnoceno jako true
. V opačném případě je výsledkem false
.
Operátor |
vyhodnotí oba operandy i v případě, že je levý operand true
vyhodnocen jako , true
takže výsledek operace je bez ohledu na hodnotu operandu pravé strany.
V následujícím příkladu je pravý operand |
operátoru volání metody, které se provádí bez ohledu na hodnotu levého operandu:
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ý operátor OR svých operandů, ale nevyhodnotí pravý operand, pokud se levý operand vyhodnotí jako true
.
Pro operandy integrálních číselných typů vypočítá operátor bitový logický operátor OR svých operandů.
Podmíněný logický operátor AND &&
Podmíněný logický operátor &&
AND , označované také jako logický operátor AND s krátkým obvodem, vypočítá logický operátor AND jeho operandů. Výsledkem je , x && y
pokud jsou true
obě a x
vyhodnoceny y
jako true
. V opačném případě je výsledkem false
. Pokud x
se vyhodnotí false
jako , y
nevyhodnotí se.
V následujícím příkladu je pravý operand &&
operátoru volání metody, které není provedeno, pokud je levý operand vyhodnocen jako 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á logický operátor AND svých operandů, ale vždy vyhodnotí oba operandy.
Podmíněný logický operátor OR ||
Podmíněný logický operátor ||
OR , označované také jako logický operátor OR s krátkým obvodem, vypočítá logický operátor OR jeho operandů. Výsledkem je , x || y
pokud true
je nebo x
y
vyhodnoceno jako true
. V opačném případě je výsledkem false
. Pokud x
se vyhodnotí true
jako , y
nevyhodnotí se.
V následujícím příkladu je pravý operand ||
operátoru volání metody, které není provedeno, pokud je levý operand vyhodnocen jako 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ý operátor OR svých operandů, ale vždy vyhodnotí oba operandy.
Logické operátory s možnou hodnotou null
U bool?
operandů bool?
&
podporují logiku se třemi hodnotami následujícím způsobem:
Operátor
&
vytvoří pouze vtrue
případě, že jsou oba operandy vyhodnoceny jakotrue
. Pokud jex
neboy
vyhodnoceno jakofalse
,x & y
vytvořífalse
(i když se jiný operand vyhodnotí jakonull
). V opačném případě je výsledkemx & y
null
.Operátor
|
vytvoří pouze vfalse
případě, že jsou oba operandy vyhodnoceny jakofalse
. Pokud jex
neboy
vyhodnoceno jakotrue
,x | y
vytvořítrue
(i když se jiný operand vyhodnotí jakonull
). V opačném případě je výsledkemx | y
null
.
Následující tabulka uvádí sémantiku:
x | y | x&y | x|y |
---|---|---|---|
true | true | true | true |
true | false (nepravda) | false (nepravda) | true |
true | null | null | true |
false (nepravda) | true | false (nepravda) | true |
false (nepravda) | false (nepravda) | false (nepravda) | false (nepravda) |
false (nepravda) | null | false (nepravda) | null |
null | true | null | true |
null | false (nepravda) | false (nepravda) | null |
null | null | null | null |
Chování těchto operátorů se liší od typického chování operátoru s typy s možnou hodnotou null. 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. Takový operátor vytvoří null
, pokud se null
některý z jeho operandů vyhodnotí jako. &
Nicméně operátory a |
mohou vygenerovat jinou hodnotu než null, i když je jeden z operandů vyhodnocen null
jako. 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 .
Operátory a ^
lze také použít !
s bool?
operandy, jak ukazuje následující příklad:
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.
Složené přiřazení
Pro binární operátor op
, výraz složeného přiřazení formuláře
x op= y
je ekvivalentem
x = x op y
s výjimkou, že x
je vyhodnocena pouze jednou.
&
Operátory, |
a ^
podporují složené přiřazení, jak ukazuje následující příklad:
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í.
Priorita operátorů
Následující seznam uvádí logické operátory od nejvyšší priority k nejnižší:
- Logický operátor negace
!
- Logický operátor AND
&
- Logický exkluzivní operátor OR
^
- Logický operátor OR
|
- Podmíněný logický operátor AND
&&
- Podmíněný logický operátor OR
||
Pomocí závorek ()
můžete změnit pořadí vyhodnocování stanovené předností operátorů:
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# .
Přetížení operátoru
Uživatelsky definovaný typ může přetížit operátory, &
, |
^
a. 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í. Uživatelsky definovaný typ nemůže explicitně přetížit operátor složeného přiřazení.
Uživatelsky definovaný typ nemůže přetížit Podmíněné logické operátory &&
a ||
. 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. Další informace naleznete v části Podmíněné logické operátory definované uživatelem v tématu specifikace jazyka C#.
specifikace jazyka C#
Další informace naleznete v následujících oddílech specifikace jazyka C#: