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 pro bool operandy ^ operátor 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.true x | 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.true x || 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 x y 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 x y 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:

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

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