# Adattípus

### A Wikipédiából, a szabad lexikonból.

Az informatikában az adattípus (gyakran röviden típus) az értékek egy halmazához rendelt név vagy címke és ezen halmaz értékein végrehajtható néhány művelet.

A programnyelvek explicit vagy implicit módon támogatják az adattípusok használatát, amelyeket a nyelv statikusan vagy dinamikusan ellenőrzött típus kényszerítés, ezzel biztosítja, hogy érvényes, helyes programokat hozzon létre az adott nyelv.

## [szerkesztés] Alapok

A jelentés nélküli bitek csoportjához szemantikai jelentéssel bíró típus hozzárendelése a célja a típus meghatározásnak. Típust gyakran vagy a memória területhez vagy egy objektumhoz illetve változóhoz rendelnek, önmagában a számítógép hardver nem tesz különbséget memóriacím, utasítás kód, karakter, integer vagy lebegőpontos szám között.

A típusok arról adnak információt a programnak és a programozónak, hogyan kell kezelni az adott bitek csoportját.

A típusok használata leginkább a következő területeken biztosít előnyt:

- Biztonság - A típusok használata biztosítja a fordítóprogramnak, hogy felismerhessen értelmetlen vagy feltehetőleg érvénytelen kifejezéseket. Például, a `"Hello, World" / 3` kifejezést érvénytelennek kell tekinteni, mivel az osztás művelete (általánosan elfogadottan) nem értelmezhető egy string és egy egész között.

- Optimalizálás - A statikus típus ellenőrzés a fordítóprogram számára hasznos információkat biztosít arra vonatkozóan, hogy milyen utasítás kód alkalmazásával lehet hatékony programot előállítani. Egy elem típusából meghatározható például az adott elem helyfoglalási igénye.

- Dokumentálás - A típusok használatával a program dokumentációja egyértelműbbé és érthetőbbé válik. Például ha létrehozunk egy időbélyeg típust, és egy eljárás eredményeként keletkező egész számhoz hozzá is rendeljük ezt a típust, akkor egyértelmű a továbbiakban a dokumentáció olvasója számára, hogy a keletkezett egészet a program a továbbiakban időbélyegnek használja. A típus így járulékos információt szolgáltat, az olvasónak egyértelművé válik az eljárás célja és eredményének további használata.

- Absztrakció (vagy modularitás) - A típusok használatával a programozó lehetőséget kap arra, hogy magasabb szinten gondolkodjon a programról, ne az alacsony szintű megvalósítási kérdések legyenek a meghatározók.

## [szerkesztés] Típus ellenőrzés

Az eljárás, ami vagy fordítási időben (statikus ellenőrzés) vagy végrehajtási időben (dinamikus ellenőrzés) ellenőrzi típuskényszerítés szabályait, és szükség esetén végrehajtja a előírt művelet(ek)et.

A statikus ellenőrzés elsődlegesen a fordítóprogram feladata. Ha a nyelv kikényszeríti a típushoz tartózó szabályok végrehajtását (ez általában a típuskonverziók végrehajtását jelenti, lehetőleg információ vesztés nélkül), akkor a nyelv erősen típusos, ellenkező esetben gyengén típusos.

## [szerkesztés] Statikus és dinamikus típusok

A dinamikus típus hozzárendelés és ellenőrzés szinte minden esetben a futásidőben történik, mivel az egyes változókhoz ekkor rendelődik hozzá az aktuális típusuk (program végrehajtási ideje). A statikus típus rendszer dinamikus használata általában szükségessé teszi egy olyan rendszer kidolgozást, ami a futási időben képes arra, hogy a kövesse az időben esetleg változó típushozzárendelések változásait. Ez az igény egyrészt triviálisnak, de ugyanakkor a helyes működés biztosítása miatt nehézkes is tűnik.

C, C++, Java, ML, és a Haskell statikus típus kezelést és ellenőrzést használják, míg a Objective-C, Scheme, Lisp, Smalltalk, Perl, PHP, Visual Basic, Ruby, és a Python dinamikus kezelést és típusellenőrzés valósítják meg. A trend azt mutatja, hogy a típus kezelést a fordított nyelvekben használják.

