TYPY DANYCH,
[ Pobierz całość w formacie PDF ]TYPY DANYCH
Zmienne i stałe reprezentują w programie dane, które charakteryzują programowane zagadnienie z świata
rzeczywistego lub wirtualnego.
Przy deklaracji stałej i zmiennej należy podać jej typ, który określa jaki rodzaj danych, z jakiego zakresu, z jaką
precyzją będzie przechowywany w stałej lub zmiennej.
Podział typów danych:
1) Typy proste
1.1) Typy porządkowe
a) Typ wyliczeniowy
b) Typy całkowite
c) Typy logiczne
d) Typ znakowy
e) Typy okrojone
1.2) Typy rzeczywiste
2) Typy łańcuchowe
3) Typy strukturalne
3.1) Typy tablicowe
3.2) Typ rekordowy
3.3) Typ zbiorowy
3.4) Typ plikowy
4) Typy wskaźnikowe
5) Typy proceduralne
6) Typ obiektowy
1)----------------------------------------------------------------------------------------------------------------------------------------------
----Typy proste
Typy proste są podstawowymi typami języka Pascal i za ich pomocą określa się bardziej złożone struktury danych.
Wszystkie typy proste składają się ze skończonego i uporządkowanego zbioru wartości. Dzięki temu na wartościach
tych typów możemy m.in. wykonywać operacje porównań. Typy proste dzielimy na typy porządkowe i typy
rzeczywiste.
1.1)---------------------------------------------------------------------------------------------------------------------------------------
Typy porządkowe
Typami porządkowymi nazywamy wszystkie typy proste z wyjątkiem typów rzeczywistych. Wyróżnienie to jest
spowodowane faktem, że typy rzeczywiste często nie mogą występować w kontekście dozwolonym dla innych typów
prostych.
Dla wartości każdego typu porządkowego są określone wartości poprzednie i następne (z wyjątkiem wartości
krańcowych). Do typów porządkowych zaliczamy: typ wyliczeniowy, typy całkowite, logiczne, typ znakowy i typy
okrojone.
1.1.a)-----------------------------------------------------------------------------------------------------------------------------------Typy
wyliczeniowe
Typ wyliczeniowy stosuje się zwykle dla zbiorów o niewielkiej liczbie elementów, na których nie wykonuje się
operacji arytmetycznych. Definicja jednego typu wyliczeniowego jest następująca:
TYPE identyfikator_typu = (lista_identyfikatorów);
Elementy typu wyliczeniowego są uporządkowane zgodnie z kolejnością ich wyliczenia w definicji typu i posiadają
liczby porządkowe odpowiednio 0,1,2 itd.
Przykłady:
TYPE Uczniowie = (Antek,
Franek, Zenek);
{Antek ma 0, Franek ma 1, a
Zenek 2}
P_roku = (wiosna, lato, jesień,
zima);
1.1.b)---------------------------------------------------------------------------------------------------------------------------------------
Typy całkowite
Typy całkowite są w języku Pascal predefiniowane i nie wymagają opisu w programie. Wszystkie typy całkowite są
podzbiorami zbioru liczb całkowitych. Wśród typów całkowitych wyróżniamy:
Typy
całkowite
Typ
Zakres
Rozmiar w bajtach
Integer
-32768...32767
2
ShortInt
-128...127
1
LongInt -2147483648...2147483647
4
Byte
0...255
1
Word
0...65535
2
Przykład:
Przypuśćmy, że zdefiniowaliśmy nowy typ:
TYPE Liczba = Integer;
W takim razie poniższa deklaracja
VAR i,j: Liczba;
jest równoważna deklaracji
VAR i,j: Integer;
1.1.c)-----------------------------------------------------------------------------------------------------------------------------------------
-Typy logiczne
Standardowymi typami logicznymi są typy Boolean, ByteBool, WordBool i LongBool.
Wartości typów logicznych są oznaczone za pomocą dwu predefiniowanych literałów (stałych): True i False,
oznaczających odpowiednio wartości logiczne fałsz i prawda, przy czym w sensie uporządkowania stała False
poprzedza stałą True.
Liczbami porządkowymi elementów typu Boolean są tylko 0 (False) i 1 (True).
Elementy pozostałych typów logicznych mogą posiadać inne (wyższe) liczby porządkowe.
1.1.d)-----------------------------------------------------------------------------------------------------------------------------------------
-Typ znakowy
Do oznaczenia typu znakowego służy predefiniowany identyfikator Char.
Elementami typu znakowego są znaki ASCII, z których każdy jest pamiętany w jednym bajcie pamięci.
Przykład:
Deklaracja zmiennej znakowej:
Var literka: Char;
Zmiennej
literka
możemy przypisać literę 'A' na trzy różne sposoby:
literka:='A';
lub za pomocą kodu ASCII
literka:=chr(65);
literka:=#65;
1.1.e)-----------------------------------------------------------------------------------------------------------------------------------------
Typy okrojone
Typy okrojone służą do ograniczania zakresów wartości dowolnego z dotychczas opisanych typów porządkowych.
Definicja jednego typu okrojonego ma postać
TYPE identyfikator_typu = stała .. stała;
Pierwsza stała podaje ograniczenie dolne i nie może być większa od drugiej - ograniczenia górnego. Stałe te muszą być
tego samego typu porządkowego.
Typ okrojony ma pewne ograniczenia w porównaniu z typami porządkowymi. Nie można na nim stosować działań, ani
pobierać wartości z klawiatury lub wyświetlić ich na ekran.
Przykład:
TYPE Litery = 'A' .. 'Z';
1.2----------------------------------------------------------------------------------------------------------------------------------------
Typy rzeczywiste
Do typów prostych należą także standardowe typy rzeczywiste, które jednak nie są typami porządkowymi. Typ
porządkowy różni się od typu rzeczywistego tym, że do typu rzeczywistego należą liczby rzeczywiste i w konsekwencji
tego, komputer nie może odnaleźć wartości mniejszej lub większej tego typu. Ma to znaczenie w instrukcji "for" i
tablicach. Każdy z dostępnych typów rzeczywistych jest dyskretnym i skończonym podzbiorem zbioru liczb
rzeczywistych. Dostępnych jest pięć standardowych typów rzeczywistych o następujących predefiniowanych
identyfikatorach:
Typy rzeczywiste
Typ
Zakres
Liczba cyfr znaczących
Rozmiar w bajtach
Real
2.9e-39...1.7e+38
11-12
6
Single
1.5e-45...3.4e+38
7-8
4
Double
5.0e-324...1.7e+308
15-16
8
Extended
1.9e-4951...1.1e+4932
19-20
10
Comp
-2
63
+1 ... 2
63
-1
19-20
8
2)------------------------------------------------------------------------------------------------------------------------------------------
Typy łańcuchowe
Typy łańcuchowe (tekstowe) służą do reprezentowania ciągu znaków, w tym niewidocznego znaku spacji.
Elementami typu łańcuchowego są łańcuchy o długości od 0 do długości podanej w definicji typu łańcuchowego.
Typ ten definiuje się następująco:
TYPE identyfikator_typu = String[rozmiar];
lub
TYPE identyfikator_typu = String;
gdzie rozmiar jest liczbą typu Byte. Brak wyspecyfikowania rozmiaru powoduje domyślne przyjęcie długości 255
znaków (wartość maksymalna).
Przykład:
TYPE Nazwisko = String[20];
tekst:='Kowalski'
3)-------------------------------------------------------------------------------------------------------------------------------------------
Typy strukturalne
Typy strukturalne stosuje się do opisu obiektów złożonych, przy czym dany obiekt możemy opisać na kilka różnych
sposobów. Każdy z typów strukturalnych definiowany jest przez podanie typów składowych i metody strukturalizacji,
która zarazem określa sposób dostępu do elementów składowych. W ogólności definicja pojedynczego typu
strukturalnego ma postać:
TYPE Identyikator_typu = Opis_typu_strukturalnego;
przy czym opis typu strukturalnego może być opisem typu tablicowego, rekordowego, zbiorowego lub plikowego.
3.1)-------------------------------------------------------------------------------------------------------------------------------------------
-Typ tablicowy
Typ tablicowy, a konkretnie tablica składa się z ustalonej liczby elementów tego samego typu, zwanego typem
składowym, który może być zarówno typem prostym lub łańcuchowym, jak i typem strukturalnym. Za pomocą tablic są
reprezentowane regularne układy danych, np. wektory i macierze. Dostęp do poszczególnych elementów tablic
uzyskuje się za pomocą indeksowania. Indeksem może być dowolne wyrażenie, którego wartość jest zgodna w sensie
przypisania z typem indeksowym. Dopuszczalny zakres indeksów jest podany w definicji typu tablicowego. Definicja
pojedynczego typu tablicowego ma postać:
TYPE Identyfikator_typu = array[typy_indeksowe] of typ_składowy;
gdzie typy indeksowe są opisami typu porządkowego (z wyjątkiem typu LongInt), przy czym poszczególne opisy
oddziela się przecinkami. Typ składowy oznacza dowolny typ.
Przykłady:
TYPE Macierz = array[1..20,1..30] of Real;
Tablica = array[Boolean,1..20,znak] of Char;
Istnieje sposób, aby tablice wypełnić jako stałą w sekcji const:
CONST
Tablica : array[0..2] of Char =
('Adam', 'Marta', 'Magda');
3.2)-------------------------------------------------------------------------------------------------------------------------------------------
Typ rekordowy
Typem rekordowym, a dokładniej rekordem nazywamy złożoną strukturę danych, której składowe, zwane polami,
mogą mieć różne charakterystyki (należeć do różnych typów). Poszczególne pola mogą być same strukturami
złożonymi, przy czym liczba pól rekordu jest ustalona. Definicja typu rekordowego określa typ i identyfikator dla
każdego pola. Definicja ta rozpoczyna się słowem kluczowym record, po którym podaje się deklarację każdego pola, a
kończy słowem kluczowym end. Poszczególne deklaracje pól oddziela się średnikami. Ostatnia deklaracja może być
wariantowa (case .. of). Definicja pojedynczego typu rekordowego ma postać:
TYPE Identyfikator_typu = record
Lista_deklaracji_pól
end;
gdzie każda z deklaracji pól ma postać:
lista_nazw_pól : opis_typu;
a ostatnia deklaracja może mieć postać (deklaracja wariantowa):
case deklaracja_pola_wyróżnikowego of wykaz_wariantów;
lub
case identyfikator_typu_porządkowego of wykaz_wariantów;
przy czym deklaracja pola wyróżnikowego wygląda następująco:
i
dentyfikator_pola_wyróżnikowego :
identyfikator_typu_porządkowego;
lub
lista_etykiet_wyboru : (lista_deklaracji_pól);
Przykłady rekordów:
TYPE Data = record
rok : Integer;
miesiac : 1 .. 12;
dzien : 1 .. 31;
end;
TYPE Rejestry = record
case Integer of
1: (AX, BX, CX, DX : Word);
2: (AL, AH, BL, BH, CL, CH,
DL, DH : Byte);
end;
end;
3.3)-------------------------------------------------------------------------------------------------------------------------------------------
--Typ zbiorowy
Typ zbiorowy jest zbiorem potęgowym danego typu porządkowego, tzn. jest zbiorem wszystkich podzbiorów tego
typu, w tym zbioru pustego. Liczba elementów typu zbiorowego nie może przekraczać 256 (przedział od 0 do 255).
Definicja pojedynczego typu zbiorowego ma postać:
TYPE Identyfikator_typu = set of typy_porządkowy;
Przykład:
TYPE Klasy = set of (LO_1d, LO_2d, LO_3d,LO_4d);
elementami typu Klasy może być dowolny podzbiór zbioru podanych nazw klas, m.in :
[ LO_1d, LO_2d ] - podzbiór dwuelementowy
[ LO_3d ] - podzbiór jednoelementowy
[ ] - zbiór pusty
[ LO_1d, LO_2d, LO_3d, LO_4d ] - podzbiór czteroelementowy
3.4)-------------------------------------------------------------------------------------------------------------------------------------------
--Typy plikowe
Typy plikowe są ściśle powiązane z plikami. Plik jest ciągiem elementów tego samego typu, tyle że liczba jego
składowych jest zmienna. Jest ona uzależniona od przebiegu wykonywania programu, a w szczególności od skojarzenia
pliku z fizycznym zbiorem danych. Od tablicy plik różni się ponadto metodą dostępu do poszczególnych elementów.
Definicja pojedynczego typu plikowego ma postać:
TYPE Identyfikator_typu = file of opis_typu_elementów_pliku;
lub
TYPE Identyfikator_typu = file;
Jeżeli w definicji typu plikowego pominięto słowo kluczowe of i opis typu jego elementów, to przyjmuje się, że dany
typ plikowy jest niezdefiniowany. Niezdefiniowane pliki są stosowane głównie w celu dostępu do fizycznych zbiorów
dyskowych zgodnie z ich wewnętrznym formatem. W Pascalu istnieje predefiniowany plik tekstowy o nazwie Text
(standardowy typ plikowy).
Przykłady:
TYPE Dane = file of Integer;
Zbior = file;
Wyniki = Text;
4)--------------------------------------------------------------------------------------------------------------------------------------Typy
wskaźnikowe
Typy wskaźnikowe. Zmienne dotychczas omówionych typów, tj. typów prostych i strukturalnych, charakteryzują się
tym, że istnieją przez cały czas wykonywania tej części, w której są zadeklarowane. Są to tzw. zmienne statyczne.
W języku Pascal występują też zmienne dynamiczne reprezentujące obiekty, dla których pamięć jest przydzielana i
zwalniana na określone żądanie. Zmienne te nie posiadają identyfikatorów, a odwołanie do nich następuje za pomocą
wskaźnika. Wartościami wskaźników są elementy typu wskaźnikowego, które określają adresy pamięci zmiennych
dynamicznych. Zastosowanie w programie zmiennych dynamicznych pociąga za sobą konieczność zdefiniowania
odpowiednich typów wskaźnikowych. Definicja pojedynczego typu wskaźnikowego ma postać:
TYPE Identyfikator_typu = ^Identyfikator_typu_bazowego;
Poprzyjmy to przykładem:
TYPE wskaznik = ^zapis;
zapis = record
Tekst: String[80];
Liczba: Integer;
end;
Definicja ta wiąże typ wskaźnik ze zbiorem wskazań danych typu zapis. Jeśli wprowadzimy teraz deklarację:
VAR adres : wskaznik;
to zmiennej wskaźnikowej adres będą mogły być w programie przypisywane adresy pamięci danych typu zapis.
W Pascalu występują dwa predefiniowane typy wskaźnikowe są to typy Pointer (zmienne tego typu są zgodne z
dowolnym innym typem wskaźnikowym) i PChar (reprezentuje wskaźnik do łańcuchów zakończonych znakiem
pustym).
Jednym ze słów kluczowych jest słowo nil, które oznacza stałą typu wskaźnikowego nie określającą żadnego adresu
(nil wskazuje na adres pusty)
5)-------------------------------------------------------------------------------------------------------------------------------------------
Typ proceduralny
Procedury i funkcje mogą być traktowane nie tylko jako części programu wykonywane na skutek wywołania, ale
także jako elementy, które mogą być przypisywane do zmiennych i przekazywane do innych funkcji lub procedur jako
parametry. Zmienne tego rodzaju powinny być typu proceduralnego Definicja pojedynczego typu proceduralnego może
mieć jedną z następujących postaci:
TYPE Nazwa = procedure;
lub
TYPE Nazwa = procedure(lista_parametrów);
lub
TYPE Nazwa = function: typ_wartości_funkcji;
lub
TYPE Nazwa = function(lista_parametrów):
typ_wartości_funkcji;
Przykłady:
[ Pobierz całość w formacie PDF ]