Operatory logiczne służą głównie do porównania elementów, wynik ich działania zawsze jest typu boolean (prawda lub fałsz). Program za ich pomocą podejmuje określone działanie poprzez sprawdzenie warunku, w C# wyróżniamy następujące warunki logiczne:
| Operator | Symbol | Opis |
|---|---|---|
| Logiczny lub |
| |
prawda | fałsz = prawda fałsz | fałsz = fałsz |
| Logiczny i | & | prawda & fałsz = fałsz fałsz & fałsz = prawda |
| Negacja | ! | !prawda =fałsz !fałsz = prawda |
| Mniejszy od | < | 15 <10 =fałsz 10<14 =prawda 10<10 =fałsz |
| Mniejszy od | <= | 15 <10 =fałsz 10<14 =prawda 10<10 =prawda |
| Większy od | > | 5>9=fałsz 9>2 = prawda 5>5 =fałsz |
| Mniejszy od | >= | 5>9=fałsz 9>2 = prawda 5>5 =prawda |
| Logiczna równość | == | (5==4) = fałsz (4==4) = prawda |
Przykład użycia
|
1 2 3 4 5 6 7 8 |
bool a = false; bool b = true; bool c = true; Console.WriteLine(a & b); //Zwróci false Console.WriteLine(b & c); //Zwróci true Console.WriteLine(false & b); //Zwróci false Console.WriteLine(true & c & b); //Zwróci true Console.WriteLine(false & c & b); //Zwróci false |
Oczywiście działania możemy wykonywać na liczbach, sprawdzając je za pomocą operatorów logicznych
|
1 2 3 4 5 6 7 8 |
bool a = 10 < 9; //false bool b = 8 == 5; //false bool c = 5 >= 3; //prawda Console.WriteLine(a & b); //Zwróci false Console.WriteLine(!b & c); //Zwróci true Console.WriteLine((3>=1) & b); //Zwróci false Console.WriteLine(true & (5==9) & b); //Zwróci false Console.WriteLine(false & c & !(4>10)); //Zwróci false |
Drugim dostępnym operatorem logicznym w C# jest znak ^ który można interpretować jako specjalny logiczny „lub”, przyjmuje ona wartość true, jeśli tylko jedna ze zmiennych jest true.
|
1 2 3 4 5 6 7 8 |
Boolean a = false; Boolean b = true; Boolean c = true; Console.WriteLine(a ^ b); //Zwróci true Console.WriteLine(b ^ c); //Zwróci false Console.WriteLine(false ^ b); //Zwróci true Console.WriteLine(true & c ^ b); //Zwróci false Console.WriteLine(false & c ^ b); //Zwróci true |
Działania logiczne wykonywane są od lewej do prawej, chyba że nawiasy wskażą inaczej:
|
1 2 |
Console.WriteLine(false & c ^ b); //Zwróci true Console.WriteLine(false & (c ^ b)); //Zwróci false |
Warunek „nieprawda że” można łączyć, ze wszystkimi operatorami. Ważny jest tutaj zapis, jeśli umieścimy wykrzyknik przed nawiasem to odnosił się będzie do całego wyrażenia:
|
1 2 3 4 |
Console.WriteLine(!(true == true)); //fałsz Console.WriteLine(!true | false); //fałsz Console.WriteLine(!!(true == true));//prawda Console.WriteLine((true & true)); //prawda |
Jeśli interesujecie się matematyką, zauważyliście pewnie, że nie ma w C# znaku implikacji znanego z logiki, można go jednak zapisać jako (!p | q )
Dla poniższej tabeli: 1= prawda, 0= fałsz
| p | q | p & q (…i… ) |
p | q (…lub…) |
|
p == q (…wtedy i tylko wtedy, gdy…) |
||
|---|---|---|---|---|---|---|---|
| 1 |
1 |
1 | 1 | 1 | 1 | ||
| 1 | 0 | 0 | 1 | 0 | 0 | ||
| 0 | 1 | 0 | 1 | 1 | 0 | ||
| 0 | 0 | 0 | 0 | 1 | 1 |
Podstawowe, zawsze prawdziwe prawa logiczne:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
bool p = true; bool q = false; bool r = false; // p & q (...i... ) matematyczny ∧ // p | q (...lub...) matematyczny ∨ //!p | q (jeżeli..., to...) matematyczny ⇒ // p == q (...wtedy i tylko wtedy, gdy...) matematyczny ⇔ //pr.podwójnego przeczenia ~ (~ p) ⇔ p Console.WriteLine(!(!p)); //prawda //pr. wyłączonego środka p∨ ~ p (z dwóch zdań przeciwnych przynajmniej jedno jest prawdziwe) Console.WriteLine(p|(!p)); //pr.sprzeczności ~(p∧ ~p) (z dwóch zdań przeciwnych przynajmniej jedno jest fałszywe) Console.WriteLine(!(p&!p)); //pr.kontrapozycji (p ⇒ q) ⇔ (~q ⇒~p) Console.WriteLine((!p|q)== (!(!q) | (!p))); // pr.przemienności koniunkcji p ∧ q ⇔ q ∧ p Console.WriteLine((p & q) == (q & p)); //pr.przemienności alternatywy p ∨ q ⇔ q ∨ p Console.WriteLine((p | q) == (q | p)); //pr.de Morgana: //~(p ∧ q) ⇔ (~p∨ ~q) Console.WriteLine(!(p & q) == (!q | !p)); //~(p ∨ q) ⇔ (~p∧ ~q) Console.WriteLine(!(p | q) == (!q & !p)); //pr.zaprzeczania implikacji ) ~(p ⇒ q) ⇔ (p∧ ~q) Console.WriteLine(!(!p | q)==(p & !q)); //pr. „nie wprost” ( p ⇒ q) ⇔{( p∧ ~ q) ⇒~ p} Console.WriteLine((!p | q) == !(p & !q) | !p); //pr. rozdzielności koniunkcji względem alternatywy ( p ∧ (q ∨ r)) ⇔ (( p ∧ q) ∨ ( p ∧ r)) Console.WriteLine((p & (q | r))==((p & q)|(p & r))); //pr. rozdzielności alternatywy względem koniunkcji ( p ∨ (q ∧ r)) ⇔ (( p ∨ q) ∧ ( p ∨ r)) Console.WriteLine((p | (q & r)) == ((p | q) & (p | r))); |
