Instrukcja warunkowa if.

Instrukcja warunkowa if.

 

Instrukcja warunkowa if jest wykorzystywana w kodzie w sytuacji kiedy np. mamy sprawdzić jakiś warunek. Jeżeli warunek jest spełniony to wykonujemy jakąś instrukcję lub blok instrukcji. IPoniżej ogólna deklaracja instrukcji warunkowej if.

if (warunek) instrukcja

Jeżeli warunek zawarty w nawiasach okrągłych jest spełniony to wykonywana jest instrukcja po nawiasie, co obrazuje rysunek poniżej.

instrukcja warunkowa if
Rysunek 13.1 Przykład instrukcji warunkowej if.

Wyjaśnię co po kolei dzieje się w naszym krótkim programie. Na początku deklarujemy zmianną x i przypisujemy do niej wartość 5. Później przy wykorzystaniu instrukcji warunkowej if sprawdzamy zmienną x czy jest równa 5. Jeżeli tak, a w naszym przypadku właśnie tak jest, to wykonywana jest instrukcja po nawiasie okrągłym czyli wyświetlenie na ekranie treści w „x=5”. Zwróć uwagę, że w nawiasie okrągłym gdzie sprawdzamy warunek korzystamy z operatora porównania „==”. Dzięki poleceniu Console.ReadKey(); program czeka na wciśnięcie jakiegokolwiek klawisza z klawiatury.

Co jednak jeżeli chcielibyśmy wykonać kilka instrukcji w sytuacji kiedy warunek jest spełniony. Wtedy blok instrukcji do wykonania umieszczamy w nawiasach klamrowych, co obrazuje poniższy przykład.

if (warunek) 
   { 
      instrukcja 1;
      instrukcja 2;
      …
      instrukcja 10;
   }

Poniższy przykład przedstawia właśnie taką sytuację.

instrukcja warunkowa if
Rysunek 13.2 Przykład instrukcji warunkowej if z blokiem instrukcji.

Tablica wielowymiarowa.

Tablica wielowymiarowa.

Żeby nie było tak prosto oprócz tablic jednowymiarowych, opisanych w poprzednim podrozdziale, istnieją także tablice wielowymiarowe. W takiej tablicy jedno pole (jeden element) jest reprezentowany przez dwa index-y. Do naszej tabeli z poprzedniego rozdziału (przechowującej polskie nazwy miesięcy) chcemy dopisać angielskie nazwy miesięcy. Poniżej wizualizacja takiej tabeli wielowymiarowej.

12.1 Wizualizacja tabeli dwu wymiarowej.
12.1 Wizualizacja tabeli dwu wymiarowej.

Poniżej przykład deklaracji tablicy wielowymiarowej.

// deklaracja tablicy wielowymiarowej
            string[,] nazwyMiesiecy;

Zwróć uwagę, że w nawiasie kwadratowym jest przecinek sugerujący, że jest to tablica wielowymiarowa (jeden przecinek sugeruje, że jest to tablica dwu wymiarowa).

Następnie musimy naszą tablicę zainicjalizować.

//inicjalizacja tablicy wielowymiarowej [2-wiersze,12-kolumn]
            nazwyMiesiecy = new string[2, 12];

Teraz pozostaje nam wprowadzić do odpowiednich pól wartości naszej tablicy, co prezentuje poniższy kod.

Listing 12.1 Wprowadzanie wartości do tablicy dwu wymiarowej komórka po komórce.

