Paraméter (számítógép-programozás)

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.^[a].^[1][2][3][4] Egy függvény szignatúrája határozza meg a paramétereit.^[5] 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(wd) 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.

A következő program egy SalesTax nevű függvényt definiál egyetlen, price nevű paraméterrel; mindkettő double(wd) 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.

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.^[6] 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,^[7] 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.^[8]

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,^[9] a paraméter kifejezést pedig kizárólag általános osztályok típusparaméterezésénél.^[10]

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]

Az erősen tipizált^[11] 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).

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.

Néhány programozási nyelv, mint például az Ada, C++, Clojure(wd), Common Lisp,^[12] Fortran 90,^[13] Python, Ruby, Tcl(wd) é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.

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

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'
Young Jennifer: I'm fresh!
Old Jennifer: I'm experienced!

PS  > jennifer -adjectiveOld 'experienced' -adjectiveYoung 'fresh'
Young Jennifer: I'm fresh!
Old Jennifer: I'm experienced!

A lambda-kalkulusban minden függvénynek pontosan egy paramétere van. Amit több paraméterrel rendelkező függvényeknek tekintünk, a lambda-kalkulusban általában egy olyan függvényként ábrázoljuk, amely az első argumentumot veszi fel, és egy olyan függvényt ad vissza, amely a többi argumentumot veszi fel; ezt a transzformációt curryingnek nevezik.^[14] Néhány programozási nyelv, mint például az ML és a Haskell, ezt a sémát követi. Ezekben a nyelvekben minden függvénynek pontosan egy paramétere van, és ami egy több paraméterből álló függvény definíciójának tűnhet, valójában szintaktikai cukor^[15] egy függvényt visszaadó függvény definíciójához stb. A függvényalkalmazás ezekben a nyelvekben, valamint a lambda-kalkulusban is bal-asszociatív, tehát ami egy függvény több argumentumra történő alkalmazásának tűnik, helyesen kiértékelődik, mint az első argumentumra alkalmazott függvény, majd a második argumentumra alkalmazott eredményfüggvény stb.

A kimeneti paraméter, vagy visszatérési paraméter (output parameter vagy return parameter) egy olyan paraméter, amelyet kimenetre használnak, a szokásos bemenet helyett. A referenciaalapú hívási paraméterek, vagy értékalapú hívási paraméterek, ahol az érték egy referencia, kimeneti paraméterként való használata egyes nyelvekben, nevezetesen a C és a C++ nyelvekben,^[b] egy sajátosság, míg más nyelvek beépített támogatással rendelkeznek a kimeneti paraméterekhez. A kimeneti paramétereket beépítetten támogató nyelvek közé tartozik az Ada,^[16] a Fortran (a Fortran 90 óta), a különféle procedurális SQL-kiterjesztések, mint például a PL/SQL^[17] és a Transact-SQL(wd), a C#^[18] és a .NET keretrendszer,^[19] a Swift,^[20] valamint a TScript(wd) szkriptnyelv.

Pontosabban, háromféle paramétert vagy paraméter módot különböztethetünk meg: bemeneti paramétereket, kimeneti paramétereket és input/output paramétereket; ezeket gyakran in, out, és in out vagy inout jelöléssel látjuk el. Egy bemeneti argumentumnak (a bemeneti paraméter argumentumának) egy értéknek kell lennie, például egy inicializált változónak vagy literálnak, és nem szabad újradefiniálni vagy hozzárendelni; egy kimeneti argumentumnak egy hozzárendelhető változónak kell lennie, de nem kell inicializálni, a meglévő értékek nem érhetők el, és értéket kell hozzárendelni; és egy bemeneti/kimeneti argumentumnak egy inicializált, hozzárendelhető változónak kell lennie, és opcionálisan hozzárendelhető egy érték. A pontos követelmények és a betartatás nyelvenként eltérőek – például az Ada 83-ban a kimeneti paraméterekhez csak hozzárendelni lehet, olvasni nem, még hozzárendelés után sem (ezt az Ada 95-ben eltávolították, hogy ne legyen szükség kiegészítő akkumulátorváltozóra). Ezek analógok azzal, mintha egy kifejezésben szereplő érték r-value (van egy értéke), l-value (hozzárendelhető), vagy r-value/l-value (van egy értéke és hozzárendelhető) lenne, bár ezeknek a kifejezéseknek a C-ben speciális jelentésük van.

