Logické logické operátory (Referenční dokumentace jazyka C#)

Následující operátory provádějí logické operace s logickými operandy:

• Unární operátor ! (logická negace)
• Binary & (Logical and), | (Logical or)a ^ (Logical or) Operators. Tyto operátory vždy vyhodnotí oba operandy.
• Binární && (Podmíněné logické a) a || (Podmíněné logické OR) operátory. Tyto operátory vyhodnotí operand na pravé straně, pokud je to nezbytné.

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

Logický operátor negace!

Unární operátor prefixu ! vypočítá logickou negaci svého operandu. To znamená, že je true -li operand vyhodnocen false , a false , pokud je operand vyhodnocen jako true :

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

Počínaje jazykem C# 8,0, unární příponový ! operátor je operátor null-striktní.

Logický operátor AND &

&Operátor vypočítá logickou a jeho operandy. Výsledek je, x & y true Pokud je x a y vyhodnocen jako true . V opačném případě je výsledkem false .

&Operátor vyhodnocuje oba operandy i v případě, že je levý operand vyhodnocen tak false , aby výsledek operace byl false bez ohledu na hodnotu operandu na pravé straně.

V následujícím příkladu je pravý operand & operátoru volání metody, která je provedena bez ohledu na hodnotu operandu na levé straně:

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Á logickou a jeho operandy, ale nevyhodnotí pravý operand, pokud je levý operand vyhodnocen jako false .

Pro operandy integrálních číselných typů & operátor vypočítá bitovou logickou a jeho operandy. Unární & operátor je operátor address-of.

Logický exkluzivní operátor OR ^

^Operátor vypočítá logickou výlučnou nebo, označovanou také jako logická XOR, z operandů. Výsledkem x ^ y je true , pokud je x vyhodnocena jako true a y false x false y true vyhodnocena jako nebo vyhodnocena jako a vyhodnocena jako. V opačném případě je výsledkem false . To znamená, že pro bool operandy ^ vypočítá operátor 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

Pro operandy integrálních číselných typů ^ operátor vypočítá BITOVÝ logický typ Exclusive nebo jeho operandů.

Logický operátor OR |

|Operátor vypočítá logický nebo jeho operandy. Výsledek je v x | y případě, že je true buď x nebo y vyhodnocen jako true . V opačném případě je výsledkem false .

|Operátor vyhodnocuje oba operandy i v případě, že je levý operand vyhodnocen tak true , aby výsledek operace byl true bez ohledu na hodnotu operandu na pravé straně.

V následujícím příkladu je pravý operand | operátoru volání metody, která je provedena bez ohledu na hodnotu operandu na levé straně:

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é nebo jeho operandy, ale nevyhodnotí operand pravého operandu, je-li operand na levé straně vyhodnocen true .

Pro operandy integrálních číselných typů | operátor vypočítá bitovou logickou nebo jeho operandy.

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

Podmíněný logický operátor AND && , označovaný také jako "" krátkodobého okruhu ", je vypočítán logický operátor a jeho operandů. Výsledek je, x && y true Pokud je x a y vyhodnocen jako true . V opačném případě je výsledkem false . Pokud se x vyhodnotí jako false , y nevyhodnotí se.

V následujícím příkladu je pravý operand && operátoru volání metody, které není provedeno, je-li operand na levé straně 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Á logickou a jeho operandy, ale vždy vyhodnotí oba operandy.

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

Podmíněný logický operátor OR || , označovaný také jako "" krátkodobého "logického okruhu, vypočítá logické nebo jeho operandy. Výsledek je v x || y případě, že je true buď x nebo y vyhodnocen jako true . V opačném případě je výsledkem false . Pokud se x vyhodnotí jako true , y nevyhodnotí se.

V následujícím příkladu je pravý operand || operátoru volání metody, které není provedeno, je-li operand na levé straně 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é nebo jeho operandy, ale vždy vyhodnotí oba operandy.

Logické operátory s možnou hodnotou null

U bool? operandů operátory & (Logical a) a | (Logical a) podporují logiku se třemi hodnotami takto:

• &Operátor vytvoří true pouze v případě, že se na jeho operandy vyhodnotí true . Pokud je x nebo y vyhodnocena jako false , x & y vytvoří (i když se false jiný operand vyhodnocuje null ). V opačném případě výsledek x & y je null .

• |Operátor vytvoří false pouze v případě, že se na jeho operandy vyhodnotí false . Pokud je x nebo y vyhodnocena jako true , x | y vytvoří (i když se true jiný operand vyhodnocuje null ). V opačném případě 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 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 některý z jeho operandů vyhodnotí jako null . Nicméně & | operátory a mohou vygenerovat jinou hodnotu než null, i když je jeden z operandů vyhodnocen jako null . 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

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

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

Viz také

• Referenční dokumentace k jazyku C#
• Operátory a výrazy v C#
• Bitové operátory a operátory bitového posunu