Podstawy programowania Zachodniopomorska Szkoła Biznesu Podstawy programowania Wykład 2: Podstawy obliczeń w C++

Podstawy programowania - Podstawy obliczeń w C++ Dane i ich rodzaje Praca programu jako przetwarzanie danych Przykłady danych różnych rodzajów: - liczba - tekst - znak - adres w pamięci - data i czas - obraz, dźwięk, video Kodowanie w postaci kombinacji (ciągu) bitów interpretowanych jako liczby Sposób kodowania danych to reprezentacja Podstawy programowania - Podstawy obliczeń w C++

Podstawy programowania - Podstawy obliczeń w C++ Typy danych w C++ Wszystkie dane w programie muszą mieć określony typ definiujący jednoznacznie ich zapis w pamięci Typy całkowite Typy zmiennoprzecinkowe Typ znakowy Typy pochodne Wskaźnik Referencja Typy złożone Tablica Rekord lub klasa Unia Pole bitowe Podstawy programowania - Podstawy obliczeń w C++

Typy całkowitoliczbowe Stosowane do zapisu wartości niewymagających użycia ułamków; ilości, numerów porządkowych itp. Typ int Zakres liczb - modyfikatory: short, long typy: short int = short, long int = long Określenie znaku - modyfikatory: signed, unsigned typy: signed int = signed unsigned int = unsigned signed/unsigned short [int] signed/unsigned long [int] Typ znakowy char może być również traktowany jako liczba całkowita Podstawy programowania - Podstawy obliczeń w C++

Typy całkowite i ich zakresy Rozmiar Znak 1B = 8b char 2B = 16b short (int) 4B = 32b long (int) Ze znakiem signed -128 127 -32 768 32 767 -2 147 483 648 2 147 483 647 Bez znaku unsigned 255 65 536 4 294 967 296 Rozmiar typu int zależy od kompilatora i z założenia powinien odpowiadać szerokości szyny danych komputera, (obecnie 32b) Typy int, short i long domyślnie posiadają znak (signed) Dla typu char własność ta zależy od kompilatora Podstawy programowania - Podstawy obliczeń w C++

Typy zmiennoprzecinkowe Zapis wartości zawierających ułamki lub zbyt dużych aby reprezentować je za pomocą typów całkowitych Typy float, double i long double Różnią się one precyzją zapisu i zakresem dopuszczalnych wartości oraz liczbą bajtów zajętej pamięci: Typ Rozmiar Precyzja Zakres wartości float 4B 7-8 cyfr  (1.5*10-45 ... 3.4*10+38 ) double 8B 15-16 cyfr  ( 5*10-324 ... 1.7*10+308) long double 10B 19-20 cyfr  ( 3.4*10-4932 ... 1.1*10+4932) Podstawy programowania - Podstawy obliczeń w C++

Stałe liczbowe w programie Liczby całkowite wpisane wprost w tekście programu traktowane są jako typ int, chyba że ich wartość wykracza poza zakres tego typu. Wtedy stosowany jest typ całkowity o większym zakresie (np. long lub int64) lub kompilacja kończy się błędem Znak U po liczbie wymusza utworzenie stałej o typie nieznakowanym (unsigned) Znak L wymusza utworzenie stałej o typie long Para znaków UL po liczbie wymusza utworzenie stałej o typie unsigned long Liczba zawierająca kropkę dziesiętną lub wartość w tzw. notacji naukowej traktowana jest jako double Podstawy programowania - Podstawy obliczeń w C++

Stałe liczbowe - przykłady 100 // int -23000U // unsigned int! 1L // long 5000000000 (5mld) // int64! 50UL // unsigned long 1.23234 // double 26. // double, 26.0 .5 // double, 0.5 -1.434e25 // double, -1.434*10^25 1e6 // double, 1 mln 5e-1 // double, 0.5 Podstawy programowania - Podstawy obliczeń w C++

Stałe ósemkowe i szesnastkowe Liczby całkowite można podawać, oprócz postaci dziesiętnej, również w kodzie ósemkowym lub szesnastkowym Stała całkowita rozpoczynająca się od 0 traktowana jest jako liczba ósemkowa, a od 0x jako szesnastkowa, np. 010 // 8 -077 // -63 0xff // 255 -0x10 // -16 Podstawy programowania - Podstawy obliczeń w C++

