Operatory logiczne

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:

Przykład użycia

            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

            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.

            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:

            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:

            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 
(jeżeli ..., to...)

Podstawowe, zawsze prawdziwe prawa logiczne:

            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)));