//przypisanie wartości do poszczególnych pól tablicy wielowymiarowej
            nazwyMiesiecy[0, 0] = "Styczeń";
            nazwyMiesiecy[1, 0] = "January";
            nazwyMiesiecy[0, 1] = "Luty";
            nazwyMiesiecy[1, 1] = "February";
            nazwyMiesiecy[0, 2] = "Marzec";
            nazwyMiesiecy[1, 2] = "March";
            nazwyMiesiecy[0, 3] = "Kwiecień";
            nazwyMiesiecy[1, 3] = "April";
            nazwyMiesiecy[0, 4] = "Maj";
            nazwyMiesiecy[1, 4] = "May";
            nazwyMiesiecy[0, 5] = "Czerwiec";
            nazwyMiesiecy[1, 5] = "June";
            nazwyMiesiecy[0, 6] = "Lipiec";
            nazwyMiesiecy[1, 6] = "July";
            nazwyMiesiecy[0, 7] = "Sierpień";
            nazwyMiesiecy[1, 7] = "August";
            nazwyMiesiecy[0, 8] = "Wrzesień";
            nazwyMiesiecy[1, 8] = "September";
            nazwyMiesiecy[0, 9] = "Październik";
            nazwyMiesiecy[1, 9] = "Oktober";
            nazwyMiesiecy[0, 10] = "Listopad";
            nazwyMiesiecy[1, 10] = "November";
            nazwyMiesiecy[0, 11] = "Grudzień";
            nazwyMiesiecy[1, 11] = "December";

 

Zwróćcie uwagę, że indeksy w pionie (wierszy) także zaczynają się od wartości „0”. Żeby odwołać się do konkretnej wartości należy wskazać index wiersza i po przecinku index kolumny np. jeżeli chcemy odwołać się do wartości „November” wpiszemy poniższy kod.

// wyświetlenie na ekranie wartości "November" z tablicy
            Console.WriteLine(nazwyMiesiecy[1,10]);

Dokładnie tak samo jak przy tablicach jednowymiarowych istnieje możliwość zapisu w jednym kroku deklaracji, inicjalizacji i przypisania wartości do pól tablicy wielowymiarowej. Poniższy kod prezentuje jeden ze sposobów przypisania wartości do tablicy dwu wymiarowej.

Listing 12.2 Wprowadzanie wartości do tablicy dwu wymiarowej w jednym kroku – sposób 1.

// deklaracja,inicjalizacja i przypisanie wartości do tablicy dwu wymiarowej w jednym kroku
            string[,] nazwyMiesiecy = new string[,]
                  {
                     {"Styczeń","January"},
                     {"Luty","February"},
                     {"Marzec","March"},
                     {"Kwiecień","April"},
                     {"Maj","May"},
                     {"Czeriec","June"},
                     {"Lipiec","July"},
                     {"Sierpień","August"},
                     {"Wrzesień","September"},
                     {"Październik","October"},
                     {"Listopad","November"},
                     {"Grudzień","December"}
                  };

Poniżej wizualizacja tablicy dwu wymiarowej z powyższego listingu.

Tabela 12.2 Wizualizacja tablicy dwu wymiarowej z listingu 12.2

12.2 Wizualizacja tablicy dwu wymiarowej z listingu 12.2.
Rysunek 12.2 Wizualizacja tablicy dwu wymiarowej z listingu 12.2.

Zwróćcie uwagę, że teraz polskie nazwy miesięcy tworzą pierwszą kolumnę a angielskie nazwy tworzą drugą kolumnę. Odwołanie się np. do wartości „November” będzie wyglądało następująco.

// wyświetlenie na ekranie wartości "November" z tablicy
            Console.WriteLine(nazwyMiesiecy1[10, 1]);

Przypisania takich samych wartości do tablicy dwu wymiarowej możemy zrealizować także w inny sposób.

Listing 12.3 Wprowadzanie wartości do tablicy dwu wymiarowej w jednym kroku – sposób 2.

// deklaracja, inicjalizacja i przypisanie wartości do tablicy dwu wymiarowej w jednym kroku
            string[,] nazwyMiesiecy = new string[,]
                 {
                      {"Styczeń","Luty","Marzec","Kwiecień","Maj","Czerwiec","Lipiec","Sierpień","Wrzesień","Październik","Listopac","Grudzień"},
                      {"January","February","March","April","May","June","July","August","September","October","November","December"}
                 };

Natomiast w sposobie drugim polskie nazwy tworzą pierwszy ale wiersz a nazwy angielskie są umieszczone w drugim wierszy (inaczej niż w przykładnie z listingu 12.2). Wizualizacja tablicy dwu wymiarowej z listingu 12.3 prezentuje się następująco.

Tabela 12.2 Wizualizacja tabeli dwu wymiarowej z listingu 12.3.

12.1 Wizualizacja tabeli dwu wymiarowej.
Rysunek 12.1 Wizualizacja tabeli dwu wymiarowej z listingu 12.3.

I gdybyśmy tutaj chcieli się odwołać także do wartości „November” musielibyśmy wpisać.

// wyświetlenie na ekranie wartości z tablicy
            Console.WriteLine(nazwyMiesiecy2[1, 10]);  

Tablica. (tablica jednowymiarowa)

Tablica.

Co to jest w ogóle tablica. Jest to zestaw zmiennych o tym samym typie. W każdym momencie do pól tablicy możemy przypisać wartość odpowiedniego typu np. jeżeli tablica jest typu int możemy do każdego pola tablicy przypisać liczbę całkowita, jeżeli tablica jest typu string to do pól tablicy możemy przypisać ciągi znaków. Wartość w tablicy możemy w każdym momencie nadpisać nową wartością. Do każdego pola tablicy możemy odwołać się za pomocą indeksu.

Struktura deklaracji tablicy jednowymiarowej.

typDanych [  ] nazwaTablicy;

Przykładowa deklaracja tablicy w C# o nazwie nazwyMiesiecy  i typie string.

string [] nazwyMiesiecy;

Po deklaracji tablicy należy ją zainicjalizować. Poniżej przykład inicjalizacji tablicy.

     nazwaTablicy = new typ [rozmiarTablicy];
 np. nazwyMiesiecy = new string [12];

Po inicjalizacji możemy przypisać do poszczególnych pól (za pomocą numerów indeksów) wartości. Skoro nasza tablica nazywa się nazwyMiesiecy to wpiszmy do naszej tablicy nazwy poszczególnych miesięcy, co prezentuje poniższy kod.

  nazwyMiesiecy[0] = "Styczeń";
  nazwyMiesiecy[1] = "Luty";
  nazwyMiesiecy[2] = "Marzec";
  nazwyMiesiecy[3] = "Kwiecień";
  nazwyMiesiecy[4] = "Maj";
  nazwyMiesiecy[5] = "Czerwiec";
  nazwyMiesiecy[6] = "Lipiec";
  nazwyMiesiecy[7] = "Sierpień";
  nazwyMiesiecy[8] = "Wrzesień";
  nazwyMiesiecy[9] = "Październik";
  nazwyMiesiecy[10] = "Listopad";
  nazwyMiesiecy[11] = "Grudzień";

Jak to wygląda w praktyce? Na poniższym rysunku postaram się to zwizualizować.

11.1 Wizualizacja tablicy jednowymiarowej.
11.1 Wizualizacja tablicy jednowymiarowej.

Żeby odwołać się do konkretnej wartości wykorzystujemy odpowiedni index.

Przy odwoływaniu się do pól/wartości w tablicy należy zwrócić na jedną sprawę szczególną uwagę. Otóż zobaczcie, że przy inicjalizacji tablicy podałem rozmiar tablicy (wartość) 12 a w momencie, kiedy przypisuję wartości do poszczególnych pól, index-y zaczynają się od „0” do „11”. Pamiętajcie, że pierwszy obiekt w tablicy ma index „0” a ostatni index ma wartość o jedną mniejszą niż rozmiar tablicy.

Kompletny kod od deklaracji po wyświetlenie konkretnej wartości z tablicy przedstawia poniższy kod (listing 11.1).