Kacsa típusosság egy humoros meghatározása az úgynevezett scripting nyelveknél használatos dinamikus típus kezlésének, amelyek bizonyos esetekben feltételezésekkel élnek a típusokra:" (értékre hivatkozás esetén) ha valami úgy megy, mint egy kacsa és úgy hápog, mint egy kacsa, akkor az kacsa". A mondás Dave Thomas-tól ered, aki a Ruby nyelvet használok közösségének tagja.

A típusellenőrzés megértéséhez vegyük a következő pszeudokód példát:

     var x;        // (1)
     x := 5;       // (2)
     x := "hi";    // (3)

A példában, (1) deklaráljuk az x nevet; (2) hozzárendeljük az 5 egész értéket az x névhez; majd (3) hozzárendeljük a "hi"string értéket az x névhez. A legtöbb statikus típus kezelést használó rendszerben a fenti kód töredék érvénytelen, mivel (2) és (3) esetben az x-hez összeférhetetlen típusokat próbálunk kapcsolni. A nem megfelelő típusok használat jelző hiba a fordítás alatt megjelenik, nem generálódik futtatható program.

Kontrasztként, egy egyszerű dinamikus típus kezelő rendszer megengedi a program futtatását, mivel az x névvel azonosított hely minden típusa összefér. A megvalósított dinamikus típus kezelő rendszertől függ, hogy hibajelzést ad - "típus hiba" - vagy esetleg hibás kifejezést generál. A lényeg, hogy az esetleges hibajelzés a program futása közben generálódik. Egy tipikus dinamikus típus kezelő rendszer megvalósítása estében a program egy "jelzőt" rendel minden értékhez, ahol a jelző az aktuális típust mutatja, és egy művelet végrehajtása előtt ellenőrzésre is kerül.

Például:

     var x = 5;     // (1)
     var y = "hi";  // (2)
     var z = x + y; // (3)

Ebben a kódtöredékben, (1) az 5 értéket rendeljük az x-hez x; (2) a "hi" értékelt rendeljük az y-hoz; majd (3) megkíséreljük összeadni x-et és y-t.

Egy dinamikus típust kezelő nyelvnél, minden érték valójában egy típusjelző és egy érték párból áll, az (1) értékadás létrehozza a `(egész, 5)` párt és a (2) értékadás a `(string, "hi")` párt. Amikor a program megkísérli végrehajtani a (3) sort, a nyelv megvalósítása megvizsgálja a párok típusjelzőit `egész` és `string`, majd felismeri, hogy az `+` (összeadás) nem értelmezhető művelet erre a két típusra, ezért hibát jelez.

Néhány statikus típus kezelő rendszert használó nyelv létrehoz egy "hátsó ajtót" a nyelvben, hogy a programozónak lehetősége legyen olyan kódot írni, melyen nem történik statikus típusellenőrzés. Például a C és a Java a "szereposztás" angolul cast megoldást alkalmazza.

## [szerkesztés] Statikus és dinamikus típusellenőrzés a gyakorlatban

A választás a két ellenőrzési mód között többnyire kereskedelmi megfontolásokon alapul. A legtöbb programozó erősen kitart az „egy minden felett” elv mellett, mások ezt kimondottan korlátozásnak és nehezen tolerálhatónak tartják. A statikus típusellenőrzés a hibákat még fordítási időben találja meg. Ezzel növelhető a program megbízhatósága. Ennek ellenére a programozók tagadják, hogy a típushibák gyakran fordulnának elő, és ezen hibák egy része van csak azért, mert nem vettek figyelembe típusokat. A statikus típusellenőrzés hívei hiszik, hogy a programok megbízhatóbbak, ha a típusokat ellenőrzik, míg a dinamikus típusellenőrzés hívei arra hivatkoznak, hogy a leszállított programok használata önmagában bizonyítja a program megbízhatóságát, és kevés a programhiba.

Az erősen típusos nyelvek (mint az ML és a Haskell) pártfogói szerint minden programhibát úgy kell tekinteni, mint típushiba, ha jól meghatározott típusokat használnak a programozók, és a fordító jól következtet.

A statikus típusok használatának egyik következménye, hogy a fordított kód gyorsabban végrehajtható. Ha ugyanis a fordító pontosan tudja az adattípust, akkor a gépi kódot hatékonyabban alkalmazhatja. Az újabb statikusan típusos nyelvek fordítói ezt a kézenfekvő lehetőséget ki is használják. Néhány dinamikusan típusos nyelv – mint a CommonLisp – opcionálisan megengedi a típusok meghatározását, éppen az optimalizálás elősegítése miatt . A statikusan típusos nyelvek esetében ez adott. Részletesebben lásd: fordítók optimalizálása.

