Upload
arty
View
56
Download
0
Embed Size (px)
DESCRIPTION
Zmienne i Typy. 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. - PowerPoint PPT Presentation
Citation preview
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.