operator warunkowy, brake i continue, operatory logiczne w pętlach

Operator warunkowy jest krótszą i bardziej elegancką metodą na zapisanie instrukcji warunkowej IF, poprzez użycie znaku ? ,który przyjmuje formę:

Wy1 ? Wy2 : Wy3 ;

Działa on w następujący sposób: Wy1 jest warunkiem. Jeśli warunek jest spełniony, instrukcja Wy2 jest realizowana, jeśli nie realizowana jest instrukcja Wy3:

            Console.WriteLine(
                "Wejście powyżej osiemnastego roku " +
                "życia, ile masz lat?");

            int wiek = 
                Convert.ToInt16(Console.ReadLine());

            if (wiek <= 18)
            {
                Console.WriteLine("Jesteś za młody!");
            }
            else
            {
                Console.WriteLine("Wejdź proszę.");
            }

            Console.WriteLine(
                "Wejście powyżej osiemnastego roku " +
                "życia, ile masz lat?");
    
            int wiek = 
                Convert.ToInt16(Console.ReadLine());

            Console.WriteLine((wiek <= 18) ? 
                "Jesteś za młody!" : "Wejdź proszę.");
            //lub przypisanie do zmiennej String
            string odp;
            odp = (wiek <= 18) ? 
                "Jesteś za młody!" : "Wejdź proszę.";

Podwójny znak ?? nazywany jest operatorem koalescencji zerowej. Zwraca lewy operand, jeśli nie jest null (pusty, niezadeklarowany). W przeciwnym wypadku zwraca prawy operand.

            Console.WriteLine(
                "Wejście powyżej osiemnastego roku życia, ile masz lat?");

            int? pobierzwiek = null;

            if (Int32.TryParse(Console.ReadLine(), out int liczba))
            {
                pobierzwiek = liczba;
            }
      
            int wiek = pobierzwiek ?? -1;

            string odpowiedz;

            odpowiedz = (wiek == -1) ? "Wprowadzono nieprawidłowy ciąg." : 
               (wiek <= 18) ? "Jesteś za młody!" : "Wejdź proszę."; 

            Console.WriteLine(odpowiedz);

Kod powyżej sprawdzi wpisany tekst, jeśli tekst jest liczbą, przypisze ją do zmiennej „pobierzwynik” jeśli, nie pozostawi tą zmienną null. Element „int wiek = pobierzwiek ?? -1;” oznacza, że jeśli „pobierzwynik=null” wtedy „wiek=-1” w innym wypadku będzie to liczba. Taki zapis oszczędza nam dużo miejsca i jest krótszy i bardziej czytelny.

Kolejnym elementem, już używanym we wcześniejszych artykułach, ale słabo omówionym jest „breake”, z wcześniejszych lekcji, wiecie, że formuła ta przerywa działanie pętli, instrukcji i wykonywanie kodu. Dodatkowym elementem działającym podobnie do „break” jest „continue” którego działanie w zasadzie jest bardzo podobne, mimo iż nazwa elementu z angielskiego to „kontynuuj” może być trochę myląca, formuła ta przerywa działanie kodu, lecz na trochę inne zasadzie niż „break”. Pomija elementy, ale nie przerywa działania pętli.

          for(int i=0;i<=10;i++)
            {
                if (i == 5) break;
                Console.WriteLine(i);
            }

            /* wyświetli
               0
               1
               2
               3
               4
           */

          for(int i=0;i<=10;i++)
            {
                if (i == 5) continue;
                Console.WriteLine(i);
            }

            /* wyświetli
               0
               1
               2
               3
               4
               6
               7
               8
               9
               10
           */

Krótko mówiąc „continue” służy do pomijania elementów a „break” do zatrzymywania działanie kodu.

Skupimy się teraz na pogłębieniu wiedzy na temat pętli i instrukcji warunkowych. Znamy już operatory arytmetyczne i logiczne, których łączenie wewnątrz warunków jest bardzo ważne i skraca ilość wpisywanych pętli i instrukcji:

            for (int a = 0; a <= 10; a++) { 
                if(a>=3)
                    if(a<=6)
                Console.WriteLine(a);
              }
            }
        /* wyświetli:
           3
           4
           5
           6
         */

            for (int a = 0; a <= 10; a++) { 
                if(a>=3 && a <= 6)
                Console.WriteLine(a);
              }
            }
        /* wyświetli:
           3
           4
           5
           6
         */

Warunki połączyliśmy operatorem „&&”, takich warunków możemy dodać, ile tylko chcemy, oszczędzając miejsce:

            for (int a = 0; a <= 10; a++) { 
                if(a>=3 && a <= 6 && a!=5)
                Console.WriteLine(a);
              }
            }
        /* wyświetli:
           3
           4
           6
         */

Takie połączenie elementów jak poniżej przerwie działanie pętli „for” na liczbie 5 dlatego liczba 6 nie będzie wyświetlona:

            for (int a = 0; a <= 10 && a != 5; a++) { 
                if(a>=3 && a <= 6 )
                Console.WriteLine(a);
              }
            }
        /* wyświetli:
           3
           4
         */

Użycie różnego rodzaju połączonych warunków prezentuje kod poniżej:

            // zaprzeczenie  
            bool rezultat = true;
            if (!rezultat)
            {
                Console.WriteLine("Warunek jest prawdziwy (rezultat == false).");
            }
            else
            {
                Console.WriteLine("Warunek jest fałszywy (rezultat ==  true).");
            }

            // połączenie dwóch warunków 
            int m = 9;
            int n = 7;
            int p = 5;
            if (m >= n && m >= p)
            {
                Console.WriteLine("Nic nie jest większe od m.");
            }

            // połączenie dwóch warunków i zaprzeczenia
            if (m >= n && !(p > m))
            {
                Console.WriteLine("Nic nie jest większe od m.");
            }

            //warunki połączone formułą LUB
            if (m > n || m > p)
            {
                Console.WriteLine("m nie jest najmniejsze.");
            }

            // LUB i zaprzeczenie
            m = 4;
            if (!(m >= n || m >= p))
            {
                Console.WriteLine("Teraz m jest najmniejsze.");
            }
            // Wyświetli:  
            // Warunek jest fałszywy (rezultat ==  true). 
            // Nic nie jest większe od m.
            // Nic nie jest większe od m.
            // m nie jest najmniejsze.
            // Teraz m jest najmniejsze.

Podczas łączenia warunków, najbardziej przydatnymi elementami są „|| – LUB -OR”, „&& – i -AND” które w swoich programach będziemy wykorzystywać bardzo często. Przykład połączenia tych dwóch operatorów:

            for (int a = 0; a <= 10; a++) { 
                if((a > 0 && a <= 3 ) || (a > 6 && a <= 9))
                Console.WriteLine(a);
              }
            }
        /* wyświetli:
           1
           2
           3
           7
           8
           9
         */

Kod wyświetli liczby, wtedy gdy „a” będzie należało do przedziału: