Ugrás a tartalomhoz

Értékadás

Ellenőrzött
A Wikipédiából, a szabad enciklopédiából

A számítógépes programozásban a hozzárendelési utasítás, az értékadás beállítja és/vagy visszaállítja a változó neve által megjelölt tárolóhely(ek)en tárolt értéket; más szóval egy értéket(wd) másol a változóba. A legtöbb imperatív programozási nyelvben az értékadó utasítás (vagy kifejezés) egy alapvető konstrukció.

Napjainkban ennek a műveletnek a leggyakrabban használt jelölése az x = expr (eredetileg Superplan(wd) 1949-51, amelyet a Fortran 1957 és a C tett népszerűvé). A második leggyakrabban használt jelölés[1] az x := expr (eredetileg ALGOL 1958, amelyet a Pascal tett népszerűvé)[2] Sok más jelölés is használatos. Egyes nyelvekben a használt szimbólumot operátornak tekintik (ami azt jelenti, hogy az értékadó utasítás egésze egy értéket ad vissza). Más nyelvek az értékadást utasításként definiálják (ami azt jelenti, hogy nem használható kifejezésben).

A hozzárendelések általában lehetővé teszik, hogy egy változó különböző értékeket tartson fenn élettartama és hatóköre során különböző időpontokban. Egyes nyelvek (elsősorban a szigorúan funkcionális nyelvek) azonban nem engedik meg ezt a fajta „destruktív” átértékelést, az a nem lokális állapot megváltozását vonhatja maga után. A cél a referenciális átláthatóság[3] érvényesítése, azaz olyan függvények létrehozása, amelyek nem függenek bizonyos változók állapotától, de ugyanazt az eredményt hozzák egy adott paraméteres bemeneti halmazra bármely időpontban. A modern programok más nyelveken is gyakran alkalmaznak hasonló stratégiákat, bár kevésbé szigorúan, és csak bizonyos részekben, a bonyolultság csökkentése érdekében, általában olyan kiegészítő módszerekkel, mint az adatstruktúrálás, a strukturált programozás és objektumorientáltsággal együtt.

Szemantika

[szerkesztés]

Az értékadó művelet egy olyan folyamat az imperatív programozásban, amelyben egy adott változónévhez az idő múlásával különböző értékek társulnak.[1] A program ilyen modellben úgy működik, hogy egymást követő értékadó utasításokkal változtatja az állapotát.[2][4] Az imperatív programozási nyelvek primitívjei értékadásra támaszkodnak az iteráció végrehajtásához.[5] A legalacsonyabb szinten az értékadást gépi műveletekkel valósítják meg, mint például a MOVE vagy a STORE.[2][5]

A változók értékek tárolói. Lehetséges egy értéket beírni egy változóba, majd később egy újra cserélni. Az értékadó művelet módosítja a futó program aktuális állapotát.[4] Következésképpen az értékadás a változók fogalmától függ. Egy értékadás során:

  • A kifejezés a program aktuális állapotában kerül kiértékelésre.
  • A változó-hoz a kiszámított érték lesz rendelve, amely felülírja a változó korábbi értékét.

Példa: Feltételezve, hogy az a egy numerikus változó, az a := 2*a értékadás azt jelenti, hogy az a változó tartalma megduplázódik az utasítás végrehajtása után.

Egy példa a C kód egy szegmensére: 

int x = 10; 
float y;
x = 23;
y = 32.4f;

Ebben a példában az x változót először int-ként deklaráljuk, majd a 10 értéket rendeljük hozzá. Figyeljük meg, hogy a deklaráció és az értékadás ugyanabban az utasításban történik. A második sorban az y értékadás nélkül van deklarálva. A harmadik sorban az x értéke 23 lesz. Végül az y értéke 32,4.

Egy értékadó művelethez szükséges, hogy a kifejezés értéke jól definiált legyen (érvényes rvalue[6]), és hogy a változó egy módosítható entitást képviseljen (érvényes módosítható – nem konstans(wd) – balérték[6]). Néhány nyelvben, jellemzően a dinamikusakban,[7] nem szükséges deklarálni egy változót az értékadás előtt. Ezekben a nyelvekben egy változó automatikusan deklarálódik az első értékadáskor, a deklarált hatókör nyelvenként változik.

Egyszeri értékadás

[szerkesztés]

Bármely értékadás, amely egy meglévő értéket módosít (pl. x := x + 1), nem engedélyezett a tisztán funkcionális(wd)[8] nyelvekben.[5] A funkcionális programozásban az értékadást ellenjavallják, és ehelyett az egyszeri értékadást (single assignment) részesítik előnyben, amelyet általában inicializálásnak neveznek. Az egyszeri értékadás a névhezkötés (name binding) egyik példája, és abban különbözik a cikkben leírt értékadástól, hogy csak egyszer végezhető el, általában a változó létrehozásakor; későbbi átértékelés nem megengedett.

Egy kifejezés kiértékelésének nincs mellékhatása(wd), ha az eredmény előállításán kívül nem változtatja meg a gép megfigyelhető állapotát,[9] és ugyanarra a bemenetre mindig ugyanazt az értéket adja.[5] Az imperatív értékadás mellékhatásokat okozhat, a régi értéket megsemmisíti és elérhetetlenné teszi, miközben egy új értékkel helyettesíti,[10] ezért a LISP-ben és a funkcionális programozásban destruktív értékadásnak nevezik, hasonlóan a destruktív frissítéshez(wd).[11][12]

Az egyszeri értékadás az egyetlen elérhető hozzárendelési forma a tisztán funkcionális nyelvekben, mint például a Haskell, amelyek nem tartalmaznak változókat az imperatív programozási nyelvek[5] értelmében vett változókkal, hanem névvel ellátott, esetleg összetett jellegű konstans értékekkel, amelyek elemeit fokozatosan, igény szerint határozzák meg a lusta[13] nyelvek számára. A tisztán funkcionális nyelvek lehetőséget biztosítanak a számítások párhuzamos végrehajtására, elkerülve a Neumann-féle szűk keresztmetszetet,[14] amely a szekvenciális, lépésenkénti végrehajtást jelenti, mivel az értékek függetlenek egymástól.[15]

A nem tiszta funkcionális nyelvek mind egyszeri, mind valódi értékadást biztosítanak (bár a valódi értékadást jellemzően ritkábban használják, mint az imperatív programozási nyelvekben). Például a Scheme-ben mind az egyszeri értékadás (let-tel), mind a valódi értékadás (set!-tel) használható minden változón, és speciális primitívek állnak rendelkezésre a listákon, vektorokon, karakterláncokon stb. belüli destruktív frissítéshez. Az OCaml-ben(wd)[16] a változók esetében csak egyszeri értékadás engedélyezett a let name = value szintaxis segítségével; azonban a destruktív frissítés használható tömbök és sztringek elemein külön <- operátorral, valamint rekordok és objektumok mezőin, amelyeket a programozó explicit módon módosíthatónak (azaz a kezdeti deklarációjuk után módosíthatónak) deklarált.[17]

Az egyszeri értékadást használó funkcionális programozási nyelvek közé tartozik a Clojure(wd) (adatszerkezetekhez, nem változókhoz),[18] az Erlang (többszörös értékadást is elfogad, ha az értékek egyenlőek, ellentétben a Haskell-lel), az F#, a Haskell, a JavaScript (konstansokhoz), a Lava(wd), az OCaml(wd), az Oz(wd) (adatfolyam-változókhoz, nem cellákhoz), a Racket(wd) (bizonyos adatszerkezetekhez, például listákhoz, nem szimbólumokhoz), a SASL(wd), a Scala(wd) (értékekhez), a SISAL(wd) és a Standard ML. A nem visszalépéses Prolog kódot explicit egyszeri értékadásúnak tekinthetjük, abban az értelemben, hogy a (megnevezett) változói explicit módon nem hozzárendelt állapotban lehetnek, vagy pontosan egyszer állíthatók be. A Haskellben ezzel szemben nem lehetnek nem hozzárendelt változók, és minden változót úgy tekinthetünk, mintha implicit módon, létrehozásakor beállították volna az értékét (vagy inkább egy számítási objektumot, amely igény szerint előállítja az értékét).

Értékadás értéke

[szerkesztés]

Néhány programozási nyelvben az értékadó utasítás értéket ad vissza, míg másokban nem.

