Zmienne i Typy

1. Zmienne i Typy

2. Deklaracje zmiennych • Każda nazwa w C++ zanim zostanie użyta, musi zostać zadeklarowana. • Deklaracja informuje kompilator, że dana nazwa reprezentuje obiekt określonego typu, ale nie rezerwuje dla niego miejsca w pamięci. • Definicja zaś - dodatkowo rezerwuje miejsce. Definicja jest miejscem, gdzie powołuje się obiekt do życia. • Oczywiście, definicja jest zawsze również deklaracją. Deklarować obiekt w programie można wielokrotnie, natomiast definiować można tylko raz.

3. Przykład: int licznik; // definicja + deklaracja extern int licznik; // deklaracja ( tylko!)

4. Systematyka typów w C++ • Typy języka C++ można podzielić dwojako: • Pierwszy podział: • typy fundamentalne; • typy pochodne, które powstają na bazie typów fundamentalnych. • Drugi podział : • typy wbudowane,czyli takie, w które język C++ jest wyposażony; • typy zdefiniowane przez użytkownika.

5. Typy fundamentalne: • Typy reprezentujące liczby całkowite: • short int • int • long int • Typ reprezentujący obiekty zadeklarowane jako znaki alfanumeryczne: • char

6. Wymienione typy mogą być w dwóch wariantach - ze znakiem i bez znaku. Do wybrania wariantu posługujemy się odpowiednio modyfikatorami: • signed • unsigned • Przykłady: • signed int x; • unsigned int x; Przez domniemanie przyjmuje się, że zapis int a; oznacza typ signed int a, czyli typ ze znakiem.

7. Typy reprezentujące liczby zmiennoprzecinkowe: • float • double • long double • Typy te umożliwiają pracę na liczbach rzeczywistych z różną dokładnością.

8. Pamięć zajmowana przez zmienne różnych typów: typaplikacje 32-bitowe char1 bajt short 2 bajty int 4 bajty long int 4 bajty float 4 bajty double 8 bajtów long double 10 bajtów bool 1 bajt

9. Zakres wartości różnych typów danych: typaplikacje 32-bitowe unsigned char 0 do 255 short-32768do32767 int-2147483648do2147483647 long int-2147483648do2147483647 float1.210-38do3.4  1038 double2.210-308do1.8  10308 long double3.410-4932do1.1  104932 booltruelubfalse

10. Wewnętrzne reprezentacje danych: int 15 15 0 0 long int 31 31 0 0 short int int long int 16-bitowe całkowite 32-bitowe całkowite

11. Wewnętrzne reprezentacje danych: float 31 22 0 double 63 51 0 long double 79 64 0 - wykładnik - znak liczby - mantysa - znak wykładnika Typy zmienoprzecinkowe

12. Wewnętrzne reprezentacje danych: float 31 22 0 double 63 51 0 long double 79 64 0 - wykładnik - znak liczby - mantysa - znak wykładnika Typy zmienoprzecinkowe 1e35 + 2 2  0. 34(0) 2e35; 34*3b = 102 b 1e35 + 1e15 1e15  0. 19(0)1e35; 19*3b = 57 b

13. #include <iostream.h> #include <conio.h> int main() { float x; clrscr(); x = 0; x = x + 0.1; x = x + 0.1; x = x + 0.1; x = x - 0.1; x = x - 0.1; x = x - 0.1; cout << "x = " << x << endl; getch(); return 0; } 0.1 – long double (80 bitów) x – float (32 bity) Koprocesor wykonuje obliczenia na 80 bitach 0.110 = 0001100110011...2

14. Definiowanie obiektów “w biegu” • #include <iostream.h> • int main () • { • float x; • //… • cout <<Podaj współczynnik kierunku; • float a; • cin >> a; • cout <<Podaj współczynnik przesunięcia; • float b; • cin >> b; • //… dalsze obliczenia • }

15. Stałe dosłowne W programach często posługujemy się stałymi. Mogą to być liczby, znaki albo ciągi znaków. Przykłady: • x = 12.34; • k = k + 14; • znak =  * ; • ciag_znakow =  język C++;

16. Stałe będące liczbami całkowitymi 17 39 - 54 Liczby całkowite ósemkowe: 010 - 8 w systemie dziesiętnym 014 - 12 w systemie dziesiętnym (8 + 4 = 12) 091 - błąd, bo w systemie ósemkowym liczba 9jest nielegalna. Liczby całkowite szesnastkowe: • 0x10 - 16 w systemie dziesiętnym (1*16 + 0 = 16) • 0xa1 - 161 w systemie dziesiętnym (10*16 + 1 = 161) • 0xff - 255 w systemie dziesiętnym (15*16 + 15 = 255)

