Logické operátory – AND, OR, NOT, XOR

Logické logické operátory provádějí logické operace s logickými operandy. Operátory zahrnují unární logickou negaci (!), binární logickou and (), OR (&|) a výhradní OPERÁTOR (^) a binární podmíněnou logickou funkci AND (&&) a OR (||).

• Unární ! operátor (logický negace).
• Binární & operátory (logické AND),|(logické OR) a ^ (logické exkluzivní OPERÁTORY OR). Tyto operátory vždy vyhodnotí oba operandy.
• Binární && operátory (podmíněné logické operátory AND) a || (podmíněné logické OPERÁTORY OR). Tyto operátory vyhodnocují pravý operand pouze v případě, že je to nutné.

Pro operandy integrálních číselných typů& provádějí bitové logické operace operátory , |a ^ operátory. Další informace naleznete v tématu Bitové operátory a operátory shift.

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í jako false, a false, pokud se operand vyhodnotí jako true:

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

Unární operátor přípony !je operátor null-forgiving.

Logický operátor AND &

Operátor & vypočítá logický operátor AND jeho operandů. Výsledkem x & y je, zda je true obojí x a y vyhodnoceno jako true. V opačném případě je falsevýsledek .

Operátor & vždy vyhodnotí oba operandy. Když se operand vlevo vyhodnotí jako falseoperand , výsledek operace je false bez ohledu na hodnotu pravého operandu. I potom se však vyhodnocuje pravý operand.

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 jeho operandů, ale nevyhodnocuje pravý operand, pokud se operand vlevo vyhodnotí jako false.

U operandů celočíselných typů& vypočítá operátor bitovou logickou hodnotu AND svých operandů. Unární & operátor je operátor address-of.

Logický exkluzivní operátor OR ^

Operátor ^ vypočítá logický exkluzivní operátor OR, označovaný také jako logický XOR, jeho operandů. Výsledek x ^ y je, pokud x se true vyhodnotí true a y vyhodnotí falsejako , nebo x se vyhodnotí false a y vyhodnotí jako true. V opačném případě je falsevýsledek . To znamená, že operátor pro bool operandy ^ vypočítá stejný výsledek jako operátor!= nerovnosti.

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

U operandů celočíselných typů^ vypočítá operátor bitovou logickou výhradní hodnotu OR svých operandů.

Logický operátor OR |

Operátor | vypočítá logickou hodnotu OR jeho operandů. Výsledek je, zda je buď x nebo y vyhodnocen jako true.truex | y V opačném případě je falsevýsledek .

Operátor | vždy vyhodnotí oba operandy. Když se operand vlevo vyhodnotí jako trueoperand , výsledek operace je true bez ohledu na hodnotu pravého operandu. I potom se však vyhodnocuje pravý operand.

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á logickou hodnotu OR jeho operandů, ale nevyhodnocuje operand na pravé straně, pokud se operand vlevo vyhodnotí jako true.

U operandů celočíselných typů| vypočítá operátor bitovou logickou hodnotu OR svých operandů.

Podmíněný logický operátor AND &

Podmíněný logický operátor &&AND , označovaný také jako "zkratový" logický operátor AND, vypočítá logický operátor AND jeho operandů. Výsledkem x && y je, zda je true obojí x a y vyhodnoceno jako true. V opačném případě je falsevýsledek . Pokud x se vyhodnotí jako false, y nevyhodnocuje se.

V následujícím příkladu je operand && zprava operátoru volání metody, které se neprovádí, pokud se operand vlevo vyhodnotí 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 jeho operandů, ale vždy vyhodnocuje oba operandy.

Podmíněný logický operátor OR ||

Podmíněný logický operátor ||OR , označovaný také jako "zkratový" logický operátor OR, vypočítá logický operátor OR jeho operandů. Výsledek je, zda je buď x nebo y vyhodnocen jako true.truex || y V opačném případě je falsevýsledek . Pokud x se vyhodnotí jako true, y nevyhodnocuje se.

V následujícím příkladu je operand || zprava operátoru volání metody, které se neprovádí, pokud se operand vlevo vyhodnotí 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á logickou hodnotu OR svých operandů, ale vždy vyhodnocuje oba operandy.

Logické operátory s možnou hodnotou null

U bool? operandů podporují operátory (logické operátory&AND) a | (logické OR) logiku se třemi hodnotami následujícím způsobem:

• Operátor & vytvoří pouze tehdy true , pokud se oba operandy vyhodnotí jako true. Pokud se buď nebo xy vyhodnotí jako false, x & y vytvoří false (i když se jiný operand vyhodnotí jako null). Jinak výsledek x & y je null.

• Operátor | vytvoří pouze tehdy false , pokud se oba operandy vyhodnotí jako false. Pokud se buď nebo xy vyhodnotí jako true, x | y vytvoří true (i když se jiný operand vyhodnotí jako null). Jinak výsledek x | y je null.

Následující tabulka uvádí sémantiku:

linka	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 hodnot s možnou hodnotou null. Obvykle lze operátor definovaný pro operandy typu hodnoty použít také s operandy odpovídajícího typu hodnoty s možnou hodnotou null. Takový operátor vytvoří null , pokud se některý z jeho operandů vyhodnotí jako null. Operátory &| však mohou vytvořit nenulovou hodnotu, i když se jeden z operandů vyhodnotí jako null. Další informace o chování operátoru s typy hodnot s možnou hodnotou null naleznete v části Lifted operátory v článku Typy hodnot Nullable.

Můžete také použít operátory ! a ^ operátory 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í

U binárního operátoru opje složený výraz přiřazení formuláře.

x op= y

je ekvivalentem

x = x op y

s tím rozdílem, že x se vyhodnotí pouze jednou.

Operátory a operátory &|^ 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 obsahuje logické operátory počínaje nejvyšší prioritou až po 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 změňte ()pořadí vyhodnocení uložené podle priority operátoru:

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 úrovně priority najdete v části Priorita operátorů v článku operátory jazyka C#.

Přetížení operátoru

Uživatelem definovaný typ může přetížit ! , &, |a ^ operátory. Pokud je binární operátor přetížen, odpovídající operátor složeného přiřazení je také implicitně přetížen. Uživatelem definovaný typ nemůže explicitně přetížit operátor složeného přiřazení.

Uživatelem definovaný typ nemůže přetížit podmíněné logické operátory && a ||. Pokud však uživatelem definovaný typ přetěžuje operátory true a false a & nebo | operátor určitým způsobem, &&|| je možné vyhodnotit operandy tohoto typu. Další informace najdete v části Podmíněné logické operátory definované uživatelem specifikace jazyka C#.

specifikace jazyka C#

Další informace najdete v následujících částech specifikace jazyka C#:

• Logický operátor negace
• Logické operátory
• Podmíněné logické operátory
• Složené přiřazení

Viz také

• Operátory a výrazy jazyka C#
• Bitové operátory a operátory posunu