Listing 11.1 Proces deklaracji, inicjalizacji, przypisania wartości i wyświetlenia wartości z tablicy.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Konsola
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] nazwyMiesiecy; // deklaracja tablicy o nazwie "nazwyMiesiecy" i o typie "string"
            nazwyMiesiecy = new string[12]; // inicjalizacja tablicy "nazwyMiesiecy"
            nazwyMiesiecy[0] = "Styczeń"; // przypisanie wartości do poszczególnych pól w tablicy
            nazwyMiesiecy[1] = "Luty";
            nazwyMiesiecy[2] = "Marzec";
            nazwyMiesiecy[3] = "Kwiecień";
            nazwyMiesiecy[4] = "Maj";
            nazwyMiesiecy[5] = "Czerwiec";
            nazwyMiesiecy[6] = "Lipiec";
            nazwyMiesiecy[7] = "Sierpień";
            nazwyMiesiecy[8] = "Wrzesień";
            nazwyMiesiecy[9] = "Październik";
            nazwyMiesiecy[10] = "Listopad";
            nazwyMiesiecy[11] = "Grudzień";
            Console.WriteLine(nazwyMiesiecy[0]); // wyświetlenie na ekranie wartości z tablicy o index-ie "0"
            Console.ReadKey(); // czekamy na wciśnięcie jakiegokolwiek przycisku z klawiatury
        }
    }
}

Deklarację, inicjalizację i przypisanie wartości możemy troszeczkę skrócić i zrobić w jednym kroku, korzystając z poniższego zapisu.

string[] nazwyMiesiecy = new string[]
     {"Styczeń", "Luty", "Marzec", "Kwiecień",
     "Maj", "Czerwiec", "Lipiec", "Sierpień", 
     "Wrzesień", "Październik", "Listopad", "Grudzień"};

Wtedy listing 10.1 zmienia postać na poniższy.

Listing 10.2. Deklaracja, inicjalizacji i przypisanie wartości do tablicy w jednym kroku.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Konsola
{
    class Program
    {
        static void Main(string[] args)
        {
           string[] nazwyMiesiecy = new string[]
                {"Styczeń", "Luty", "Marzec", "Kwiecień", 
                 "Maj", "Czerwiec", "Lipiec", "Sierpień", 
                 "Wrzesień", "Październik", "Listopad", "Grudzień"};
            Console.WriteLine(nazwyMiesiecy[0]); 
                // wyświetlenie na ekranie wartości z tablicy o index-ie "0"
            Console.ReadKey(); 
                // czekamy na wciśnięcie jakiegokolwiek przycisku z klawiatury
        }
    }
}

Powyższy zapis deklaracji, inicjalizacji i przypisania wartości do poszczególnych pól można jeszcze skrócić usuwając część „new string[]”, patrz kod poniżej.

string [] nazwyMiesiecy = new string[]
                {"Styczeń", "Luty", "Marzec", "Kwiecień", "Maj", "Czerwiec", "Lipiec", "Sierpień", "Wrzesień", "Październik", "Listopad", "Grudzień"};

Zwróć uwagę, że w nawiasach kwadratowych nie ma żadnej wartości. Jeśli zaistnieje taka sytuacja długość takiej tablicy jest tworzona dynamicznie w zależności ile przypiszemy do niej wartości po prawej stronie w nawiasach klamrowych.

Rzutowanie czyli konwersja typów.

Rzutowanie czyli konwersja typów.

Rzutowanie, czyli konwersja typów, to nic innego jak próba zamiany typu zmiennej na inny typ.  Jest jednak pewien haczyk. O ile można rzutować wartość z typu o mniejszej precyzji do typu o większej precyzji o tyle nie można niejawnie rzutować typu o większej precyzji na typ o mniejszej precyzji.

Pokażę to na dwóch prostych przykładach.

W pierwszym przykładzie postaram się rzutować wartość zmiennej x typu int na typ double a w drugim przykładzie postaram się uzyskać odwrotny efekt czyli rzutować wartość zmiennej x typu double na typ int.

Rzutowanie wartości zmiennej x typu int na zmienną y typu double. Takie rzutowanie przedstawia kod na rysunku poniżej.