A legtöbb kifejezés-orientált programozási nyelvben (például C-ben) az értékadó utasítás visszaadja a hozzárendelt értéket, lehetővé téve az olyan idiómákat, mint az x = y = a, amelyben az y = a értékadó utasítás visszaadja az a értékét, amelyet aztán az x-hez rendelünk hozzá. Egy olyan utasításban, mint a while ((ch = getchar()) != EOF) {…}, egy függvény visszatérési értékét használjuk egy ciklus vezérlésére, miközben ugyanazt az értéket rendeljük egy változóhoz.

Más programozási nyelvekben, például a Scheme-ben, az értékadás visszatérési értéke nincs definiálva, és az ilyen idiómák érvénytelenek.

A Haskellben[19] nincs változóértékadás; de az értékadáshoz hasonló műveletek (például egy tömb eleméhez vagy egy módosítható adatszerkezet mezőjéhez való értékadás) általában az egységtípust[20] adják vissza, amelyet () alakban jelölünk. Ennek a típusnak csak egy lehetséges értéke van, ezért nem tartalmaz információt. Ez jellemzően az a kifejezéstípus, amelyet kizárólag a mellékhatásai szempontjából értékelnek ki.

Különféle értékadási formák

[szerkesztés]

Bizonyos használati minták nagyon gyakoriak, ezért gyakran speciális szintaxissal rendelkeznek a támogatásukhoz. Ezek elsősorban szintaktikai cukorként[21] szolgálnak a forráskód redundanciájának csökkentésére, de segítenek a kód olvasóinak megérteni a programozó szándékát, és támpontot adnak a fordítónak a lehetséges optimalizáláshoz.

Kiterjesztett értékadás

[szerkesztés]

Az az eset, amikor a hozzárendelt érték egy előzőtől függ, annyira gyakori, hogy sok imperatív nyelv, leginkább a C és leszármazottainak többsége, speciális operátorokat, úgynevezett kiterjesztett értékadást[22] biztosít, mint például a *=, így az a = 2*a ehelyett a *= 2-ként írható fel.[4] A szintaktikai cukron (syntactic sugar[21]) túl ez segíti a fordítóprogram feladatát azáltal, hogy egyértelművé teszi az a változó helybeni módosításának lehetőségét.

Láncolt értékadás

[szerkesztés]

Egy olyan utasítást, mint a w = x = y = z, láncolt értékadásnak (chained assignment) nevezünk, amelyben z értékét több w, x, és y változóhoz rendeljük. A láncolt értékadást gyakran használják több változó inicializálására, mint például az
a = b = c = d = f = 0

Nem minden programozási nyelv támogatja a láncolt értékadást. A láncolt értékadások egyenértékűek értékadások sorozatával, de a kiértékelési stratégia nyelvenként eltérő. Egyszerű láncolt értékadásoknál, például több változó inicializálásánál, a kiértékelési stratégia nem számít, de ha az értékadásban szereplő célok (balértékek[6]) valamilyen módon összefüggenek, a kiértékelési stratégia befolyásolja az eredményt.

Néhány programozási nyelvben (például C) a láncolt értékadások támogatottak, mivel az értékadások kifejezések, és értékekkel rendelkeznek. Ebben az esetben a lánchozzárendelés jobbról balra történő asszociatív értékadással valósítható meg. Például az i = arr[i] = f() egyenértékű az arr[i] = f(); i = arr[i] képlettel. C++-ban osztálytípusok értékeihez is elérhetők az értékadó operátor megfelelő visszatérési típusának deklarálásával.

A Pythonban az értékadó utasítások nem kifejezések, így nincs értékük. Ehelyett a láncolt hozzárendelések olyan utasítások sorozatát jelentik, amelyek egyetlen kifejezéshez több célpontot is rendelnek. Az értékadások balról jobbra haladnak, így az i = arr[i] = f() kiértékeli az f() kifejezést, majd az eredményt a bal szélső célponthoz, i-hez rendeli, végül pedig a következő célponthoz, arr[i]-hez rendeli az i új értékét felhasználva.[23] Ez lényegében egyenértékű a tmp = f(); i = tmp; arr[i] = tmp képlettel, bár az ideiglenes értékhez nem jön létre tényleges változó.

Párhuzamos értékadás

[szerkesztés]

Néhány programozási nyelv, mint például az APL, Common Lisp,[24] Go,[25] JavaScript (1.7 óta), Julia(wd), PHP, Maple, Lua, occam 2,[26] Perl,[27] Python,[28] REBOL(wd), Ruby,[29] és PowerShell lehetővé teszi több változó párhuzamos értékadását, a következő szintaxissal: 