Bizonyos esetekben csak az input-ot és az input/output-ot különböztetik meg, az output-ot az input/output egy specifikus felhasználásának tekintik, más esetekben pedig csak az input és az output (de az input/output nem) támogatott. Az alapértelmezett mód nyelvenként változik: a Fortran 90-ben az input/output az alapértelmezett, míg a C#-ban és az SQL-bővítményekben az input az alapértelmezett, a TScriptben pedig minden paraméter explicit módon meg van adva bemenetként vagy kimenetként.

Szintaktikailag a paramétermódot általában egy kulcsszó jelzi a függvénydeklarációban, például a C#-ban a void f(out int x). A kimeneti paramétereket hagyományosan gyakran a paraméterlista végére helyezik, hogy egyértelműen megkülönböztessék őket, bár ezt nem mindig tartják be. A TScript egy másik megközelítést alkalmaz, ahol a függvénydeklarációban a bemeneti paraméterek, majd a kimeneti paraméterek vannak felsorolva, kettősponttal (:) elválasztva, és magának a függvénynek nincs visszatérési típusa, mint ebben a függvényben, amely egy szövegrészlet méretét számítja ki:

TextExtent(WString text, Font font : Integer width, Integer height)

A paramétermódok a denotációs szemantika(wd) egy formája, amely a programozó szándékát fejezi ki, és lehetővé teszi a fordítók számára a hibák észlelését és optimalizálások alkalmazását – nem feltétlenül utalnak működési szemantikákra(wd) (hogyan történik a paraméterátadás valójában). Figyelemre méltó, hogy míg a bemeneti paraméterek implementálhatók értékalapú hívással, a kimeneti és bemeneti/kimeneti paraméterek pedig hivatkozásalapú hívással – és ez egy egyszerű módja ezen módok implementálásának a beépített támogatás nélküli nyelvekben –, nem mindig így implementálják őket. Ezt a megkülönböztetést részletesen tárgyalja az Ada '83 Indoklása, amely hangsúlyozza, hogy a paraméter mód attól függ, hogy melyik paraméterátadási mechanizmus (hivatkozással vagy másolással) valósul meg valójában.^[16] Például míg a C#-ban a bemeneti paramétereket (alapértelmezés szerint, nincs kulcsszó) érték szerint adjuk át, a kimeneti és a bemeneti/kimeneti paramétereket (out és ref) pedig referencia szerint, addig a PL/SQL-ben a bemeneti paramétereket (IN) referencia szerint adjuk át, a kimeneti és a bemeneti/kimeneti paramétereket (OUT és IN OUT) pedig alapértelmezés szerint érték szerint adjuk át, és az eredményt másoljuk vissza, de a NOCOPY fordítói utalás használatával referenciaként is átadhatók.^[21]

Egy szintaktikailag hasonló konstrukció a kimeneti paraméterekhez, hogy a visszatérési értéket egy olyan változóhoz rendeljük, amelynek neve megegyezik a függvény nevével. Ez megtalálható a Pascalban és a Fortran 66-ban, valamint a Fortran 77-ben, ahogy ebben a Pascal példában is látható:

function f(x, y: integer): integer;
begin
    f := x + y;
end;

Ez szemantikailag más, mivel meghívásakor a függvény egyszerűen kiértékelődik – nem kap át egy változót a hívó hatókörből a kimenet tárolásához.

A kimeneti paraméterek elsődleges felhasználási módja több érték visszaadása egy függvényből, míg a bemeneti/kimeneti paraméterek felhasználása az állapot módosítása paraméterátadással (a megosztott környezet helyett, mint a globális változók esetében). A több érték visszaadásának egyik fontos felhasználási módja az érték és egy hibaállapot együttes visszaadásának félpredikátum problémájának megoldása.^[22][23]

Például két változó visszaadásához egy C függvényből, a következőt írhatjuk:

int width
int height;

F(x, &width, &height);

ahol x egy bemeneti paraméter, a width és height pedig a kimeneti paraméterek.

A C és rokon nyelvekben egy gyakori használati eset a kivételkezelés, ahol egy függvény a visszatérési értéket egy kimeneti változóba helyezi, és egy logikai értéket ad vissza, amely attól függ, hogy a függvény futása sikeres volt-e vagy sem. Egy archetípusos példa erre a .NET, különösen a C# TryParse metódusa, amely egy karakterláncot egész számmá elemez, siker esetén true, hiba esetén pedig false értéket ad vissza. Ennek a következő szignatúrája van:^[24]