17. Znaki a, b, c, d, e, f w liczbach oznaczają odpowiednio 10, 11, 12, 13, 14, 15 w systemie dziesiętnym. • W zapisie można posługiwać się zarówno małymi literami, jak i wielkimi. • Stałe całkowite traktuje się jako typ int, chyba że reprezentują tak wielkie liczby, które nie zmieściłyby się w int. Wówczas stała taka jest typu long. • Można zmienić typ nawet niewielkiej liczby z typu int na typ long. Robi się to przez dopisanie na końcu liczby litery L lub l: • 0L 123L • Jeśli chcemy by liczba miała typ unsigned, należy dopisać na końcu literę u. • Przykłady: • 213u 34uL

18. main () { int i; int k, n, m, j; clrscr (); i = 5; k = i + 010; cout << "k= " << k <<endl; m = 100; n = 0x100; j = 0100; cout << "m+n+j= " << (m+n+j) <<endl; cout << "wypisujemy: " << 0x22 << " " << 022 << " " << 22 <<endl; return 0; } k =13 m+n+j =420 wypisujemy:34 18 22

19. Stałe zmiennoprzecinkowe • Przykłady: • 12.33.1416 -123.45 -17. • 5e2 oznacza 5 * 102, czyli 500 • 32.5e4 oznacza 32.5 * 104, czyli 325000 • 7.3e-3 oznacza 7.3 * 10-3, czyli 0.0073 Stałe znakowe • a oznacza literę a • 8 oznacza cyfrę 8 (nie liczbę8) • char znak; • znak = ‘A’;

20. Znaki sterujące: • ‘\b’ - cofacz (ang. Backspace) • ‘\f’ - nowa strona (ang. Form feed) • ‘\n’ - nowa linia (ang. New line) • ‘\r’ - powrót karetki (ang. carriage Return) • ‘\t’ - tabulator poziomy (ang. Tabulator) • ‘\v’ - tabulator pionowy (ang. Vertical tabulator) • ‘\a’ - sygnał dźwiękowy (Alarm) Znaki specjalne: • ‘\\’ - ukośnik lewostronny • ‘\’’ - apostrof • ‘\’ - cudzysłów • ‘\0’ - NULL, znak o kodzie 0 • ‘\?’ - znak zapytania

21. Stałe tekstowe Stała tekstowa to ciąg znaków ujęty w cudzysłów • Przykłady: • Programowanie komputerów • język C++ • Łańcuchy są przechowywane w pamięci jako ciąg znaków, a na samym końcu tego ciągu dodawany jest znak o kodzie 0, czyli znak NULL. • Jeżeli cudzysłów ma stanowić jeden ze znaków ciągu, należy go poprzedzić ukośnikiem.

22. Przykładowo: cout <<Polecam książkę J.Grębosza  <<  \ Symfonia C++\; Polecam książkę J.Grębosza Symfonia C++

23. Typy pochodne • Typy pochodne są budowane na bazie typów fundamentalnych. • Przykładem typu pochodnego może być tablica lub wskaźnik. • Możemy mieć kilka luźnych obiektów typu int, ale możemy je powiązać w tablicę obiektów typuint. • Tablica obiektów typu int jest typem pochodnym od typu int. • Typy pochodne oznacza się stosując nazwę typupodstawowego i operator deklaracji typu pochodnego.

24. Przykład: • int a; // obiekt typu int • int b[10]; // tablica obiektów typu int (10-elementowa) Operatory tworzące obiekty typów pochodnych: • [ ] - tablica obiektów danego typu; • * - wskaźnik do pokazywania na obiekty danego typu; • ( ) - funkcja zwracająca wartość danego typu; • & - referencja (przezwisko) obiektu danego typu.

25. Przykład: Typy fundamentalne: • int b; // definicja obiektu typu int • short int c; // definicja obiektu typu short • float x; // definicja obiektu typu float Typy pochodne: • int t[20]; // tablica 20 elementów typu int • float *p; // wskaźnik obiektu typu float • char funk(); // funkcja zwracająca wartość typu char

26. Typvoid • void *p; - oznacza, że p jest wskaźnikiem do wskazywania obiektu nieznanego typu. • void fun(); - deklaracja ta mówi, że funkcja fun nie będzie zwracać żadnej wartości.

