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;

Operatory arytmetyczne

Myślę, że nie trzeba tłumaczyć czym są operatory arytmetyczne. Ograniczę się tylko do ich przedstawienia z krótkim przykładem.

Dodawanie „+”
przykład:
int x = 10;
int y = 7;
Console.WriteLine( x + y );  // wyświetlenie w konsoli wyniku działania
Odejmowanie  „-„
przykład:
int x = 20;
int y = 10;
Console.WriteLine( x – y );  // wyświetlenie w konsoli wyniku działania
Mnożenie ” * „
przykład:
int x = 5;
int y = 5;
Console.WriteLine( x * y );  // wyświetlenie w konsoli wyniku działania
Dzielenie „/”
przykład:
int x = 10;
int y = 5;
Console.WriteLine( x / y );  // wyświetlenie w konsoli wyniku działania
Reszta z dzielenia „%”
przykład:
int x = 12;
int y = 5;
Console.WriteLine( x % y ); // wyświetlenie w konsoli wyniku działania

W powyższym przykładzie dla reszty z dzielenia wynikiem będzie liczba 2. Pamiętaj, że znak modulo ‚%’ to nie to samo co dzielenie ‚/’.

darmowy-kurs-csharp   Przy bardziej skomplikowanych działaniach z większą ilością nawiasów itp. obowiązuje, jak w matematyce, pierwszeństwo wykonywania działań.
darmowy-kurs-csharp   Kiedy wynikiem naszego działania może być liczba zmiennoprzecinkowa, wtedy musimy skorzystać ze zmiennych typu double a nie typu int.przykład dzielenia zmiennych typu int które dają wynik zmiennoprzecinkowy

int x = 81;
int y = 10;
Console.WriteLine(x / y);

Wynikiem naszego działania będzie liczba 8 mimo, że wynik dzielenia to 8,1. Dlaczego tak się stało? Ponieważ zmienne wykorzystane w tym działaniu są typu int, z typ ten reprezentuje liczby całkowite.

przykład dzielenia zmiennych typu double które dają wynik zmiennoprzecinkowy

double x = 81;
double y = 10;
Console.WriteLine(x / y);

Wynikiem naszego działania będzie liczba 8,1 i to jest prawidłowy wynik.

 

Typy danych

W języku C# każda zmienna lub stała ma przypisany odpowiedni typ danych.  Określa on jakiego rodzaju dane (wartości) będą przechowywane w danej zmiennej lub stałej. Typu danych określa m.in.:

  • Charakter danych. Czy jest to np. liczba całkowita bez znaku (typ: int) lub ciąg znaków (typ: string).
  • Przestrzeń przechowywania (ile dany typ zajmuje miejsca w pamięci).
  • Wartości minimalne i maksymalne jakie może reprezentować (innymi słowy zakres wartości).

Przy doborze typu zmiennej należy się kierować zasadą minimalizacji tzn. jeśli nie potrzebujemy „większego” typu to korzystamy z „mniejszego”. Przykładem może być byte i short. Zmienna typu byte może przyjąć wartość od 0 do 255 (włącznie z 255), a zmienna o typie short może przyjąć wartość od -32768 do 32767. Jeżeli wiemy, że wartość naszej zmiennej nie przyjmie nigdy wartości większej niż 255 to nie ma sensu korzystać z typu short bo typu short potrzebuje do reprezentacji 2 Bajty pamięci. W takim przypadku lepiej skorzystać z typu byte, który do reprezentacji potrzebuje tylko 1 Bajta.

Podstawowe typy danych

zestawienie typów danych

Przyjrzyjmy się jeszcze jednej właściwości typów. Na podstawie typu int zaprezentuję możliwość zwiększenia (a w zasadzie przesunięcia) zakresu zmiennej. Powiedzmy, że do zmiennej „a” chcemy przypisać wartość 2500000000 (dwa i pół miliarda). Jeżeli chcielibyśmy zadeklarować naszą zmienną „a” o typie int to zobaczylibyśmy błąd z powodu przekroczenia zakresu, gdyż zmienne typu int mogą przyjąć wartość od -2147483648 do 2147483647. W tym przypadku należałoby użyć typu long który daje już możliwość przypisania tak dużej wartości do zmiennej. Typ long potrzebuje jednak dwa razy więcej pamięci. Jeżeli wiemy, że nasza zmienna może przyjmować tylko wartości dodatnie możemy zastosować typ int bez znaku dodając do słówka int „u” (unsigned) na początku, czyli uint. To przerzuca jakby zakres ujemny na dodatnią stronę i tym samym zwiększa (podwaja) „dodatni” zakres typu uint, co obrazuje poniższy zrzut.

typ uint
Rysunek 2.1 Porównanie typów int i uint

Na rysunku widzimy deklarację zmiennej „c” typu int i próbę przypisania do niej wartości spoza zakresu. Kompilator od razu podkreśla błąd na czerwono.

Drugi przypadek to deklaracja zmiennej „d” typu uint i próba przypisania do niej tej samej wartości co w pierwszym przypadku. Błąd w takim przypadku nie występuję z uwagi na zwiększenie/przesunięcie zakresu typu.

darmowy-kurs-csharp  Przykład deklaracji i inicjalizacji zmiennej typu int (liczby całkowite). Pamiętaj, że liczby całkowite zawierają także liczby ujemne.int a = -300 ;
darmowy-kurs-csharp   Przykład deklaracji i inicjalizacji zmiennej typu double (liczba zmiennoprzecinkowa).double a = 30.55;
darmowy-kurs-csharp   Przykład deklaracji i inicjalizacji zmiennej typu char (typu znakowy).char x = ‚K';

Pamiętaj, że liczby to także mogą być znaki i znak ‚1’ nie oznacza w przypadku typu char liczby jeden tylko znak jeden.

darmowy-kurs-csharp   Przykład deklaracji i inicjalizacji zmiennej typu string (ciąg znaków)string x = „Ala ma kota”;
darmowy-kurs-csharp   Przykład deklaracji i inicjalizacji zmiennej typu bool (typ logiczny prawda/fałsz)bool x = false;