A számítógép-programozásban a paraméter, más néven formális argumentum, egy változó, amely egy argumentumot, más néven tényleges argumentumot, vagy tényleges paramétert képvisel egy alprogramhívásban.. Egy függvény szignatúrája határozza meg a paramétereit.Egy típusszignatúra (Type signature vagy type annotation) definiálja egy függvény, szubrutin vagy metódus bemeneteit és kimeneteit. Tartalmazza a függvény argumentumainak számát, típusát és sorrendjét. Egy hívás magában foglalja a hívás minden egyes argumentumkifejezésének kiértékelését és az eredmény hozzárendelését a megfelelő paraméterhez.

Például vegyük a def add(x, y): return x + y alprogramot. Az x és y változók paraméterek. Az add(2, 3) hívása esetén a 2 és 3 kifejezések argumentumok. Az add(a+1, b+2) hívása esetén az argumentumok a+1 és b+2.

A paraméterátadást egy programozási nyelv definiálja. A kiértékelési stratégia meghatározza a paraméterek deklarálásának és az argumentumok alprogramnak való átadásának szemantikáját. Általában az érték szerinti hívás esetén a paraméter egy új, lokális változóként viselkedik, amely az argumentum értékére van inicializálva. Ha az argumentum egy változó, az alprogram nem módosíthatja az argumentum állapotát, mivel a paraméter egy másolat. Hivatkozáson alapuló hívás esetén, amely megköveteli, hogy az argumentum egy változó legyen, a paraméter az argumentum aliasa.

Példa A következő program egy SalesTax nevű függvényt definiál egyetlen, price nevű paraméterrel; mindkettő double típusú.

double SalesTax(double price) { return 0.05 * price; }

A SalesTax(10.00) függvény meghívásakor a 10.00 argumentum double értékre (10) lesz kiértékelve, és a price paraméterváltozóhoz lesz rendelve. A függvény végrehajtódik, és 0.5 értéket ad vissza.

Paraméterek és argumentumok A paraméter és az argumentum kifejezéseknek eltérő jelentésük lehet a különböző programozási nyelvekben. Néha felcserélhetően használják őket, és a kontextus segít megkülönböztetni a jelentésüket. A paraméter kifejezés (néha formális paraméternek is nevezik) gyakran a függvénydeklarációban található változóra utal, míg az argumentum (néha tényleges paraméternek is nevezik) a függvényhívás során megadott tényleges bemenetre utal. Például, ha egy függvényt def f(x): ...-ként definiálunk, akkor x a paraméter, és ha az a = ...; f(a) hívja meg, akkor a az argumentum. A paraméter egy (kötetlen) változó, míg az argumentum lehet literál, változó, vagy összetettebb kifejezés, amely literálokat és változókat is tartalmaz. Érték szerinti hívás esetén a függvény az argumentum értékét kapja meg – például f(2) és a = 2; f(a) ekvivalens hívások –, míg hivatkozás szerinti hívás esetén, változó argumentummal, egy változóra mutató hivatkozást ad át – annak ellenére, hogy a függvényhívás szintaxisa változatlan maradhatna. A referenciaként való átadásra vagy az értékként való átadásra vonatkozó specifikációt a függvénydeklarációban és/vagy definícióban kell elvégezni.

A paraméterek az eljárásdefiníciókban, az argumentumok az eljáráshívásokban jelennek meg. Az f(x) = x*x függvénydefinícióban az x változó egy paraméter; az f(2) függvényhívásban a 2 érték a függvény argumentuma. Lazán fogalmazva, a paraméter egy típus, az argumentum pedig egy példány.

A paraméter az eljárás belső tulajdonsága, amely a definíciójában szerepel. Például sok nyelvben egy olyan eljáráshoz, amely két megadott egész számot összead, és kiszámítja az összeget, két paraméterre lenne szükség, minden egész számhoz egy-egy. Általánosságban elmondható, hogy egy eljárás tetszőleges számú paraméterrel definiálható, vagy egyáltalán nem lehet paramétere. Ha egy eljárásnak paraméterei vannak, akkor a definíciójának azt a részét, amely a paramétereket meghatározza, paraméterlistának nevezzük.

Ezzel szemben az argumentumok azok a kifejezések, amelyeket az eljárás meghívásakor adunk meg, általában egy, a paraméterek egyikéhez illeszkedő kifejezés. A paraméterekkel ellentétben, amelyek az eljárás definíciójának változatlan részét képezik, az argumentumok hívásról hívásra változhatnak. Minden alkalommal, amikor egy eljárás meghívódik, az eljáráshívás azon részét, amely az argumentumokat határozza meg, argumentumlistának nevezzük.