a, b := 0, 1

amely egyidejűleg 0-t rendel a-hoz és 1-et b-hez. Ezt leggyakrabban párhuzamos értékadásnak nevezik; a CPL-ben(wd) vezették be 1963-ban, szimultán értékadás néven,[30] és néha többszörös értékadásnak is nevezik, bár ez zavaró lehet, ha az „egyszeres értékadás”-sal használják, mivel ezek nem ellentétesek. Ha az értékadás jobb oldala egyetlen változó (pl. tömb vagy struktúra), akkor a funkciót kicsomagolásnak (unpacking)[31] vagy értékadás destrukturálásnak (destructuring assignment) nevezzük:[32] 

var list := {0, 1}
a, b := list

A listát úgy csomagoljuk ki, hogy az a-hoz 0, a b-hez pedig 1 kerüljön. Továbbá, 

a, b := b, a

felcseréli az a és b értékeit. Párhuzamos értékadás nélküli nyelvekben ezt egy ideiglenes változó használatához kellene írni. 

var t := a
a := b
b := t

mivel a := b; b := a esetén a és b is megmarad b eredeti értékével.

Néhány nyelv, mint például a Go, az F# és a Python, kombinálja a párhuzamos értékadást, a tuple-ket és az automatikus tuple-kicsomagolást, hogy egyetlen függvényből több visszatérési értéket lehessen visszaadni, ahogy ebben a Python példában is látható, 

def f():
    return 1, 2
a, b = f()

míg más nyelvek, mint például a C# és a Rust, amelyeket itt bemutatunk, explicit tuple-konstrukciót és zárójeles dekonstrukciót igényelnek: 

// Valid C# or Rust syntax
(a, b) = (b, a);

// C# tuple return
(string, int) f() => ("foo", 1);
var (a, b) = f();

// Rust tuple return
let f = || ("foo", 1);
let (a, b) = f();

Ez alternatívát kínál a kimeneti paraméterek használatára több érték visszaadására egy függvényből. Ez CLU-ra(wd) (1974) nyúlik vissza, és a CLU segített a párhuzamos értékadás általános népszerűsítésében.

A C# ezenkívül lehetővé teszi az általánosított dekonstrukciós értékadást, amelynek implementációját a jobb oldalon található kifejezés határozza meg, mivel a fordító a kifejezésen keres megfelelő példányt vagy kiterjesztést, a Deconstruct metódust(wd),[33] amelynek kimeneti paraméterekkel kell rendelkeznie a hozzárendelt változókhoz.[34] Például egy olyan metódus, amely az osztályt(wd) a fenti f() függvény visszatérési értékével megegyező viselkedéssel jelenítené meg, a következő lenne: 

void Deconstruct(out string a, out int b) { a = "foo"; b = 1; }

A C és C++ nyelvekben a vessző operátor hasonló a párhuzamos értékadáshoz, mivel lehetővé teszi több értékadást egyetlen utasításon belül, az a = 1, b = 2 kifejezést írva az a, b = 1, 2 helyett. Ezt elsősorban for ciklusokban használják, és más nyelvekben, például a Go-ban, a párhuzamos értékadás helyettesíti.[35] A fenti C++ kód azonban nem garantálja a tökéletes egyidejűséget, mivel a következő kód jobb oldala, az a, b = b, a+1, a bal oldal után kerül kiértékelésre. Az olyan nyelvekben, mint a Python, az a = b, b = a+1 a két változót egyidejűleg rendeli hozzá, az a kezdeti értékét használva az új b kiszámításához.

Értékadás kontra egyenlőség

[szerkesztés]

Az egyenlőségjel = értékadó operátorként való használatát gyakran kritizálták, mivel ütközik az egyenlőség összehasonlításával. Ez zavart okoz mind a kezdőknek a kódírásban, mind a tapasztalt programozóknak a kódolvasásban. Az egyenlőség operátorok használata értékadáshoz Heinz Rutishauser(wd)[36] 1949 és 1951 között tervezett Superplan(wd) nyelvére nyúlik vissza, amelyet különösen a Fortran tett népszerűvé:

„A rossz ötlet hírhedt példája volt az egyenlőségjel választása a hozzárendelés jelölésére. Ez a Fortran 1957-es[37] bevezetéséig nyúlik vissza, és nyelvtervezők seregei másolták vakon. Miért rossz ötlet? Mert megdönti azt az évszázados hagyományt, hogy az "=" egy egyenlőségi összehasonlítást jelöl, egy olyan predikátumot, amely vagy igaz, vagy hamis. De a Fortranban értékadást, az egyenlőség érvényesítését értették alatta. Ebben az esetben az operandusok egyenlőtlen helyzetben vannak: a bal oldali operandust (egy változót) egyenlővé kell tenni a jobb oldali operandussal (egy kifejezéssel). Az x = y nem ugyanazt jelenti, mint az y = x.”[38]
— Niklaus Wirth, Good Ideas, Through the Looking Glass

A kezdő programozók néha összekeverik az értékadást az egyenlőség relációs operátorával(wd), mivel az "=" a matematikában egyenlőséget jelent, és sok nyelvben használják értékadásra. Az értékadás azonban megváltoztatja egy változó értékét, míg az egyenlőségvizsgálat azt vizsgálja, hogy két kifejezés értéke megegyezik-e.

Néhány nyelvben, például a BASIC-ben, egyetlen egyenlőségjelet ("=") használnak mind az értékadó operátor, mind az egyenlőség relációs operátoraként, a kontextus határozza meg, hogy melyikre gondolunk. Ez valójában egyszerű feladat: ha az utasítás változónévvel kezdődik, majd egy "=" követi, akkor ez egy értékadó utasítás. Hivatalosan a BASIC nyelv tartalmazza a LET utasításszót is, amely az értékadást jelöli (pl. LET k=9), de régi hagyomány, hogy ez az utasításszó elhagyható. Az egyenlőségjel minden más helyzetben egy logikai művelet műveleti jele, és a művelet értéke True vagy -1 egyenlőség esetén, False vagy 0 különbözőség esetén.

Más nyelvek különböző szimbólumokat használnak a két operátor jelölésére. [39] Például:

  • Az ALGOL-ban és a Pascalban az értékadó operátor egy kettőspont és egy egyenlőségjel (":="), míg az egyenlőségoperátor egyetlen egyenlőségjel ("=").
  • C-ben az értékadó operátor egyetlen egyenlőségjel ("="), míg az egyenlőségoperátor két egyenlőségjel ("==").
  • Az R-ben az értékadó operátor alapvetően <-, mint az x <- value esetében, de bizonyos helyzetekben egyetlen egyenlőségjel is használható.

A két szimbólum hasonlósága hibákhoz vezethet, ha a programozó elfelejti, hogy melyik forma ("=", "==", ":=") a megfelelő, vagy elgépeli a "=" karaktert, amikor eredetileg "==" volt a szándéka. Ez egy gyakori programozási probléma olyan nyelveken, mint a C (beleértve egy híres kísérletet a Linux kernel hátsó kapujának[40] elérésére),[41] ahol az értékadó operátor szintén visszaadja a hozzárendelt értéket (ugyanúgy, ahogy egy függvény visszaad egy értéket), és érvényesen beágyazható kifejezésekbe. Ha például egy if utasításban két érték összehasonlítása lenne a cél, akkor egy értékadás valószínűleg egy logikai igazként értelmezhető értéket ad vissza, amely esetben a then záradék végrehajtódik, ami a program váratlan viselkedését eredményezi. Egyes nyelvi processzorok (például a gcc) képesek észlelni az ilyen helyzeteket, és figyelmeztetni a programozót a lehetséges hibára.[42][43]

Jelölés

[szerkesztés]

A másoló értékadás két leggyakoribb ábrázolása az egyenlőségjel (=) és a kettőspont-egyenlőségjel (:=). Mindkét forma szemantikailag jelölhet értékadó utasítást vagy értékadó operátort (amelynek szintén van értéke), a nyelvtől és/vagy a használattól függően.

variable = expression Fortran, PL/I, C (és leszármazottai, mint például C++, Java stb.), Bourne shell(wd), Python, Go (előre deklarált változókhoz való hozzárendelés), R, PowerShell, Nim(wd) stb.
variable := expression ALGOL (és származékai), Simula, CPL(wd), BCPL(wd), Pascal[44] (és leszármazottai, mint például a Modula(wd)), Mary(wd), PL/M(wd), Ada, Smalltalk, Eiffel,[45][46] Oberon(wd), Dylan(wd),[47] Seed7(wd), Python (értékadó kifejezés),[48] Go (változó deklarálásának és definiálásának rövidítése),[49] Io(wd), AMPL(wd), ML (referenciaértékhez való hozzárendelés),[50] AutoHotkey(wd) stb.