public static bool TryParse(string s, out int result)

és a következőképpen használható:

int result;
if (!Int32.TryParse(s, result)) {
    // exception handling
}

Hasonló megfontolások vonatkoznak a több lehetséges típus egyikének értékének visszaadására, ahol a visszatérési érték megadhatja a típust, majd az érték több kimeneti változó egyikében tárolódik.

A modern programozásban gyakran nem javasolják a kimeneti paraméterek használatát, mivel kényelmetlenek, zavaróak és túl alacsony szintűek – a szokásos visszatérési értékeket lényegesen könnyebb megérteni és kezelni.^[25] Figyelemre méltó, hogy a kimeneti paraméterek mellékhatásokkal járó függvényeket tartalmaznak (a kimeneti paraméter módosítása), és szemantikailag hasonlóak a referenciákhoz, amelyek zavaróbbak, mint a tiszta függvények és értékek, és a kimeneti paraméterek és a bemeneti/kimeneti paraméterek közötti különbségtétel finom lehet. Továbbá, mivel a szokásos programozási stílusokban a legtöbb paraméter egyszerűen bemeneti paraméter, a kimeneti paraméterek és a bemeneti/kimeneti paraméterek szokatlanok, és ezért félreértésekre adnak okot.

A kimeneti és bemeneti/kimeneti paraméterek megakadályozzák a függvények kompozícióját,^[26] mivel a kimenet változókban tárolódik, nem pedig egy kifejezés értékében. Ezért először egy változót kell deklarálni, majd a függvénylánc minden egyes lépésének külön utasításnak kell lennie. Például C++-ban a következő függvénykompozíció:

Object obj = G(y, F(x));

kimeneti és bemeneti/kimeneti paraméterekkel írva ehelyett a következőképpen alakul (F esetén kimeneti paraméter, G esetén bemeneti/kimeneti paraméter):

Object obj;
F(x, &obj);
G(y, &obj);

Abban a speciális esetben, ha egy függvénynek egyetlen kimeneti vagy bemeneti/kimeneti paramétere van, és nincs visszatérési értéke, a függvény kompozíciója akkor lehetséges, ha az output vagy input/output paramétert (vagy C/C++-ban annak címét) a függvény is visszaadja, amely esetben a fentiek a következőképpen alakulnak:

Object obj;
G(y, F(x, &obj));

A kimeneti paraméterek használatára számos alternatíva létezik.

Több érték visszaadására egy függvényből alternatív megoldás egy tuple visszaadása. Szintaktikailag ez egyértelműbb, ha automatikus sorozatkicsomagolás és párhuzamos értékadás használható, mint például a Go-ban vagy a Pythonban, például:

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

Több típus egyikének értékének visszaadásához címkézett uniót^[27] is használhatunk; a leggyakoribb esetek a nullázható típusok, ahol a visszatérési érték null lehet a hiba jelzésére.^[28] Kivételkezeléshez visszaadhatunk egy nullázható típust, vagy kivételt idézhetünk elő. Például Pythonban a következők lehetnek:

result = parse(s)
if result is None:
    # exception handling

vagy, máshogy fogalmazva:

try:
    result = parse(s)
except ParseError:
    # exception handling

A lokális változók mellőzésének és a visszatérési érték másolásának mikrooptimalizálása kimeneti változók használata esetén kellően kifinomult fordítóprogramokkal a hagyományos függvényekre és visszatérési értékekre is alkalmazható.

A C és rokon nyelvekben a kimeneti paraméterek szokásos alternatívája egyetlen adatstruktúra visszaadása, amely az összes visszatérési értéket tartalmazza.^[18] Például, ha adott egy szélességet és magasságot magába foglaló struktúra, akkor a következőt írhatjuk fel:

WidthHeight width_and_height = F(x);

Objektumorientált nyelvekben a bemeneti/kimeneti paraméterek használata helyett gyakran használható a megosztáson alapuló hívás,^[29] amely egy objektumra mutató hivatkozás átadását, majd az objektum mutálását jelenti, anélkül, hogy megváltoztatnánk, hogy a változó melyik objektumra hivatkozik.^[25]

• Parancssoros felhasználói felület

Ez a szócikk részben vagy egészben a Parameter (computer programming) 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.