Rysunek 10.1 Rysunek 10.1 Rzutowanie wartości zmiennej x typu int na zmienną y typu double.Rzutowanie wartości zmiennej x typu int na zmienną y typu double.
Rysunek 10.1 Rysunek 10.1 Rzutowanie wartości zmiennej x typu int na zmienną y typu double.Rzutowanie wartości zmiennej x typu int na zmienną y typu double.

Wynikiem uruchomienia takiego programu będzie wyświetlenie na ekranie wartości 100, co jest wynikiem prawidłowym.

Kolejne zadanie to rzutowanie wartości zmiennej x typu double na zmienną y typu int. Takie rzutowanie przedstawia kod na rysunku poniżej.

Rysunek 10.2 Rzutowanie wartości zmiennej x typu double na zmienną y typu int.
Rysunek 10.2 Rzutowanie wartości zmiennej x typu double na zmienną y typu int.

Przy próbie uruchomienia programu otrzymujemy komunikat „There were build errors. Would You like to continue and run the last successful build. Yes/No?” co oznacza, że nie można skompilować naszego program z powodu błędów w kodzie.

Jak najedziemy kursorem nad podkreślone x otrzymamy komunikat „Cannot implicitly convert type ‘double’ to ‘int’. An explicit conversion exists (are you missing a cart?)”. To oznacza, że trzeba zadeklarować jawną konwersję, co przedstawia rysunek 10.3.

Rysunek 10.3 Jawne rzutowanie typu double na int.
Rysunek 10.3 Jawne rzutowanie typu double na int.

Widzimy, że Visual Studio nie pokazuje żadnych błędów więc powinniśmy mieć możliwość uruchomienia naszego programu. Więc do dzieła, uruchamiamy go przyciskiem F5. Wynikiem działania naszego programu jest liczba 10, co obrazuje następny rysunek.

Rysunek 10.4 Wynik jawnego rzutowania typu double na int.
Rysunek 10.4 Wynik jawnego rzutowania typu double na int.

Nasuwa się pytanie, ale dlaczego 10 a nie 10,5 jak było zadeklarowane w zmiennej typu double. Odpowiedź jest prosta, bo rzutowaliśmy zmienną o typie o większej precyzji na zmienną o typie o mniejszej precyzji. Zmienna typu int nie może przechowywać wartości zmiennoprzecinkowych, więc rzutując taką wartość tracimy jej precyzję i wynik jest, w naszym przypadku, zaokrąglany do liczb całkowitych.

Stała

Stała

Stała to identyfikator, do którego możemy przypisać jakąś wartość lub wyrażenie (np. wartość liczbowa lub ciąg znaków itp.), której nie można zmieniać podczas wykonywania programu. W języku C# stałą deklarujemy za pomocą słówka const. Stałą możemy wykorzystywać wielokrotnie w kodzie programu. Np. przypisujemy do stałej wartość liczby Pi=3,14 w trakcie pracy programu możemy do tej stałej odwołać się ile razy chcemy. Przy deklaracji stałej musimy także określić typ stałej.

Przykład deklaracji i inicjalizacji stałej typu double.

const double liczbaPi = 3.14;

Stałe możemy także wykorzystywać w obliczeniach

Deklaracja stałej i wykorzystanie jej w obliczeniach.

const double cenaPodstawowa = 99.99;
double cenaKoncowa = cenaPodstawowa * 0.8;

Delegaty.

Delegaty

Delegaty to utworzone przez nas typy danych za pomocą których „wskazujemy” na odpowiednie metody które mają zostać wykonane w danym momencie. W tym momencie ktoś może powiedzieć, że można to zrobić korzystając z instrukcji warunkowych i ma rację, Delegaty są jednak lepsze przy bardziej rozbudowanych projektach. Moim zdaniem po bliższym poznaniu delegatów są one lepszym rozwiązaniem.

