Zmienne i TypyZmienne i Typy

Deklaracje zmiennychDeklaracje 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.

Przykład:

int licznik; // definicja + deklaracja

extern int licznik; // deklaracja ( tylko!)

Systematyka typów w C++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.

Typy fundamentalne:Typy fundamentalne:

Typy reprezentujące liczby całkowite:

short intintlong int

Typ reprezentujący obiekty zadeklarowane jako znaki alfanumeryczne:

char

Wymienione typy mogą być w dwóch wariantach - ze znakiem i bez znaku. Do wybrania wariantu posługujemy się odpowiednio modyfikatorami:

signedunsigned

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.

Typy reprezentujące liczby zmiennoprzecinkowe:

floatdoublelong double

Typy te umożliwiają pracę na liczbach rzeczywistych z różną dokładnością.

Pamięć zajmowana przez zmienne różnych typów:

typ aplikacje 32-bitowe

char 1 bajt short 2 bajtyint 4 bajtylong int 4 bajty

float 4 bajtydouble 8 bajtówlong double 10 bajtów

bool 1 bajt

Zakres wartości różnych typów danych:

typ aplikacje 32-bitowe

unsigned char 0 do 255

short -32768 do 32767int -2147483648 do 2147483647long int -2147483648 do 2147483647

float 1.210-38 do 3.4 1038

double 2.210-308 do 1.8 10308 long double 3.410-4932 do 1.1 104932

bool true lub false

Wewnętrzne reprezentacje danychWewnętrzne reprezentacje danych::

015

031

int

long int

16-bitowe całkowite

32-bitowe całkowite

015

short int

031

intlong int

Wewnętrzne reprezentacje danychWewnętrzne reprezentacje danych::

Typy zmienoprzecinkowe

031

float

22

long double

79 064

double

063 51

- znak wykładnika - wykładnik - znak liczby - mantysa

Wewnętrzne reprezentacje danychWewnętrzne reprezentacje danych::

Typy zmienoprzecinkowe

031

float

22

long double

79 064

double

063 51

- znak wykładnika - wykładnik - znak liczby - mantysa

1e35 + 2

2 0. 34(0) 2e35; 34*3b = 102 b

1e35 + 1e15

1e15 0. 19(0)1e35; 19*3b = 57 b

#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

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

}

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++ ;

Stałe będące liczbami całkowitymi

17 39 - 54

010 - 8 w systemie dziesiętnym014 - 12 w systemie dziesiętnym (8 + 4 = 12)091 - błąd, bo w systemie ósemkowym liczba 9 jest

nielegalna.

Liczby całkowite ósemkowe:

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)

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

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 = 13m+n+j = 420wypisujemy: 34 18 22

Stałe zmiennoprzecinkowe

Przykłady:

12.3 3.1416 -123.45 -17.5e2 oznacza 5 * 102, czyli 50032.5e4 oznacza 32.5 * 104, czyli 3250007.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’;

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

Stałe tekstowe

Stała tekstowa to ciąg znaków ujęty w cudzysłów

Przykłady:

Programowanie komputerówję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.

Przykładowo:

cout << Polecam książkę J.Grębosza << \ Symfonia C++\ ;

Polecam książkę J.Grębosza Symfonia C++

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 typu int.

Tablica obiektów typu int jest typem pochodnym od typu int.

Typy pochodne oznacza się stosując nazwę typu podstawowego i operator deklaracji typu pochodnego.

Przykład:

int a; // obiekt typu intint 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.

Przykład:

int b; // definicja obiektu typu intshort int c; // definicja obiektu typu shortfloat x; // definicja obiektu typu float

int t[20]; // tablica 20 elementów typu intfloat *p; // wskaźnik obiektu typu floatchar funk(); // funkcja zwracająca wartość typu char

Typy fundamentalne:

Typy pochodne:

Typ void

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.

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.

Zakres lokalny

#include <iostream.h>int main (){

{int x;…

}…

}

Zakres - blok funkcji

Zakres ważności ograniczony do bloku funkcji ma etykieta.

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 globalnaint 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.

Zasłanianie nazw

Przykład:

#include <iostream.h>#include <conio.h>int k =33; //zmienna globalna - PROG14.CPPint main (){ clrscr (); cout << "Jestem w pliku głównym, k = " << k << endl; { //----------------------------------------------

int k = 10; //zmienna lokalnacout << "Po lokalnej definicji k = " << k <<

endl; } //---------------------------------------------- cout << "Poza blokiem k = " << k << endl; return 0;}

Jestem w pliku głównym, k = 33

Po lokalnej definicji k = 10

Poza blokiem k = 33

Istnieje możliwość odniesienia się do zasłoniętej zmiennej globalnej za pomocą operatora zakresu :: (dwa dwukropki).

#include <iostream.h>#include <conio.h>int k =33; //zmienna globalna - PROG15.CPPint main (){ clrscr (); cout << "Jestem w pliku głównym, k = " << k << endl; { //----------------------------------------------

int k = 10; //zmienna lokalnacout << "Po lokalnej definicji k = " << k << ", " <<

endl << "ale obiekt globalny k = "

<< ::k; } //---------------------------------------------- cout << "\nPoza blokiem k = " << k << endl; return 0;}

Jestem w pliku głównym, k = 33

Po lokalnej definicji k = 10 ,

ale obiekt globalny k = 33

Poza blokiem k = 33

Modyfikator const

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 const można inicjować, ale nie można do nich nic przypisać.

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 jedynie synonim do typu już istniejącego.

Typ wyliczeniowy enum 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;

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};

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.