Bár a paramétereket gyakran argumentumoknak is nevezik, az argumentumokat néha a paraméterváltozókhoz rendelt tényleges értékekként vagy hivatkozásokként tekintik, amikor az alprogramot futási időben hívják. Amikor egy alprogramot meghívó kódról beszélünk, az alprogramnak átadott értékek vagy hivatkozások argumentumok, és a kódban ezek az értékek vagy hivatkozások a paraméterlista helyét foglalják magukban. Amikor az alprogram definícióján belüli kódról beszélünk, az alprogram paraméterlistájában szereplő változók a paraméterek, míg a paraméterek futásidejű értékei az argumentumok. Például C-ben, szálak kezelésekor gyakori, hogy egy void* típusú argumentumot adunk át, és egy várható típusra konvertáljuk: void ThreadFunction(void* pThreadArgument) { // Naming the first parameter 'pThreadArgument' is correct, rather than // 'pThreadParameter'. At run time the value we use is an argument. As // mentioned above, reserve the term parameter for when discussing // subroutine definitions. }

A különbség jobb megértéséhez tekintsük a következő, C nyelven írt függvényt: int Sum(int addend1, int addend2) { return addend1 + addend2; }

A Sum függvénynek két paramétere van, addend1 és addend2. Összeadja a paramétereknek átadott értékeket, és az eredményt visszaadja az alprogram hívójának (a C fordító által automatikusan biztosított technikát használva).

A Sum függvényt meghívó kód így nézhet ki: int value1 = 40; int value2 = 2; int sum_value = Sum(value1, value2); A value1 és value2 változók értékekkel vannak inicializálva. A value1 és value2 ebben a kontextusban egyaránt argumentumok a sum függvény számára.

Futásidőben az ezekhez a változókhoz rendelt értékek argumentumként kerülnek átadásra a Sum függvénynek. A Sum függvényben az addend1 és addend2 paraméterek kiértékelésre kerülnek, ami a 40-es és 2-es argumentumot eredményezi. Az argumentumok értékeit összeadjuk, és az eredményt visszaadjuk a hívónak, ahol az a sum_value változóhoz lesz rendelve.

A paraméterek és argumentumok közötti különbség miatt előfordulhat, hogy egy eljárás nem megfelelő argumentumokat ad meg. A hívás túl sok vagy túl kevés argumentumot adhat meg; egy vagy több argumentum rossz típusú lehet; vagy az argumentumok rossz sorrendben kerülhetnek megadásra. Ezen helyzetek bármelyike eltérést okoz a paraméter- és argumentumlisták között, és az eljárás gyakran nem kívánt választ ad vissza, vagy futásidejű hiba keletkezik.A futásidő (run time) vagy végrehajtási idő a számítógépes program életciklusának utolsó fázisa, amelyben a kódot a számítógép központi feldolgozó egységén (CPU) gépi kódként hajtják végre. Más szóval, a "futásidejű" a program futási fázisa.A futásidejű hibát (runtime error) a program végrehajtása (futási állapota) után vagy alatt észlelik, míg a fordítási idejű hibát a fordító észleli a program végrehajtása előtt.

Alternatív konvenció az Eiffelben Az Eiffel szoftverfejlesztési módszerében és nyelvében az argumentum és a paraméter kifejezéseknek konvenció által meghatározott, eltérő felhasználási módjaik vannak. Az argumentum kifejezést kizárólag egy rutin bemeneteire vonatkozóan használjuk,Meyer, Bertrand. Object-Oriented Software Construction, 2nd Edition, Prentice Hall, 1997, p 444. a paraméter kifejezést pedig kizárólag általános osztályok típusparaméterezésénél.Meyer, p. 96.

Tekintsük a következő rutindefiníciót: sum (addend1: INTEGER; addend2: INTEGER): INTEGER do Result := addend1 + addend2 end

A sum rutin két argumentumot fogad el: az addend1-et és az addend2-t, amelyeket a rutin formális argumentumainak nevezünk. A sum függvényhívás tényleges argumentumokat ad meg, ahogy az alább látható az value1 és value2 használatával.

sum_value: INTEGER value1: INTEGER = 40 value2: INTEGER = 2 … sum_value := sum (value1, value2)

A paramétereket formális vagy aktuális paramétereknek is tekintjük. A formális generikus paramétereket generikus osztályok definíciójában használjuk. Az alábbi példában a HASH_TABLE osztályt generikus osztályként deklaráljuk, amelynek két formális generikus paramétere van: G a számunkra érdekes adatot, K pedig az adat hash kulcsát jelöli:

class HASH_TABLE [G, K -> HASHABLE] …

Amikor egy osztály a HASH_TABLE kliensévé válik, a formális generikus paramétereket tényleges generikus paraméterekkel helyettesíti egy generikus levezetésben. A következő attribútumdeklarációban a my_dictionary-t karakterlánc alapú szótárként kell használni. Mint ilyen, mind az adat, mind a kulcs formális generikus paramétereit STRING típusú tényleges generikus paraméterekkel helyettesíti.

my_dictionary: HASH_TABLE [STRING, STRING]

Adattípusok Az erősen tipizáltA programozási nyelvek besorolásának egyik módja az, hogy a nyelv típusrendszere erősen típusos, vagy gyengén (lazán) típusos-e. programozási nyelvekben minden paraméter típusát meg kell adni az eljárásdeklarációban. A típuskövetkeztetést használó nyelvek megpróbálják automatikusan felfedezni a típusokat a függvény törzséből és használatából. A dinamikusan tipizált programozási nyelvek a típusfeloldást a futási időig halasztják. A gyengén tipizált nyelvek kevés vagy semmilyen típusfeloldást nem végeznek, ehelyett a programozóra támaszkodnak a helyesség érdekében.

Néhány nyelv egy speciális kulcsszót (pl. void) használ annak jelzésére, hogy az alprogramnak nincsenek paraméterei; a formális típuselméletben az ilyen függvények egy üres paraméterlistát fogadnak el (amelynek típusa nem void, hanem unit).

Argumentum-átadás Az argumentumok paraméterekhez rendelésének pontos mechanizmusa, az úgynevezett argumentum-átadás, az adott paraméterhez használt kiértékelési stratégiától függ (jellemzően érték szerinti hívás), amely kulcsszavak segítségével adható meg.

Alapértelmezett argumentumok Néhány programozási nyelv, mint például az Ada, C++, Clojure, Common Lisp, Fortran 90, Python, Ruby, Tcl és a Windows PowerShell lehetővé teszi, hogy egy alapértelmezett argumentumot explicit módon vagy implicit módon adjunk meg egy alprogram deklarációjában. Ez lehetővé teszi a hívó számára, hogy kihagyja ezt az argumentumot az alprogram meghívásakor. Ha az alapértelmezett argumentum explicit módon meg van adva, akkor ezt az értéket használja a program, ha a hívó nem adja meg. Ha az alapértelmezett argumentum implicit (néha egy kulcsszó, például az Optional használatával), akkor a nyelv egy jól ismert értéket biztosít (például null, Empty, zero, üres karakterlánc stb.), ha a hívó nem ad meg értéket.

PowerShell példa: function doc($g = 1.21) { "$g gigawatts? $g gigawatts? Great Scott!" } PS > doc 1.21 gigawatts? 1.21 gigawatts? Great Scott!

PS > doc 88 88 gigawatts? 88 gigawatts? Great Scott!

Az alapértelmezett argumentumok a változó hosszúságú argumentumlista speciális esetének tekinthetők.

Változó hosszúságú paraméterlisták Néhány nyelv lehetővé teszi, hogy az alprogramok változó számú argumentumot fogadjanak el. Az ilyen nyelvek esetében az alprogramoknak végig kell haladniuk az argumentumok listáján.

PowerShell példa: function marty { $args | foreach { "back to the year $_" } } PS > marty 1985 back to the year 1985

PS > marty 2015 1985 1955 back to the year 2015 back to the year 1985 back to the year 1955

Elnevezett paraméterek Néhány programozási nyelv – például az Ada és a Windows PowerShell – lehetővé teszi, hogy az alprogramok elnevezett paraméterekkel rendelkezzenek. Ez lehetővé teszi, hogy a hívó kód öndokumentálóbb legyen. Emellett nagyobb rugalmasságot biztosít a hívónak, gyakran lehetővé téve az argumentumok sorrendjének módosítását, vagy az argumentumok szükség szerinti elhagyását.

PowerShell példa: function jennifer($adjectiveYoung, $adjectiveOld) { "Young Jennifer: I'm $adjectiveYoung!" "Old Jennifer: I'm $adjectiveOld!" } PS > jennifer 'fresh' 'experienced'