Podstawy programowania - Podstawy obliczeń w C++ Zmienne Jeżeli w programie zachodzi potrzeba zapamiętania pewnej wartości lub jej przetwarzania należy zarezerwować odpowiedni obszar w pamięci nadając mu nazwę oraz typ. Obszar taki wraz z nazwą i typem nazywa się zmienną. Zmienna zawsze zawiera wartość Składnia deklaracji (utworzenia) zmiennej: typ nazwa_zmiennej; typ nazwa_zmiennej1, nazwa_zmiennej2,...; Ograniczenia nazwy: litery wielkie i małe (bez polskich znaków), cyfry oraz znak ‘_’, nie może zaczynać się od cyfry, zwykle max. 32 znaki Przykłady: int x; unsigned long _Bardzo_Dluga_Nazwa_Zmiennej; float Pole_Kola1, Pole_Kola2; Podstawy programowania - Podstawy obliczeń w C++

Korzystanie ze zmiennej Zapamiętanie wartości w zmiennej odbywa się dzięki operatorowi przypisania = Składnia: zmienna = wartość; Od chwili utworzenia zmiennej użycie jej nazwy (za wyjątkiem lewej strony przypisania) oznacza odczyt wartości w niej zapisanej Przykłady int x,y; // utworzenie zmiennych x=25; // przypisanie wartości zmiennej x y=x; // odczyt wartości ze zmiennej x // i przypisanie tej wartości zmiennej y Podstawy programowania - Podstawy obliczeń w C++

Inicjalizacja zmiennej Jeżeli chcemy nadać zmiennej pewną wartość początkową, możemy dokonać zwykłego przypisania po jej utworzeniu, np.: int x; x=5; Możliwe jest jednak połączenie obu czynności czyli nadanie wartości zmiennej już w chwili tworzenia - inicjalizacja, np.: int x=5; float f, d=0.5; long a1=100L, a2, a3=5; Powoduje to skrócenie zapisu, a w niektórych przypadkach może być jedyną szansą nadania wartości zmiennej (np. zmienne typu const) Podstawy programowania - Podstawy obliczeń w C++

Podstawy programowania - Podstawy obliczeń w C++ Wyrażenia Wyrażenie to ciąg symboli, któremu w danej chwili działania programu można przypisać konkretną wartość określonego typu Do budowy wyrażeń używa się operatorów oraz m.in. stałych i zmiennych odgrywających rolę operandów Przykłady wyrażeń: 1 x // wyrażenia bez operatora -a 2*x+(a-1) // działania arytmetyczne a>1 a==x+1 // relacje x &&(a>1) // działania logiczne Podstawy programowania - Podstawy obliczeń w C++

Podstawy programowania - Podstawy obliczeń w C++ Operatory Operator to symbol oznaczający wykonanie pewnego działania. Obiektem działania jest symbol lub symbole sąsiadujące z operatorem, zwane operandami. Operatory arytmetyczne jednoargumentowe: + - Przykłady: -a +b // ‘+’ nie daje efektu Operatory arytmetyczne dwuargumentowe: + - * / % (tylko całkowite) Przykłady: a+b x-y 2*p rok/12.0 // dzielenie „arytmetyczne” 10/3 10%3 // dzielenie całkowite i reszta Podstawy programowania - Podstawy obliczeń w C++

Typ wyniku działań arytmetycznych Jeżeli operandy działań arytmetycznych są całkowite , wynik jest typu int, chyba że jeden z operandów był typu long Jeżeli chociaż jeden z operandów był zmiennoprzecinkowy, wynik jest zmiennoprzecinkowy (takiego typu jak ten operand) Jeżeli zakres wartości typów operandów jest różny, wynik posiada typ o zakresie odpowiadającym większemu z zakresów operandów Przykłady: short x; float f; x+2 // short + int = int 10+2.5 // int + double = double f + 10.0 // float + double = double f + 1 // float + int = float 2 * 1L // int + long = long Podstawy programowania - Podstawy obliczeń w C++

Podstawy programowania - Podstawy obliczeń w C++ Operator konwersji Opisane wyżej sytuacje dotyczą tzw. konwersji niejawnych czyli zmian typu niezależnych od programisty Możliwa jest również zmiana typu poprzez konwersję jawną (tzw. rzutowanie) za pomocą operatora () Składnia: (typ) wyrażenie Przykłady: short x=1; float f; f= x / 5; // 0 dzielenie całkowite f= (float) x / 5; // 0.2, dzielenie zwykłe x= f * 5; // 0.2 * 5 = 1.0 x= (int) f * 5; // 0 * 5 = 0 x= 2* (int)(1.0/10+1);// 2*(int) 1.1 = 2*1=2 Podstawy programowania - Podstawy obliczeń w C++