Spróbuję wytłumaczyć to bardziej szczegółowo. Wyobraź sobie taką sytuację, że podczas działania programu użytkownik może podjąć decyzję co do dalszego działania tego programu np. mamy program który realizuje podstawowe zadania kalkulatora. Podajemy dwie liczby i możemy wybrać działanie jakie na zostać wykonane na tych dwóch liczbach. W momencie wyboru działania program nie wie jakie działanie wybierze użytkownik. To użytkownik podejmuje decyzję o wyborze działania i tutaj właśnie możemy użyć delegatów. Za ich pomocą możemy (w zależności od wyboru użytkownika)powiedzieć programowi która metoda powinna zostać wykonana.

Przykład deklaracji delegata:

public delegate int typDelegata = (int a);

Jak widać w powyższym przykładzie delegata deklarujemy przy pomocy słówka delegate. Zadeklarowaliśmy delegata o typie int z jednym parametrem także o typie int.

Ponadto możemy stworzyć obiekt o typie delegata, przykład poniżej.

typDelegata mojObiekt = new typDelegata(metoda1);

Jak widzimy w powyższym przykładzie stworzyliśmy obiekt o nazwie „mojObiekt” o typie „typDelegata” i jak parametr dodaliśmy nazwę metody do wykonania „metoda1″.

Dla pełnego zobrazowania działania naszego delegata prezentuję poniżej pełny kod programu.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Konsola
{
    class Program
    {
        public delegate int typDelegata (int a);
        static int metoda1(int a)
        {
            return a;
        }
        static int metoda2(int a)
        {
            return a + 10; ;
        }
        static void Main(string[] args)
        {
            typDelegata mojObjekt = new typDelegata(metoda1);

            Console.WriteLine("Wynik działania metody 1: " + mojObjekt(10));

            mojObjekt = metoda2;

            Console.WriteLine("Wynik działania metody 2: " + mojObjekt(10));

            Console.ReadKey();

        }
    }
}

Program jest bardzo prosty ale prezentuje działanie delegatów. Zadeklarowałem na samym początku delegata o nazwie „typDelegata” oraz dwie metody o nazwach „metoda1″ i „metoda2″. Pierwsza metoda zwraca wartość parametru, a druga zwraca wartość parametru powiększonego o 10. W metodzie „Main” tworzymy obiekt „mojObiekt” i przypisujemy do niego metodę „metoda1″. Następnie na wyrzucamy na ekran konsoli wynik działania metody1, gdzie jako parametr delegata podajemy wartość 10. Następnie „łączymy” delegata z metodą2, gdzie jako parametr delegata podajemy wartość 10 i wyrzucamy na ekran konsoli efekt działania metody 2. Na ekranie powinniśmy otrzymać wynik jak poniżej.

Wynik działania metody 1: 10
Wynik działania metody 2: 20

I wszystko się zgadza metoda 1 miała nam zwrócić wartość parametru, czyli liczbę 10 a metoda 2 miała nam zwrócić wartość parametru powiększonego o 10, czyli wartość 20.

 

Konkatenacja. Operator łączenia.

Konkatenacja w programowaniu oznacza łączenie dwóch wyrażeń w jedno. Wyrażeniami mogą być np. dwa ciągi znaków ale także liczba i ciąg znaków.

Listing 7.1 Łączenie dwóch ciągów znaków.

   string a = "Ala";
   string b = " ma kota";
   Console.WriteLine(a + b);
   Console.ReadKey();

Efekt po uruchomieniu projektu

kurs c# konkatenacja operator łączenia.
Rysunek 7.1 Efekt łączenia dwóch ciągów znaków.

Przykład 2. Łączenie zmiennej typu int z ciągiem znaków oraz zmiennej typu double z ciągiem znaków (listing 7.2).

   int a = 12;
   double b = 99.99;
   Console.WriteLine(a + "zł");
   Console.WriteLine(b + "zł");
   Console.ReadKey();

Efekt po uruchomieniu projektu.

Rysunek 7.2 Efekt łączenia zmiennej typu int i double z ciągiem znaków.