27. Zakres ważności obiektu • Zakres ważności nazwy obiektu, to ta część programu, w której nazwa znana jest kompilatorowi. • Czas życia obiektu jest to okres od momentu, gdy zostaje on zdefiniowany do momentu, gdy przestaje istnieć, a jego miejsce w pamięci zostaje zwolnione. • Różnica między zakresem ważności nazwy a czasem życia obiektu jest taka, że w jakimś momencie obiekt może istnieć, ale nie być dostępny, ponieważ chwilowo znajdujemy się poza zakresem jego ważności. • W zależności od tego, jak zdefiniowany jest obiekt, zakres jego ważności może być różnego rodzaju.

28. Zakres lokalny • #include <iostream.h> • int main () • { • { • int x; • … • } • … • } Zakres - blok funkcji Zakres ważności ograniczony do bloku funkcji ma etykieta.

29. Zakres - obszar pliku Nazwa zadeklarowana na zewnątrz jakiegokolwiek bloku, jest nazwą globalną. Ma ona zakres ważności pliku. • Przykład: • float x; // nazwa x jest globalna • int main () • { • // treść funkcji • } Jednakże taka nazwa nie jest od razu automatycznie znana w innych plikach. Jej zakres ważności ogranicza się tylko do tego pliku, w którym ją zdefiniowano.

30. Zasłanianie nazw Jestem w pliku głównym, k =33 Po lokalnej definicji k =10 Poza blokiem k =33 • Przykład: • #include <iostream.h> • #include <conio.h> • int k =33; //zmienna globalna - PROG14.CPP • int main () • { • clrscr (); • cout << "Jestem w pliku głównym, k = " << k <<endl; • {//---------------------------------------------- • int k = 10; //zmienna lokalna • cout << "Po lokalnej definicji k = " << k <<endl; • }//---------------------------------------------- • cout << "Poza blokiem k = " << k <<endl; • return 0; • }

31. Istnieje możliwość odniesienia się do zasłoniętej zmiennej globalnej za pomocą operatora zakresu:: (dwa dwukropki). Jestem w pliku głównym, k =33 Po lokalnej definicji k =10 , ale obiekt globalny k =33 Poza blokiem k =33 • #include <iostream.h> • #include <conio.h> • int k =33; //zmienna globalna - PROG15.CPP • int main () • { • clrscr (); • cout << "Jestem w pliku głównym, k = " << k <<endl; • { //---------------------------------------------- • int k = 10; //zmienna lokalna • cout << "Po lokalnej definicji k = " << k << ", " <<endl • << "ale obiekt globalny k = " • << ::k; • }//---------------------------------------------- • cout <<"\nPoza blokiem k = " << k <<endl; • return 0; • }

32. Modyfikatorconst • float pi = 3.14; const float pi = 3.14; • Inicjowaniem nazywamy nadanie obiektowi wartości w momencie jego definicji. • Przypisaniem nazywamy podstawienie do obiektu wartości w jakimkolwiek późniejszym momencie. • Obiekty constmożna inicjować, ale nie można do nich nic przypisać.

33. Instrukcja typedef Instrukcja typedef pozwala na nadanie dodatkowej nazwy już istniejącemu typowi. • typedef int cena; • cena x; // co odpowiada: int x; • cena a, b, c; // co odpowiada: int a, b, c; Instrukcja typedef nie wprowadza nowego typu, a jedyniesynonim do typu już istniejącego.

34. Typ wyliczeniowyenum • Wyliczenie deklaruje się słowem kluczowym enum, po którym następuje wykaz stałych całkowitych oddzielonych przecinkiem i zamkniętych w nawiasy klamrowe. • Wymienionym stałym są przypisywane wartości domyślne: pierwszej z nich ‑ wartość 0, a każdej następnej - wartość o 1 większą od poprzedzającej. • enum { pn, wt, sr, czw, pt, sob, nd } • const pn = 0; • const wt = 1; • … • const nd = 6;

35. Stałym typu wyliczeniowego można również przypisywać wartości jawnie, przy czym wartości te mogą się powtarzać. • enum { poczatek, koniec = 0, dalej=1, cofnij = 1 }; W wyliczeniach można po enum umieścić identyfikator, który staje się od tego momentu nazwą nowego typu, np.: • enum dni_tygodnia {pn, wt, sr, czw, pt, sob, nd};

36. enum dni_tygodnia {pn, wt, sr, czw, pt, sob, nd}; • Typ wyliczeniowy jest podobny do typów char oraz int . • Nie można jednakże na jego wartościach wykonywać żadnych operacji arytmetycznych. • Gdy wartość typu wyliczeniowego pojawia się w wyrażeniach arytmetycznych, to jest niejawnie (ostrzeżenie) przekształcana do typu int przed wykonaniem operacji.