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í falsejako , falsea , 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 falsevyhodnocen 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í trueyfalsejako a jako , x nebo se vyhodnotí jako yfalse 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 xy 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 truevyhodnocen 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í falsejako , 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 xy vyhodnoceno jako true. V opačném případě je výsledkem false. Pokud x se vyhodnotí truejako , 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 v true případě, že jsou oba operandy vyhodnoceny jako true. Pokud je x nebo y vyhodnoceno jako false, x & y vytvoří false (i když se jiný operand vyhodnotí jako null). V opačném případě je výsledkem x & ynull.

  • Operátor | vytvoří pouze v false případě, že jsou oba operandy vyhodnoceny jako false. Pokud je x nebo y vyhodnoceno jako true, x | y vytvoří true (i když se jiný operand vyhodnotí jako null). V opačném případě je výsledkem x | ynull.

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#:

Viz také