További lehetőségek lehetnek a balra mutató nyíl vagy egy kulcsszó, bár léteznek más, ritkább változatok is:

variable << expression Magik(wd)
variable <- expression F#, OCaml(wd), R, S(wd)
variable <<- expression R
assign("variable", expression) R
variable ← expression APL,[51] Smalltalk, Atari 2600 BASIC Programming(wd)
variable =: expression J(wd)
LET variable = expression BASIC
let variable := expression XQuery
set variable to expression AppleScript(wd)
set variable = expression C shell(wd)
Set-Variable variable (expression) PowerShell
variable : expression Macsyma, Maxima(wd), K(wd)
variable: expression Rebol(wd)
var variable expression mIRC scripting language(wd)
reference-variable :- reference-expression Simula

A matematikai pszeudokód hozzárendeléseket általában balra mutató nyíllal jelölik.

Néhány platform a kifejezést balra, a változót pedig jobbra helyezi:

MOVE expression TO variable COBOL
expression → variable TI-BASIC(wd), Casio BASIC(wd)
expression -> variable POP-2(wd), BETA, R
put expression into variable HyperTalk(wd), LiveCode(wd)
PUT expression IN variable ABC

Néhány kifejezésorientált nyelv, mint például a Lisp[52][53] és a Tcl(wd), egységesen prefix (vagy postfix) szintaxist használ minden utasításhoz, beleértve az értékadást is.

(setf variable expression) Common Lisp
(set! variable expression) Scheme[54][55][56]
set variable expression Tcl(wd)
expression variable ! Forth

Kapcsolódó szócikkek

[szerkesztés]

Jegyzetek