Podstawy programowania - Podstawy obliczeń w C++ Operatory relacji Operatory relacji: > (większe) < (mniejsze) >= (większe lub równe) <= (mniejsze lub równe) oraz porównania: == (równe) != (różne) Są to operatory dwuargumentowe generujące wartość typu int równą 1 (prawda) lub 0 (fałsz) w zależności od prawdziwości relacji dla podanych operandów Przykłady: 1==0 // 0 2>=2 // 1 2<1 // 0 0!=0 // 0 x+1 > 2*y-5 // wynik zależy od zmiennych // dla x=5 i y=2: 0 Podstawy programowania - Podstawy obliczeń w C++

Podstawy programowania - Podstawy obliczeń w C++ Operatory logiczne Operatory logiczne: ! (negacja/not) && (i/and) || (lub/or) Negacja jest jednoargumentowa, pozostałe są dwuargumentowe. Wykonują działania logiczne przy założeniu, że wartość operandu równa jest: 1 (prawda) jeżeli jest on różny od zera 0 (fałsz) jeżeli jest on równy zero x y !x x && y x || y 1 Podstawy programowania - Podstawy obliczeń w C++

Podstawy programowania - Podstawy obliczeń w C++ Operatory bitowe Operatory bitowe: ~ (negacja/not) & (i/and) | (lub/or) ^ (xor) Działanie jest bardzo podobne do działania operatorów logicznych, jednak w tym przypadku działania wykonywane są na każdej z odpowiadających sobie par bitów. x y ~x x & y x | y x ^ y 1 Podstawy programowania - Podstawy obliczeń w C++

Operatory logiczne i bitowe Przykład: 10 && 25 // 1(nie-zero) && 25(nie-zero) = 1 10 & 25 // 00000000000000000000000000001010 // & 00000000000000000000000000011001 //------------------------------------ // = 00000000000000000000000000001000 // = 16 Podstawy programowania - Podstawy obliczeń w C++

Operatory przesunięć bitowych >> (przesunięcie bitowe w prawo) << (przesunięcie bitowe w lewo) powodują przesunięcie wszystkich bitów lewego operandu o liczbę miejsc określoną przez prawy operand. Oba operandy muszą być całkowite. Wypadające bity giną, a wchodzące przyjmują wartość 0 (Przy operatorze >> dla wartości ujemnych, z lewej strony wchodzą 1 - powielenie bitu znaku) Efekt działania operatora >> jest zbliżony do podzielenia liczby przez 2, a operatora << do pomnożenia. Przykłady: 50 << 1 // 50(32b): 00000000000000000000000000110010 // 100 : 00000000000000000000000001100100 -50 >> 2 // -50: 11111111111111111111111111001110 // -12: 11111111111111111111111111110011 Podstawy programowania - Podstawy obliczeń w C++

Operatory działań z przypisaniem Operator += (operator zwiększenia) Zapis: x += 5; oznacza: x = x + 5; Zaletą tego podejścia jest skrócenie zapisu oraz przyspieszenie działania tej operacji (wygenerowany kod maszynowy jest krótszy). Nieco obniża się czytelność tych operacji. Analogiczne operatory to: -= *= /= %= &= |= ^= <<= >>= Przykład: int x=5; x+=10; // x=x+10; 15 x/=2; // x=x/2; 7 (dzielenie całkowite) x%=5; // x=x%7; 2 (reszta z dzielenia) x>>=1; // x=x>>2; 1 Podstawy programowania - Podstawy obliczeń w C++

Wartość operacji przypisania Wartość operacji przypisania równa jest przypisywanej wartości, np. wyrażenie a=5+5 ma wartość 10. Operacja przypisania może być więc użyta w wyrażeniach, np.: zapis: y = 3+ (a=10); // nawias konieczny oznacza: a = 10; y = 3+a; // czyli 13 Powoduje to skrócenie zapisu oraz przyspieszenie działania tych operacji kosztem spadku czytelności Analogicznie działają operatory: -= *= /= %= &= |= ^= <<= >>= Przykłady: int x, y; y= 1+ (x=4); // x=4, y=1+4=5; y= 2* (x+=11); // x=15, y=2*15=30; y+= 5+(x/=3); // x=5, y=y+5+5=40 y= (x*=2) + (x+=3); // wartości niepewne (kolejność)! Podstawy programowania - Podstawy obliczeń w C++