Konkatenacja operator łączenia.
Rysunek 7.2 Efekt łączenia zmiennej typu int i double z ciągiem znaków.

 

 

Dekrementacja. Operator dekrementaji. Pre dekrementacja. Post dekrementacja.

Dekrementacja (ang. decrement – ubytek) to proces odwrotny do inkrementacji (opisanej wcześniej). To zmniejszenie wartości argumentu o jeden. Operator dekrementacji to „ - – ”.

Przykład: powiedzmy, że chcemy zmniejszyć wartość zmiennej „a” która w chwili obecnej wynosi 10 o jeden, czyli finalnie nasza zmienna otrzyma wartość 9.

int a = 10; // tworzymy zmienną „a” i przypisujemy jej wartość 10

Listing 5.1 Zmniejszanie wartości zmiennej bez operatora dekrementacji.

   int a = 10; // tworzymy zmienną "a" i przypisujemy jej wartość 10
   a = a - 1 ; // zmniejszamy jej wartość o 1

Pobierz cały listing 5.1

W powyższym przykładzie widzimy, że zmniejszyliśmy wartość zmiennej “a” o 1 ale bez użycia operatora dekrementacji.

Listing 5.2 Zmniejszenie wartości zmiennej „a” przy użyciu operatora dekrementacji.

int a = 10; // tworzymy zmienną "a" i przypisujemy jej wartość 10
a--; // zmniejszamy wartość zmiennej "a" o 1 przy użyciu operatora dekrementacji

Pobierz cały listing 5.2

Jeżeli chodzi o pojęcie dekrementacji to wyróżniamy jej dwie postacie pre dekrementacja i post dekrementacja. Już same przedrostki naprowadzają o co chodzi. Otóż pre dekrementacja to operacja powodująca zmniejszenie wartości zmiennej przed użyciem zmiennej a post dekrementacja to operacja powodująca zmniejszenie wartości zmiennej po jej użyciu, co obrazują poniższe przykłady.

Listing 4.3 Użycie pre dekrementacji.

int a = 10; // tworzymy "a" i przypisujemy jej wartość 10
Colsole.WriteLine(--a); 
/* przykład pre dekrementacji czyli najpierw zmniejszamy wartość zmiennej (operator dekrementacji znajduje się przed zmienną „a”) a później wyświetlamy jej wartość na ekranie */
Console.ReadKey();

Pobierz cały listing 5.3.

Analizując powyższy przykład pre dekrementacji należy zwrócić uwagę że na ekranie pojawi się wartość 9 ponieważ dekrementacja (zmniejszenie wartości o 1) nastąpiła przed wyświetleniem wartości zmiennej „a” na ekranie.

Listing 4.4 Użycie post dekrementacji.

int a = 10;
   // tworzymy zmienną "a" i przypisujemy jej wartość 10
Console.WriteLine(a--); 
   /* przykład post dekrementacji, czyli najpierw wyświetlamy wartość zmiennej "a" na ekranie a później zmniejszamy jej wartość o 1 operatorem dekrementacji "--" */
Console.ReadKey();

Pobierz cały listing 5.4

Analizując powyższy przykład chciałem zwrócić uwagę na miejsce które wymaga dodatkowego wyjaśnienia. Zwódźcie uwagę, że mimo wyświetlenia na ekranie wartości 10 po wykonaniu się instrukcji Console.WriteLine(a–); wartość zmiennej „a” będzie równa 9. Dlaczego? Ponieważ operator dekrementacji znajduje się za zmienną „a”, co powoduje zmniejszenie wartości tej zmiennej już po wyświetleniu jej wartości pierwotnej na ekranie. Gdybyśmy dodali do naszego kodu kolejne polecenie Console.WriteLine(a); to zobaczylibyśmy na ekranie wartość 9.

Dekrementację możemy wykonać wielokrotnie.

Inkrementacja, operator inkrementacji. Pre i post inkrementacja.

Inkrementacja (ang. increment – przyrost) to zwiększenie wartości argumentu o jeden. Operator inkrementacji to „++”.