[szerkesztés]
  1. ↑ a b 2cs24 Declarative. www.csc.liv.ac.uk . [2006. április 24-i dátummal az eredetiből archiválva]. (Hozzáférés: 2018. április 20.)
  2. ↑ a b c Imperative Programming. uah.edu . [2016. március 4-i dátummal az eredetiből archiválva]. (Hozzáférés: 2018. április 20.)
  3. ↑ Az analitikus filozófiában és az informatikában a referenciális transzparencia és a referenciális átlátszatlanság a nyelvi konstrukciók, és ezen keresztül a nyelvek tulajdonságai.
  4. ↑ a b c Ruediger-Marcus Flaig. Bioinformatics programming in Python: a practical course for beginners. Wiley-VCH, 98–99. o. (2008). ISBN 978-3-527-32094-3 
  5. ↑ a b c d e Crossing borders: Explore functional programming with Haskell Archiválva 2010. november 19-i dátummal a Wayback Machine-ben., by Bruce Tate
  6. ↑ a b c Néhány nyelv a balérték (l-value) és jobbérték (r-value) fogalmát használja, amely az értékadó utasítások bal és jobb oldalán található tipikus kiértékelési módból származik. A balérték egy olyan objektumra utal, amely egyetlen kifejezésen túl is létezik. Az r-érték egy ideiglenes érték, amely nem marad fenn azon a kifejezésen túl, amelyik használja.
  7. ↑ A dinamikus programozási nyelv(wd) lehetővé teszi különféle műveletek futásidejű meghatározását és végrehajtását.
  8. ↑ A számítástudományban a tisztán funkcionális programozás általában egy olyan programozási paradigmát jelöl – a számítógépes programok szerkezetének és elemeinek felépítési stílusát –, amely minden számítást matematikai függvények kiértékeléseként kezel.
  9. ↑ Mitchell, John C.. Concepts in programming languages. Cambridge University Press, 23. o. (2003). ISBN 978-0-521-78098-8 
  10. ↑ Imperative Programming Languages (IPL). gwu.edu . [2011. július 16-i dátummal az eredetiből archiválva]. (Hozzáférés: 2018. április 20.)
  11. ↑ A számítástechnikában a perzisztens adatszerkezet (persistent data structure vagy not ephemeral data structure) olyan adatszerkezet, amely módosításakor mindig megőrzi önmagának előző verzióját. Az ilyen adatszerkezetek gyakorlatilag megváltoztathatatlanok(wd), mivel műveleteik nem (láthatóan) frissítik a struktúrát helyben, hanem mindig egy új, frissített struktúrát eredményeznek.
  12. ↑ Making data structures persistent, Proceedings of the eighteenth annual ACM symposium on Theory of computing - STOC '86, 109–121. o.. DOI: 10.1145/12130.12142 (1986). ISBN 978-0-89791-193-1 
  13. ↑ A programozási nyelvelméletben a lusta kiértékelés(wd) (lazy evaluation), vagy igény szerinti hívás (call-by-need) egy olyan kiértékelési stratégia(wd), amely egy kifejezés(wd) kiértékelését késlelteti, amíg az értékére szükség nem lesz (nem szigorú kiértékelés), és amely elkerüli az ismételt kiértékeléseket (megosztás használatával).
  14. ↑ Ugyanazon busz használata utasítások és adatok lekérésére a Neumann-féle szűk keresztmetszethez vezet, ami a központi feldolgozó egység (CPU) és a memória közötti korlátozott átviteli sebességet (adatátviteli sebességet) jelent a memória mennyiségéhez képest.
  15. ↑ John C. Mitchell. Concepts in programming languages. Cambridge University Press, 81–82. o. (2003). ISBN 978-0-521-78098-8 
  16. ↑ Az OCaml egy általános célú, magas szintű, több paradigmát támogató programozási nyelv, amely a Caml(wd) (Categorical Abstract Machine Language) dialektusát az ML (Meta Language) objektumorientált funkcióival bővíti.
  17. ↑ Az objektumorientált (OO) és funkcionális programozásban az állandó objektum(wd) (immutable object) olyan objektum, amelynek állapota a létrehozása után nem módosítható. Ez ellentétben áll a módosítható objektummal (mutable object vagy changeable object), amely a létrehozása után módosítható.
  18. ↑ A Clojure a Lisp programozási nyelv dinamikus(wd) és funkcionális dialektusa Java platformon(wd).
  19. ↑ Hudak, Paul. The Haskell School of Expression: Learning Functional Programming Through Multimedia. Cambridge: Cambridge University Press (2000). ISBN 0-521-64408-9 
  20. ↑ A matematikai logika és a számítástechnika típuselméletként(wd) ismert területén az egységtípus(wd) olyan típus, amely csak egy értéket enged meg.
  21. ↑ a b A számítástechnikában a szintaktikai cukor (syntactic sugar(wd)) egy programozási nyelven belüli szintaxis, amelynek célja, hogy megkönnyítse a dolgok olvasását vagy kifejezését. A nyelv „édesebbé” válik az emberi használat számára: a dolgokat világosabban, tömörebben vagy olyan alternatív stílusban lehet kifejezni, amelyet egyesek jobban kedvelnek.
  22. ↑ A kiterjesztett értékadást (augmented assignment), vagy összetett értékadást (compound assignment) bizonyos programozási nyelvekben (különösen a C-ből származókban) értékadó operátoroknak nevezik.
  23. ↑ 7. Simple statements — Python 3.6.5 documentation. docs.python.org . (Hozzáférés: 2018. április 20.)
  24. ↑ CLHS: Macro SETF, PSETF. Common Lisp Hyperspec . LispWorks. (Hozzáférés: 2019. április 23.)
  25. ↑ The Go Programming Language Specification: Assignments
  26. ↑ szerk.: INMOS Limited: Occam 2 Reference Manual. New Jersey: Prentice Hall (1988). ISBN 0-13-629312-3 
  27. ↑ Wall, Larry. Perl Programming Language, 2, Cambridge: O´Reilly (1996). ISBN 1-56592-149-6 
  28. ↑ Lutz, Mark. Python Programming Language, 2, Sebastopol: O´Reilly (2001). ISBN 0-596-00085-5 
  29. ↑ Thomas, David. Programming Ruby: The Pragmatic Programmer's Guide. Upper Saddle River: Addison Wesley (2001). ISBN 0-201-71089-7 
  30. ↑ D.W. Barron et al., "The main features of CPL", Computer Journal 6:2:140 (1963). full text (subscription)
  31. ↑ PEP 3132 -- Extended Iterable Unpacking. legacy.python.org . (Hozzáférés: 2018. április 20.)
  32. ↑ Destructuring assignment. MDN Web Docs . (Hozzáférés: 2018. április 20.)
  33. ↑ Az objektumorientált programozásban (OOP) egy metódus(wd) egy objektumhoz, és általában egy üzenethez(wd) társított eljárás.
  34. ↑ Deconstructing tuples and other types. Microsoft Docs . Microsoft. (Hozzáférés: 2019. augusztus 29.)
  35. ↑ Effective Go: for, "Finally, Go has no comma operator and ++ and -- are statements not expressions. Thus if you want to run multiple variables in a for you should use parallel assignment (although that precludes ++ and --)."
  36. ↑ Heinz Rutishauser (1918. január 30. – 1970. november 10.) svájci matematikus és a modern numerikus analízis, valamint a számítástudomány úttörője volt.
  37. ↑ Az = használata megelőzi a Fortran-t, bár a Fortran tette népszerűvé.
  38. ↑ Niklaus Wirth: Good Ideas, Through the Looking Glass
  39. ↑ C++ Programming Language. Basics. ntu.edu.sg , 2013. június 1. (Hozzáférés: 2024. június 21.)
  40. ↑ A hátsó ajtó (backdoor(wd)) egy jellemzően rejtett módszer a normál hitelesítés vagy titkosítás megkerülésére egy számítógépben, vagy más eszközön.
  41. ↑ Corbet: An attempt to backdoor the kernel. lwn.net , 2003. november 6. (Hozzáférés: 2024. június 21.)
  42. ↑ Static Analyzer Options (Using the GNU Compiler Collection (GCC)). gcc.gnu.org . (Hozzáférés: 2024. június 21.)
  43. ↑ Deitel, Paul: C++ Control Statements, Part 2. Domyassignments , 2022. október 25. (Hozzáférés: 2024. június 21.)
  44. ↑ Moore, Lawrie. Foundations of Programming with Pascal. New York: John Wiley & Sons (1980). ISBN 0-470-26939-1 
  45. ↑ Meyer, Bertrand. Eiffel the Language. Hemel Hempstead: Prentice Hall International(UK) (1992). ISBN 0-13-247925-7 
  46. ↑ Wiener, Richard. An Object-Oriented Introduction to Computer Science Using Eiffel. Upper Saddle River, New Jersey: Prentice Hall (1996). ISBN 0-13-183872-5 
  47. ↑ Feinberg, Neal. Dylan Programming. Massachusetts: Addison Wesley (1997). ISBN 0-201-47976-1 
  48. ↑ PEP 572 – Assignment Expressions. python.org , 2018. február 28. (Hozzáférés: 2020. március 4.)
  49. ↑ The Go Programming Language Specification - The Go Programming Language. golang.org . (Hozzáférés: 2018. április 20.)
  50. ↑ Ullman, Jeffrey D.. Elements of ML Programming: ML97 Edition. Englewood Cliffs, New Jersey: Prentice Hall (1998). ISBN 0-13-790387-1 
  51. ↑ Iverson, Kenneth E.. A Programming Language. John Wiley and Sons (1962). ISBN 0-471-43014-5 
  52. ↑ Graham, Paul. ANSI Common Lisp. New Jersey: Prentice Hall (1996). ISBN 0-13-370875-6 
  53. ↑ Steele, Guy L.. Common Lisp: The Language. Lexington: Digital Press (1990). ISBN 1-55558-041-6 
  54. ↑ Dybvig, R. Kent. The Scheme Programming Language: ANSI Scheme. New Jersey: Prentice Hall (1996). ISBN 0-13-454646-6 
  55. ↑ Smith, Jerry D.. Introduction to Scheme. New Jersey: Prentice Hall (1988). ISBN 0-13-496712-7 
  56. ↑ Abelson, Harold. Structure and Interpretation of Computer Programs. New Jersey: McGraw-Hill (1996). ISBN 0-07-000484-6 

Fordítás

[szerkesztés]

Ez a szócikk részben vagy egészben az Assignment (computer science) című angol Wikipédia-szócikk fordításán alapul. Az eredeti cikk szerkesztőit annak laptörténete sorolja fel. Ez a jelzés csupán a megfogalmazás eredetét és a szerzői jogokat jelzi, nem szolgál a cikkben szereplő információk forrásmegjelöléseként.

A lap eredeti címe: „https://hu.wikipedia.org/w/index.php?title=Értékadás&oldid=28194882”