Inkrementacja i dekrementacja Inkrementacja to zmiana pewnej wartości na następną. W praktyce zwykle oznacza to jej zwiększenie o 1 Dekrementacja to operacja odwrotna (zmniejszenie o 1) W języku C i C++ operatory tych działań to: ++ i -- Zapis: ++x; lub x++; oznacza: x = x+1; --x; lub x--; oznacza: x = x-1; Preinkrementacja Predekrementacja: Postinkrementacja Postdekrementacja: Przykłady: int x, y=5; x= y++ +1; // x= 6; y=6; x= --y *10 // x=50; y=5 y = ++x x = x+1; y = x; y = --x; x = x-1; y = x; y = x++ y = x; x = x+1; y = x--; y = x; x = x-1; Podstawy programowania - Podstawy obliczeń w C++

Podstawy programowania - Podstawy obliczeń w C++ Operator warunkowy Wykorzystuje się go w sytuacji gdy chcemy przypisać zmiennej jedną z dwóch wartości w zależności od pewnego warunku. Jest to jedyny operator trzyargumentowy (warunek oraz dwie wartości alternatywne) Zapisywany jest za pomocą symboli: ? i : Składnia: (warunek) ? wartosc_gdy_niezero : wartosc_gdy_zero Warunek to dowolne wyrażenie, istotne jest czy jego wartość wynosi zero czy nie. Nawias jest obowiązkowy. Przykłady: int x, y=5; x= (y>0) ? 1 : 0; // x=1, y=5 y= (x--) ? 100 : 0; // x=0, y=100 y= 25 + ((x<5) ? 25 : 10)); // x=0, y=25+25=50 Podstawy programowania - Podstawy obliczeń w C++

Podstawy programowania - Podstawy obliczeń w C++ Operator , Umożliwia on podanie kilku wyrażeń w sytuacji, gdy oczekiwane jest tylko jedno, np. x= (1, b=2); Wartość całego wyrażenia w nawiasie równa jest wartości najbardziej prawego z wyrażeń oddzielonych przecinkami: 2 Wartości wyrażeń wyliczane są w kolejności od lewej do prawej Przykłady: int x, y; x= (y=1, y+5); // x=6, y=1 y= (1,2,3,4,5); // y=5 x+= (++x, y++); // x=12, y=6 Podstawy programowania - Podstawy obliczeń w C++

Podstawy programowania - Podstawy obliczeń w C++ Operator sizeof Operator ten pozwala uzyskać liczbę bajtów konieczną do zapisania podanej wartości lub podanego typu Składnia: sizeof(wyrażenie) sizeof(nazwa typu) Przykłady: int x,y; x= sizeof (int); // zwykle 4 x= sizeof(10.0/3); // sizeof(double), zwykle 8 x= sizeof(y)*8; /// liczba bitów dla int: 32 Podstawy programowania - Podstawy obliczeń w C++

Priorytety operatorów Kolejność interpretowania operatorów nie jest dowolna, regulują ją tzw. priorytety Na przykład w wyrażeniu: x + 5 * a pierwsze zostanie wykonane mnożenie (ma wyższy priorytet), kolejność ta jest w tym wypadku podyktowana zasadami algebry Jeżeli oba działania dotyczące pewnego operandu mają jednakowy priorytet, kolejność ich wykonania zależy od kompilatora, zazwyczaj od lewej do prawej Zmianę kolejności można wymusić za pomocą nawiasów ( ) Podstawy programowania - Podstawy obliczeń w C++

Priorytety poznanych operatorów 1 ( ) nawiasy 2 ++ -- postfix 3 ++ -- ~ ! sizeof + - prefix oraz jednoargumentowe 4 (typ) konwersja 5 * / % multiplikatywne 6 + - addytywne 7 << >> przesunięcie bitowe 8 < > <= >= relacje 9 == != porównanie 10 & bitowe and 11 ^ bitowe xor 12 | bitowe or 13 && logiczne and 14 || logiczne or 15 ? : warunkowy 16 = *= /= %= += -= >>= <<= &= ^= |= przypisanie 17 , przecinek Podstawy programowania - Podstawy obliczeń w C++