Sdílet prostřednictvím

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

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 true se x 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 | y nebo true vyhodnocen jako x.ytrue 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 || y nebo true vyhodnocen jako x.ytrue 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
pravda pravda pravda pravda
pravda false (nepravda) false (nepravda) pravda
pravda nula nula pravda
false (nepravda) pravda false (nepravda) pravda
false (nepravda) false (nepravda) false (nepravda) false (nepravda)
false (nepravda) nula false (nepravda) nula
nula pravda nula pravda
nula false (nepravda) false (nepravda) nula
nula nula nula nula

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 ekvivalentní

x = x op y

Kromě toho, že x se vyhodnotí jenom 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 , !, &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. Počínaje jazykem C# 14 může uživatelem definovaný typ explicitně přetížit operátory složeného přiřazení, aby poskytoval efektivnější implementaci. Typ obvykle přetěžuje tyto operátory, protože hodnotu lze aktualizovat místo přidělení nové instance pro uložení výsledku binární operace. Pokud typ neposkytuje explicitní přetížení, kompilátor vygeneruje implicitní přetížení.

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

Viz také