Przykład: powiedzmy, że chcemy zwiększyć wartość zmiennej „a” o wartości 10 o jeden, czyli finalnie nasza zmienna otrzyma wartość 11.

int a = 10; // tworzymy zmienną „a” i przypisujemy jej wartość 10

Listing 4.1 Zwiększanie wartości zmiennej bez operatora inkrementacji.

   int a = 10; // tworzymy zmienną "a" i przypisujemy jej wartość 10
   a = a + 1 ; // zwiększamy jej wartość o 1

Pobierz cały listing 4.1

W powyższym przykładzie widzimy, że zwiększyliśmy wartość zmiennej “a” o 1 ale bez użycia operatora inkrementacji.

Listing 4.2 Zwiększenie wartości zmiennej „a” przy użyciu operatora inkrementacji.

int a = 10; // tworzymy zmienną "a" i przypisujemy jej wartość 10
a++; // zwiększamy wartość zmiennej "a" o 1 przy użyciu operatora inkrementacji

Pobierz cały listing 4.2

Jeżeli chodzi o pojęcie inkrementacji to wyróżniamy jej dwie postacie pre inkrementacja i post inkrementacja. Już same przedrostki naprowadzają o co chodzi. Otóż pre inkrementacja to operacja powodująca zwiększenie wartości zmiennej przed użyciem zmiennej a post inkrementacja to operacja powodująca zwiększenie wartości zmiennej po jej użyciu, co obrazują poniższe przykłady.

Listing 4.3 Użycie pre inkrementacji.

int a = 10; // tworzymy "a" i przypisujemy jej wartość 10
Colsole.WriteLine(++a); 
/* przykład pre inkrementacji czyli najpierw zwiększamy wartość zmiennej (operator inkrementacji znajduje się przed zmienną „a”) a później wyświetlamy jej wartość na ekranie */
Console.ReadKey();

Pobierz cały listing 4.3

Analizując powyższy przykład pre inkrementacji należy zwrócić uwagę że na ekranie pojawi się wartość 11 ponieważ inkrementacja (zwiększenie wartości o 1) nastąpiła przed wyświetleniem wartości zmiennej „a” na ekranie.

Listing 4.4 Użycie post inkrementacji.

int a = 10;
   // tworzymy zmienną "a" i przypisujemy jej wartość 10
Console.WriteLine(a++); 
   /* przykład post inkrementacji, czyli najpierw wyświetlamy wartość zmiennej "a" na ekranie a później zwiększamy jej wartość o 1 operatorem inkrementacji "++" */
Console.ReadKey();

Pobierz cały listing 4.4

Analizując powyższy przykład chciałem zwrócić uwagę na miejsce które wymaga dodatkowego wyjaśnienia. Zwódźcie uwagę, że mimo wyświetlenia na ekranie wartości 10 po wykonaniu się instrukcji Console.WriteLine(a++); wartość zmiennej „a” będzie równa 11. Dlaczego? Ponieważ operator inkrementacji znajduje się za zmienną „a”, co powoduje zwiększenie wartości tej zmiennej już po wyświetleniu jej wartości pierwotnej na ekranie. Gdybyśmy dodali do naszego kodu kolejne polecenie Console.WriteLine(a); to zobaczylibyśmy na ekranie wartość 11.

Inkrementację możemy wykonać wielokrotnie.

Operator przypisania

W C# operatorem przypisania jest znak ‚=’.

Operator przypisania może służyć do przypisania wartości do zmiennej.

   int a = 4;

Może on także służyć do przypisania wartości jednej zmiennej do drugiej.

   int a = 5;
   int b = a;

Może on także służyć do przypisania jednej zmiennej wartości wyrażenia matematycznego.

   int a = 5;
   int b = 7;
   int c = a + b;

Za pomocą operatora przypisania możemy także zwiększać wartość zmiennej.

   a += 4; // zapis równoważny to: a = a + 4;
   a *= 4; // zapis równoważny to: a = a * 4;