Azok a statikusan típusos nyelvek, amelyekben hiányzik az interfész típus – mint a Java – igénylik a programozóktól, hogy előbb határozzák meg a típusokat, mielőtt azt egy metódus vagy függvény használná. Ez egy kiegészítő információ a program számára, és a fordító nem engedi meg a programozónak, hogy megváltoztassa, vagy ne vegye ezeket figyelembe. Végül is, egy nyelv lehet statikusan típusos anélkül, hogy igényelne típus meghatározásokat, tehát ez nem következménye a statikus típusosságnak.

## [szerkesztés] Erős és gyenge típusosság

## [szerkesztés] Típusok és a polimorfizmus

## [szerkesztés] Típusok

- elemi adattípusok — a legegyszerűbb típusok, pl. integer vagy lebegőpontos

- egész típusok — az egész számok és a természetes számok típusai

- racionális típusok — a valódi törtek pl. 1/3 vagy 3/5 típusa

- lebegőpontos típusok — a különböző lebegőpontos számábrázolásokhoz tartozó típusok

- összetett adattípusok — a típus elemi típusokból épül fel, pl. rekord. Absztrakt adattípusoknak vannak összetett adattípusú és interfész adattípusú jellemzőik is, attól függően, minek tekintjük őket.

- altípus

- származtatott típus

- objektum típus, pl. típus változó

- rekurzív típus

- funkció típusok, pl. bináris funkciók

- univerzális mennyiségi típusok, pl. paraméterezett típusok

- Egzisztenciális mennyiségi típusok, pl. modulok

## [szerkesztés] Speciális típusok

- osztály — az objektum-orientált programozásban egy objektum
- interfész — függőség típusa
- protokoll — egy kommunikációs csatorna típusa
- kind — a típus típusa
- használati eset (use case) — a környezet és a rendszer közötti interakció típusa
- réteg (layer) — egy metódus egy osztályának végrehajtási környezetének típusa az objektum-orientált programozásban

## [szerkesztés] Kompatibilitás, ekvivalencia, helyettesíthetőség

A kompatibilitás és ekvivalencia kérdése nagyon bonyolult és ellentmondásos, és közvetlenül kapcsolódik a helyettesíthetőség kérdéséhez; más szavakkal: ha adott A típus és b típus, akkor azok azonos vagy kompatibilis típusúak? Használható-e A értéke helyett B értéke?

Ha A kompatibilis B-vel, akkor A B egyik altípusa (de fordítva ez nem minden esetben igaz!) - mondja ki a Liskov-féle helyettesítési elv.

A típuskonverzió használatával lehetséges, hogy egy típus kompatibilis legyen egy másikkal, egy helyettesítési környezetben.

Két különböző típus kompatibilitásra létezik metódus: a nevük (elnevezésük) kompatibilis és a strukturálisan kompatibilisek. Ekkor az "ekvivalencia" és a "kompatibilitás" kifejezések azonos fogalmat takarnak.

1. típus név kompatibiltás azt jelenti, hogy két változó csak akkor kompatibilis típusú, ha egyik vagy a másik megjelenik azonos deklarációban vagy deklarációkban és azonos típusnevet használnak.
2. strukturális kompatibilitás azt jelenti, hogy a két változó struktúrája identikus.

A két metódusnak különböző variációi léteznek, a legtöbb (programozási) nyelv ezeknek a technikáknak a különböző kombinációit alkalmazza.

## [szerkesztés] Lásd még

- programozási nyelvek
- polimorfizmus

| Ez az informatikai tárgyú lap még csak csonk (azaz erősen hiányos). Segíts te is, hogy igazi szócikk lehessen belőle!

A lap eredeti címe "http://hu.wikipedia.org../../../a/d/a/Adatt%C3%ADpus.html"

Kategóriák: Informatika | Csonkok (informatika) | Csonkok 2006 januárjából

##### Views

- Szócikk
- Vitalap
- Aktuális változat

##### Keresés

##### Más nyelveken

- English
- Česky
- Français
- Русский
- தமிழ்