पैरामीटर (कंप्यूटर प्रोग्रामिंग)

For other uses, see पैरामीटर (बहुविकल्पी).

कंप्यूटर प्रोग्रामिंग में, एक पैरामीटर या एक औपचारिक तर्क एक विशेष प्रकार का चर है जिसका उपयोग उपनेमका में इनपुट के रूप में प्रदान किए गए डेटा के टुकड़ों में से एक को संदर्भित करने के लिए किया जाता है। डेटा के ये टुकड़े तर्कों के मान हैं (जिन्हें प्रायः वास्तविक तर्क या वास्तविक पैरामीटर कहा जाता है) जिसके साथ उपनेमका को बुलाया/आह्वान किया जा रहा है। मापदंडों की एक आदेशित सूची सामान्यतः एक उपनेमका की परिभाषा में सम्मिलित होती है, ताकि हर बार उपनेमका को कॉल किया जाए, उस कॉल के लिए इसके तर्कों का मूल्यांकन किया जाता है, और परिणामी मान संबंधित पैरामीटर को नियुक्त किया जा सकता है।

सामान्य गणितीय उपयोग में तर्क के विपरीत, कंप्यूटर विज्ञान में तर्क एक वास्तविक इनपुट अभिव्यक्ति है जो किसी क्रिया, प्रक्रिया या रूटीन को आह्वान/आह्वान कथन में पास/आपूर्ति की जाती है, जबकि पैरामीटर उपनेमका के कार्यान्वयन के अंदर चर है। उदाहरण के लिए, यदि कोईadd उपनेमका को def add(x, y): return x + yके रूप में परिभाषित करता है, तो x, y पैरामीटर हैं, जबकि अगर इसे add(2, 3)कहा जाता है तब 2, 3 तर्क हैं। ध्यान दें कि आह्वान संदर्भ से चर (और उसके भाव) तर्क हो सकते हैं: यदि उपनेमका को a = 2 कहा जाता है; b = 3; add(a, b) तो चर a, b तर्क हैं, मूल्य 2, 3 नहीं है। अधिक जानकारी के लिए पैरामीटर और तर्क अनुभाग देखें।

मापदंडों को कैसे घोषित किया जा सकता है और उपनेमका के मापदंडों के लिए (मूल्य) तर्कों को कैसे पारित किया जाता है, इसके शब्दार्थ को भाषा की मूल्यांकन रणनीति द्वारा परिभाषित किया जाता है, और किसी विशेष कंप्यूटर प्रणाली में इसका प्रतिनिधित्व कैसे किया जाता है, इसका विवरण उस प्रणाली के आह्वान सम्मेलन पर निर्भर करता है। सबसे सामान्य प्रकरण में, मूल्य से कॉल करें, एक पैरामीटर उपनेमका के अंतर्गत एक नए स्थानीय चर के रूप में कार्य करता है जो तर्क के मान के लिए आरंभिक होता है (यदि तर्क एक चर है तो तर्क की एक स्थानीय (पृथक) प्रति), लेकिन अन्य में प्रकरण में, उदाहरण के लिए संदर्भ द्वारा कॉल, कॉल करने वाले द्वारा प्रदान किया गया तर्क चर उपनेमका कहे जाने वाले कार्यों से प्रभावित हो सकता है।

उदाहरण

C प्रोग्रामिंग भाषा में निम्नलिखित क्रमादेश एक क्रिया को परिभाषित करता है जिसे "सेल्सटैक्स" नाम दिया गया है और इसमें "मूल्य" नाम का एक पैरामीटर है। कीमत का प्रकार "दोगुना" है (अर्थात एक द्विगुण परिशुद्धता चल बिंदु संख्या) है। क्रिया का प्रतिफल प्रकार भी दोहरा है।

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

क्रिया परिभाषित होने के बाद, इसे निम्नानुसार उपयोजित किया जा सकता है:

SalesTax(10.00);

इस उदाहरण में, क्रिया को तर्क 10.00 के साथ उपयोजित किया गया है। जब ऐसा होता है, तो 10.00 मूल्य निर्धारित किया जाएगा, और क्रिया इसके परिणाम की गणना करना प्रारंभ कर देता है। परिणाम प्रस्तुत करने के कदम नीचे दिए गए हैं, {} में संलग्न हैं। 0.05 * price इंगित करता है कि सबसे पहले मूल्य के मूल्य से 0.05 को गुणा करना है, जो 0.50 returnदेता है जिसका अर्थ है कि क्रिया 0.05 * priceके परिणाम का उत्पादन करेगा। इसलिए, अंतिम परिणाम (बाइनरी अंशों के रूप में दशमलव अंशों का प्रतिनिधित्व करने के साथ सामना करने वाली संभावित निकटन त्रुटियों को उपेक्षित करना) 0.50 है।

पैरामीटर और तर्क

विभिन्न प्रोग्रामिंग भाषाओं में पैरामीटर और तर्क के अलग-अलग अर्थ हो सकते हैं। कभी-कभी उनका उपयोग परस्पर विनिमय के लिए किया जाता है, और अर्थ को अलग करने के लिए संदर्भ का उपयोग किया जाता है। शब्द पैरामीटर (कभी-कभी औपचारिक पैरामीटर कहा जाता है) का उपयोग प्रायः क्रिया परिभाषा में पाए जाने वाले चर को संदर्भित करने के लिए किया जाता है, जबकि तर्क (कभी-कभी वास्तविक पैरामीटर कहा जाता है) क्रिया कॉल पर प्रदान किए गए वास्तविक इनपुट को संदर्भित करता है। उदाहरण के लिए, यदि कोई क्रिया को def f(x): ... के रूप में परिभाषित करता है, तब x पैरामीटर है, और यदि इसे a = ...; f(a)कहा जाता है तो a तर्क है। एक पैरामीटर एक (अपरिबद्ध) चर है, जबकि तर्क एक शाब्दिक (कंप्यूटर प्रोग्रामिंग) या चर या अधिक जटिल अभिव्यक्ति हो सकता है जिसमें शाब्दिक और चर सम्मिलित हैं। मान आह्वान के प्रकरण में, क्रिया को जो पास किया जाता है वह तर्क का मान है - उदाहरण के लिए, f(2) और a = 2; f(a) समतुल्य कॉल हैं - संदर्भ द्वारा कॉल करते समय, तर्क के रूप में एक चर के साथ, जो पारित किया जाता है वह उस चर का एक संदर्भ है - भले ही क्रिया कॉल के लिए वाक्य विन्यास वही रह सकता है। क्रिया घोषणा और/या परिभाषा में उत्तीर्ण-द्वारा-संदर्भ या उत्तीर्ण-द्वारा-मूल्य के लिए विनिर्देश बनाए जाएंगे।

प्रक्रिया परिभाषाओं में पैरामीटर दिखाई देते हैं; प्रक्रिया कॉल में तर्क प्रकट होते हैं। क्रिया परिभाषा में f(x) = x*x चर x एक पैरामीटर है; क्रिया कॉल में f(2) मान 2 क्रिया का तर्क है। संक्षेप में, एक पैरामीटर एक प्रकार है, और एक तर्क एक उदाहरण है।

एक पैरामीटर प्रक्रिया का एक आंतरिक गुण है, इसकी परिभाषा में सम्मिलित है। उदाहरण के लिए, कई भाषाओं में, दो प्रदान किए गए पूर्णांकों को एक साथ जोड़ने और योग की गणना करने की प्रक्रिया में प्रत्येक पूर्णांक के लिए एक, दो पैरामीटर की आवश्यकता होगी। सामान्य रूप में, एक प्रक्रिया को कई मापदंडों के साथ परिभाषित किया जा सकता है, या कोई भी पैरामीटर के साथ नहीं परिभाषित किया जा सकता है। यदि किसी प्रक्रिया में पैरामीटर हैं, तो उसकी परिभाषा का वह भाग जो पैरामीटर निर्दिष्ट करता है, उसकी पैरामीटर सूची कहलाती है।

इसके विपरीत, तर्क उस प्रक्रिया को प्रदान किए गए भाव हैं जब इसे कहा जाता है, सामान्यतः एक अभिव्यक्ति जो किसी एक पैरामीटर से अनुकूल है। मापदंडों के विपरीत, जो प्रक्रिया की परिभाषा का एक अपरिवर्तनीय भाग है, तर्क कॉल से कॉल में भिन्न हो सकते हैं। प्रत्येक बार एक प्रक्रिया को कॉल किया जाता है, प्रक्रिया कॉल का भाग जो तर्कों को निर्दिष्ट करता है उसे तर्क सूची कहा जाता है।

यद्यपि मापदंडों को सामान्यतः तर्कों के रूप में संदर्भित किया जाता है, तर्कों को कभी-कभी वास्तविक मान या पैरामीटर चर के संदर्भ के रूप में माना जाता है जब उपनेमका को कार्यावधि पर बुलाया जाता है। उपनेमका में कॉल करने वाले कोड पर चर्चा करते समय, उपनेमका में पारित कोई भी मान या संदर्भ तर्क होते हैं, और कोड में वह स्थान जहां ये मान या संदर्भ दिए जाते हैं, पैरामीटर सूची है। उपनेमका परिभाषा के अंदर कोड पर चर्चा करते समय, उपनेमका की पैरामीटर सूची में चर पैरामीटर होते हैं, जबकि कार्यावधि पर पैरामीटर के मान तर्क होते हैं। उदाहरण के लिए, C में, क्रम से वितरण के समय शून्य * प्रकार के तर्क में पास होना सामान्य बात है और इसे अपेक्षित प्रकार में डाला जाता है:

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.
}

अंतर को अधिक समझने के लिए, C में लिखे गए निम्नलिखित क्रिया पर विचार करें:

int Sum(int addend1, int addend2)
{
  return addend1 + addend2;
}

क्रिया योग के दो पैरामीटर हैं, जिनका नाम addend1 और addend2 है। यह मापदंडों में दिए गए मान जोड़ता है, और उपनेमका के कॉलर को परिणाम देता है (C अनुभाषक द्वारा स्वचालित रूप से आपूर्ति की गई तकनीक का उपयोग करके)।

सम क्रिया को कॉल करने वाला कोड इस तरह दिखाई दे सकता है:

int value1 = 40;
int value2 = 2;
int sum_value = Sum(value1, value2);

चर value1 और value2 मानों के साथ प्रारंभ किए गए हैं। इस संदर्भ में, value1 और value2, दोनों योग क्रिया के लिए तर्क हैं।

कार्यावधि पर, इन परिवर्त्य को नियुक्त किए गए मान क्रिया योग को तर्कों के रूप में पास किए जाते हैं। Sum क्रिया में, पैरामीटर addend1 और addend2 का मूल्यांकन किया जाता है, जिससे क्रमशः तर्क 40 और 2 प्राप्त होते हैं। तर्कों के मान जोड़े जाते हैं, और परिणाम कॉलर को वापस कर दिया जाता है, जहां इसे चर योग मूल्य को नियुक्त किया जाता है।

मापदंडों और तर्कों के मध्य अंतर के कारण, किसी प्रक्रिया को अनुचित तर्क देना संभव है। कॉल बहुत अधिक या बहुत कम तर्क प्रदान कर सकता है; एक या अधिक तर्क गलत प्रकार के हो सकते हैं; या तर्क गलत क्रम में दिए जा सकते हैं। इनमें से कोई भी स्थिति पैरामीटर और तर्क सूचियों के मध्य अवतरण का कारण बनती है, और प्रक्रिया प्रायः अनपेक्षित उत्तर देती है या कार्यावधि त्रुटि उत्पन्न करती है।

एफिल में वैकल्पिक सम्मेलन

एफिल (प्रोग्रामिंग लैंग्वेज) सॉफ्टवेयर डेवलपमेंट मेथड और लैंग्वेज के अंतर्गत, कन्वेंशन द्वारा स्थापित तर्क और पैरामीटर के अलग-अलग उपयोग हैं। शब्द तर्क विशेष रूप से नियमित इनपुट के संदर्भ में प्रयोग किया जाता है, और टर्म पैरामीटर का उपयोग विशेष रूप से सामान्य प्रोग्रामिंग के लिए टाइप पैरामीटराइजेशन में किया जाता है। निम्नलिखित नियमित परिभाषा पर विचार करें:

    sum (addend1: INTEGER; addend2: INTEGER): INTEGER
        do
            Result := addend1 + addend2
        end

दिनचर्या sum दो तर्क लेता है addend1 और addend2, जिन्हें रूटीन का औपचारिक तर्क कहा जाता है। को एक कॉल sum वास्तविक तर्कों को निर्दिष्ट करता है, जैसा कि नीचे दिखाया गया है value1 और value2.

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

पैरामीटर्स को या तो औपचारिक या वास्तविक माना जाता है। सामान्य वर्ग की परिभाषा में औपचारिक सामान्य पैरामीटर का उपयोग किया जाता है। नीचे दिए गए उदाहरण में, class HASH_TABLE एक सामान्य वर्ग के रूप में घोषित किया गया है जिसमें दो औपचारिक सामान्य पैरामीटर हैं, G ब्याज के डेटा का प्रतिनिधित्व और K डेटा के लिए हैश कुंजी का प्रतिनिधित्व करना:

class HASH_TABLE [G, K -> HASHABLE] 
            …

जब एक वर्ग ग्राहक बन जाता है HASH_TABLE, एक सामान्य व्युत्पत्ति में औपचारिक सामान्य मापदंडों को वास्तविक सामान्य मापदंडों के साथ प्रतिस्थापित किया जाता है। निम्नलिखित विशेषता घोषणा में, my_dictionary एक वर्ण स्ट्रिंग आधारित साहचर्य सरणी के रूप में उपयोग किया जाना है। इस प्रकार, डेटा और प्रमुख औपचारिक सामान्य पैरामीटर दोनों प्रकार के वास्तविक सामान्य पैरामीटर के साथ प्रतिस्थापित किए जाते हैं STRING.

    my_dictionary: HASH_TABLE [STRING, STRING]

डेटा प्रकार

दृढ़ता से टाइप की गई प्रोग्रामिंग भाषाओं में, प्रत्येक पैरामीटर के डेटाटाइप को प्रक्रिया घोषणा में निर्दिष्ट किया जाना चाहिए। प्रकार अनुमान का उपयोग करने वाली भाषाएं क्रिया के शरीर और उपयोग से स्वचालित रूप से प्रकारों को खोजने का प्रयास करती हैं। डायनामिक रूप से टाइप की गई प्रोग्रामिंग लैंग्वेज रन-टाइम तक टाइप रेजोल्यूशन को डिफर करती हैं। कमजोर रूप से टाइप की गई भाषाएँ शुद्धता के लिए प्रोग्रामर पर निर्भर होने के बजाय, बिना किसी प्रकार के संकल्प के बहुत कम प्रदर्शन करती हैं।

कुछ भाषाएँ यह इंगित करने के लिए एक विशेष कीवर्ड (जैसे शून्य) का उपयोग करती हैं कि उपनेमका का कोई पैरामीटर नहीं है; औपचारिक प्रकार सिद्धांत में, ऐसे कार्य एक खाली पैरामीटर सूची लेते हैं (जिसका प्रकार शून्य नहीं है, बल्कि इकाई प्रकार है)।

तर्क पासिंग

मापदंडों को तर्क देने के लिए सटीक तंत्र, जिसे तर्क पारित करना कहा जाता है, उस पैरामीटर के लिए उपयोग की जाने वाली मूल्यांकन रणनीति पर निर्भर करता है (सामान्यतः मूल्य द्वारा कॉल किया जाता है), जिसे कीवर्ड का उपयोग करके निर्दिष्ट किया जा सकता है।

डिफ़ॉल्ट तर्क

कुछ प्रोग्रामिंग लैंग्वेज जैसे Ada (प्रोग्रामिंग लैंग्वेज), C++, क्लोजर, सामान्य लिस्प, फोरट्रान 90, पायथन (प्रोग्रामिंग लैंग्वेज), रूबी (प्रोग्रामिंग भाषा) , Tcl (प्रोग्रामिंग लैंग्वेज), और विंडोज पॉवरशेल उपनेमका की घोषणा में डिफ़ॉल्ट तर्क को स्पष्ट रूप से या निहित रूप से दिए जाने की अनुमति दें। यह कॉल करने वाले को उपनेमका को कॉल करते समय उस तर्क को छोड़ने की अनुमति देता है। यदि डिफ़ॉल्ट तर्क स्पष्ट रूप से दिया गया है, तो कॉलर द्वारा प्रदान नहीं किए जाने पर उस मान का उपयोग किया जाता है। यदि डिफ़ॉल्ट तर्क अंतर्निहित है (कभी-कभी वैकल्पिक जैसे कीवर्ड का उपयोग करके) तो भाषा एक प्रसिद्ध मान प्रदान करती है (जैसे शून्य सूचक, खाली, शून्य, एक खाली स्ट्रिंग, आदि) यदि कोई मान प्रदान नहीं किया जाता है फोन करने वाला।

पॉवरशेल उदाहरण:

function doc($g = 1.21) {
    "$g gigawatts? $g gigawatts? Great Scott!"
}

<वाक्यविन्यास प्रकाश लैंग = ps1con> पीएस> डॉक्टर 1.21 गीगावाट? 1.21 गीगावाट? महान स्काट!

पीएस> डॉक्टर 88 88 गीगावाट? 88 गीगावाट? महान स्काट! </वाक्यविन्यास हाइलाइट> डिफ़ॉल्ट तर्कों को चर-लंबाई तर्क सूची के विशेष प्रकरण के रूप में देखा जा सकता है।

चर-लंबाई पैरामीटर सूची

कुछ भाषाएँ उपनेमका्स को वैराडिक क्रिया को स्वीकार करने के लिए परिभाषित करने की अनुमति देती हैं। ऐसी भाषाओं के लिए, उपनेमका्स को तर्कों की सूची के माध्यम से पुनरावृति करनी चाहिए।

पॉवरशेल उदाहरण:

function marty {
    $args | foreach { "back to the year $_" }
}

<वाक्यविन्यास प्रकाश लैंग = ps1con> पीएस> मार्टी 1985 वर्ष 1985 में वापस

पीएस> मार्टी 2015 1985 1955 वर्ष 2015 तक वापस वर्ष 1985 में वापस वर्ष 1955 में वापस </वाक्यविन्यास हाइलाइट>

नामित पैरामीटर

कुछ प्रोग्रामिंग लैंग्वेज- जैसे एडा (प्रोग्रामिंग लैंग्वेज) और विंडोज पॉवरशेल- उपनेमका्स को पैरामीटर्स नाम देने की अनुमति देते हैं। यह आह्वान कोड को अधिक स्व-दस्तावेजीकरण करने की अनुमति देता है। यह कॉल करने वाले को अधिक लचीलापन भी प्रदान करता है, प्रायः तर्कों के क्रम को बदलने की अनुमति देता है, या आवश्यकतानुसार तर्कों को छोड़ दिया जाता है।

पॉवरशेल उदाहरण:

function jennifer($adjectiveYoung, $adjectiveOld) {
    "Young Jennifer: I'm $adjectiveYoung!"
    "Old Jennifer: I'm $adjectiveOld!"
}

<वाक्यविन्यास प्रकाश लैंग = ps1con>

पुनश्च> जेनिफर 'ताजा' 'अनुभवी' युवा जेनिफर: मैं ताज़ा हूँ! ओल्ड जेनिफर: मैं अनुभवी हूँ!

पीएस > जेनिफर -विशेषणपुराना 'अनुभवी' -विशेषणयुवा 'ताजा' युवा जेनिफर: मैं ताज़ा हूँ! ओल्ड जेनिफर: मैं अनुभवी हूँ! </वाक्यविन्यास हाइलाइट>

कार्यात्मक भाषाओं में एकाधिक पैरामीटर

लैम्ब्डा कैलकुस में, प्रत्येक क्रिया में बिल्कुल एक पैरामीटर होता है। कई मापदंडों वाले कार्यों के बारे में क्या सोचा जाता है, सामान्यतः लैम्ब्डा कैलकुलस में एक क्रिया के रूप में दर्शाया जाता है जो पहला तर्क लेता है, और एक क्रिया देता है जो बाकी तर्कों को लेता है; यह एक परिवर्तन है जिसे करींग के रूप में जाना जाता है। कुछ प्रोग्रामिंग लैंग्वेज, जैसे एमएल (प्रोग्रामिंग भाषा) और हास्केल (प्रोग्रामिंग भाषा) , इस योजना का पालन करती हैं। इन भाषाओं में, प्रत्येक क्रिया में बिल्कुल एक पैरामीटर होता है, और जो कई पैरामीटर के क्रिया की परिभाषा की तरह दिख सकता है, वास्तव में क्रिया की परिभाषा के लिए सिंटैक्टिक चीनी है जो क्रिया देता है, आदि। क्रिया आवेदन ऑपरेटर सहयोगीता है। बाएं- इन भाषाओं के साथ-साथ लैम्ब्डा कैलकुस में सहयोगी, इसलिए एकाधिक तर्कों के लिए क्रिया के अनुप्रयोग की तरह क्या दिखता है, पहले तर्क पर उपयोजित क्रिया के रूप में सही ढंग से मूल्यांकन किया जाता है, फिर परिणामी क्रिया दूसरे तर्क पर उपयोजित होता है, आदि।

आउटपुट पैरामीटर

आउटपुट पैरामीटर, जिसे आउट पैरामीटर या प्रतिफल पैरामीटर के रूप में भी जाना जाता है, इनपुट के अधिक सामान्य उपयोग के बजाय आउटपुट के लिए उपयोग किया जाने वाला पैरामीटर है। संदर्भ मापदंडों द्वारा कॉल का उपयोग करना, या मूल्य मापदंडों द्वारा कॉल करना जहां मूल्य एक संदर्भ है, क्योंकि आउटपुट पैरामीटर कुछ भाषाओं में एक मुहावरा है, विशेष रूप से C और C++, जबकि अन्य भाषाओं में आउटपुट पैरामीटर के लिए अंतर्निहित समर्थन है। आउटपुट पैरामीटर के लिए अंतर्निहित समर्थन वाली भाषाओं में एडा (प्रोग्रामिंग भाषा) सम्मिलित है (बी देखें: एडीए प्रोग्रामिंग/उपप्रोग्राम), फोरट्रान (फोरट्रान 90 के बाद से; बी देखें: फोरट्रान/फोरट्रान प्रक्रियाएं और कार्य#इरादा|फोरट्रान इरादा), एसक्यूएल के लिए विभिन्न प्रक्रियात्मक एक्सटेंशन, जैसे पीएल/एसक्यूएल (पीएल/एसक्यूएल#क्रिया देखें) |पीएल/एसक्यूएल कार्य) और Transact-SQL, C Sharp (प्रोग्रामिंग लैंग्वेज)|C# और .NET फ्रेमवर्क, स्विफ्ट (प्रोग्रामिंग भाषा), और स्क्रिप्टिंग भाषा टीस्क्रिप्ट (देखें टीस्क्रिप्ट#क्रिया डिक्लेरेशन)।

अधिक सटीक रूप से, कोई तीन प्रकार के पैरामीटर या पैरामीटर मोड में अंतर कर सकता है: input parameterएस, आउटपुट पैरामीटर, औरinput/output parameterएस; इन्हें प्रायः निरूपित किया जाता है in, out, और in out या inout. एक इनपुट तर्क (इनपुट पैरामीटर के लिए तर्क) एक मान होना चाहिए, जैसे प्रारंभिक चर या शाब्दिक, और इसे फिर से परिभाषित या नियुक्त नहीं किया जाना चाहिए; एक आउटपुट तर्क एक नियुक्त करने योग्य चर होना चाहिए, लेकिन इसे प्रारंभ करने की आवश्यकता नहीं है, कोई मौजूदा मान पहुंच योग्य नहीं है, और इसे एक मान निर्दिष्ट किया जाना चाहिए; और एक इनपुट/आउटपुट तर्क एक प्रारंभिक, नियुक्त करने योग्य चर होना चाहिए, और वैकल्पिक रूप से एक मान नियुक्त किया जा सकता है। भाषाओं के मध्य सटीक आवश्यकताएं और प्रवर्तन अलग-अलग होते हैं - उदाहरण के लिए, Ada 83 में आउटपुट पैरामीटर केवल नियुक्त किए जा सकते हैं, पढ़े नहीं, नियुक्तमेंट के बाद भी (इसे Ada 95 में एक सहायक संचायक चर की आवश्यकता को हटाने के लिए हटा दिया गया था)। ये एक आर-वैल्यू (एक वैल्यू है), एक एल-वैल्यू (नियुक्त किया जा सकता है), या एक आर-वैल्यू/एल-वैल्यू (एक वैल्यू है) के एक्सप्रेशन में मूल्य (कंप्यूटर विज्ञान) की धारणा के अनुरूप हैं। और नियुक्त किया जा सकता है), क्रमशः, हालांकि इन शब्दों का सी में विशेष अर्थ है।

कुछ मामलों में केवल इनपुट और इनपुट/आउटपुट को अलग किया जाता है, आउटपुट को इनपुट/आउटपुट का एक विशिष्ट उपयोग माना जाता है, और अन्य मामलों में केवल इनपुट और आउटपुट (लेकिन इनपुट/आउटपुट नहीं) समर्थित होते हैं। डिफ़ॉल्ट मोड भाषाओं के मध्य भिन्न होता है: फोरट्रान में 90 इनपुट/आउटपुट डिफ़ॉल्ट है, जबकि C# और SQL एक्सटेंशन में इनपुट डिफ़ॉल्ट है, और TScript में प्रत्येक पैरामीटर को इनपुट या आउटपुट के रूप में स्पष्ट रूप से निर्दिष्ट किया गया है।

सिंटैक्टिक रूप से, पैरामीटर मोड को सामान्यतः क्रिया डिक्लेरेशन में एक कीवर्ड के साथ इंगित किया जाता है, जैसे void f(out int x) सी # में। परंपरागत रूप से आउटपुट पैरामीटर को प्रायः पैरामीटर सूची के अंत में स्पष्ट रूप से अलग करने के लिए रखा जाता है, हालांकि इसका हमेशा पालन नहीं किया जाता है। TScript एक अलग दृष्टिकोण का उपयोग करता है, जहां क्रिया डिक्लेरेशन में इनपुट पैरामीटर सूचीबद्ध होते हैं, फिर आउटपुट पैरामीटर, एक कोलन (:) द्वारा अलग किए जाते हैं और क्रिया में स्वयं कोई प्रतिफल प्रकार नहीं होता है, जैसा कि इस क्रिया में होता है, जो टेक्स्ट के आकार की गणना करता है टुकड़ा:

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

पैरामीटर मोड सांकेतिक शब्दार्थ का एक रूप है, जो प्रोग्रामर के इरादे को बताता है और अनुभाषक्स को त्रुटियों को पकड़ने और ऑप्टिमाइज़ेशन उपयोजित करने की अनुमति देता है - वे अनिवार्य रूप से परिचालन सिमेंटिक्स (कैसे पैरामीटर पासिंग वास्तव में होता है) को उपयोजित नहीं करते हैं। विशेष रूप से, हालांकि इनपुट पैरामीटर्स को कॉल बाई वैल्यू द्वारा उपयोजित किया जा सकता है, और आउटपुट और इनपुट/आउटपुट पैरामीटर्स को कॉल बाई रेफरेंस द्वारा उपयोजित किया जा सकता है - और यह बिना बिल्ट-इन सपोर्ट के भाषाओं में इन मोड्स को उपयोजित करने का एक सीधा तरीका है - यह हमेशा ऐसा नहीं होता है। कार्यान्वित। इस भेद पर Ada '83 Rationale में विस्तार से चर्चा की गई है, जो इस बात पर जोर देता है कि पैरामीटर मोड सारगर्भित है जिससे पैरामीटर पासिंग मैकेनिज्म (संदर्भ द्वारा या प्रतिलिपि द्वारा) वास्तव में कार्यान्वित किया जाता है।उदाहरण के लिए, जबकि C# में इनपुट पैरामीटर (डिफ़ॉल्ट, कोई कीवर्ड नहीं) मान द्वारा पास किए जाते हैं, और आउटपुट और इनपुट/आउटपुट पैरामीटर (out और ref) पीएल/एसक्यूएल इनपुट पैरामीटर में संदर्भ द्वारा पारित किया जाता है (IN) संदर्भ द्वारा पारित किया जाता है, और आउटपुट और इनपुट/आउटपुट पैरामीटर (OUT और IN OUT) डिफ़ॉल्ट रूप से मान द्वारा पास किए जाते हैं और परिणाम वापस कॉपी किया जाता है, लेकिन इसका उपयोग करके संदर्भ द्वारा पारित किया जा सकता है NOCOPY संकलक संकेत। आउटपुट पैरामीटर के लिए एक वाक्य रचनात्मक रूप से समान निर्माण क्रिया के समान नाम वाले चर के लिए वापसी मान निर्दिष्ट करना है। यह पास्कल (प्रोग्रामिंग भाषा) और फोरट्रान 66 और फोरट्रान 77 में पाया जाता है, जैसा कि इस पास्कल उदाहरण में है:

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

यह शब्दार्थ से भिन्न है कि जब कॉल किया जाता है, तो क्रिया का मूल्यांकन किया जाता है - आउटपुट को स्टोर करने के लिए आह्वान स्कोप (कंप्यूटर साइंस) से एक चर पारित नहीं किया जाता है।

प्रयोग

आउटपुट पैरामीटर का प्राथमिक उपयोग क्रिया से एकाधिक मान वापस करना है, जबकि इनपुट/आउटपुट पैरामीटर का उपयोग पैरामीटर पासिंग का उपयोग करके राज्य को संशोधित करना है (साझा वातावरण के बजाय, वैश्विक चर के रूप में)। एकाधिक मानों को वापस करने का एक महत्वपूर्ण उपयोग एक मान और एक त्रुटि स्थिति दोनों को वापस करने की अर्धसूत्रीविभाजन समस्या को हल करना है - सेमीप्रिडिकेट समस्या # मल्टीवैल्यूड प्रतिफल देखें। सेमिप्रिडिकेट समस्या: मल्टीवैल्यूड प्रतिफल।

उदाहरण के लिए, सी में किसी क्रिया से दो चर वापस करने के लिए, कोई लिख सकता है:

int width
int height;

F(x, &width, &height);

कहाँ x एक इनपुट पैरामीटर है और width और height आउटपुट पैरामीटर हैं।

सी और संबंधित भाषाओं में एक सामान्य उपयोग मामला अपवाद से निपटने के लिए है, जहां एक क्रिया प्रतिफल मान को आउटपुट चर में रखता है, और क्रिया सफल हुआ या नहीं, इसके अनुरूप एक बूलियन देता है। एक आदर्श उदाहरण है TryParse .NET में विधि, विशेष रूप से C#, जो एक स्ट्रिंग को एक पूर्णांक में पार्स करती है, वापस लौटती है true सफलता पर और false असफलता पर। इसमें निम्नलिखित हस्ताक्षर हैं:

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

और इस तरह इस्तेमाल किया जा सकता है:

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

इसी तरह के विचार कई संभावित प्रकारों में से एक के मूल्य को वापस करने के लिए उपयोजित होते हैं, जहां वापसी मूल्य प्रकार निर्दिष्ट कर सकता है और फिर कई आउटपुट चरों में से एक में मूल्य संग्रहीत किया जाता है।

कमियां

आधुनिक प्रोग्रामिंग में आउटपुट मापदंडों को प्रायः हतोत्साहित किया जाता है, अनिवार्य रूप से अजीब, भ्रामक और बहुत निम्न-स्तर के रूप में - सामान्य प्रतिफल मान समझने और काम करने में काफी आसान होते हैं। विशेष रूप से, आउटपुट पैरामीटर में साइड इफेक्ट्स (आउटपुट पैरामीटर को संशोधित करना) के साथ कार्य सम्मिलित होते हैं और शब्दार्थ संदर्भ के समान होते हैं, जो शुद्ध कार्यों और मूल्यों की तुलना में अधिक भ्रमित होते हैं, और आउटपुट पैरामीटर और इनपुट/आउटपुट पैरामीटर के मध्य अंतर सूक्ष्म हो सकता है। इसके अलावा, चूंकि सामान्य प्रोग्रामिंग शैलियों में अधिकांश पैरामीटर केवल इनपुट पैरामीटर हैं, आउटपुट पैरामीटर और इनपुट/आउटपुट पैरामीटर असामान्य हैं और इसलिए गलतफहमी के लिए अतिसंवेदनशील हैं।

आउटपुट और इनपुट/आउटपुट पैरामीटर क्रिया संरचना (कंप्यूटर विज्ञान) को रोकते हैं, क्योंकि आउटपुट अभिव्यक्ति के मूल्य के बजाय चर में संग्रहीत होता है। इस प्रकार किसी को प्रारंभ में एक चर घोषित करना चाहिए, और फिर कार्यों की श्रृंखला के प्रत्येक चरण को एक अलग कथन होना चाहिए। उदाहरण के लिए, सी ++ में निम्न क्रिया संरचना:

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

जब आउटपुट और इनपुट/आउटपुट पैरामीटर के साथ लिखा जाता है तो इसके बजाय (for F यह एक आउटपुट पैरामीटर है, के लिए G एक इनपुट/आउटपुट पैरामीटर):

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

एकल आउटपुट या इनपुट/आउटपुट पैरामीटर वाले क्रिया के विशेष प्रकरण में और कोई वापसी मान नहीं, क्रिया संयोजन संभव है यदि आउटपुट या इनपुट/आउटपुट पैरामीटर (या C/C++ में, इसका पता) भी क्रिया द्वारा लौटाया जाता है, जिस स्थिति में उपरोक्त बन जाता है:

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

विकल्प

आउटपुट पैरामीटर के उपयोग के मामलों के लिए कई विकल्प हैं।

किसी क्रिया से एकाधिक मान वापस करने के लिए, एक विकल्प टपल वापस करना है। यदि स्वचालित अनुक्रम अनपैकिंग और समानांतर नियुक्तमेंट का उपयोग जाओ (प्रोग्रामिंग भाषा) या पायथन में किया जा सकता है, तो सिंटैक्टिक रूप से यह स्पष्ट है:

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

कई प्रकारों में से किसी एक का मान लौटाने के लिए, इसके बजाय टैग किए गए संघ का उपयोग किया जा सकता है; सबसे आम प्रकरण अशक्त प्रकार (विकल्प प्रकार) हैं, जहां वापसी मूल्य विफलता को इंगित करने के लिए शून्य हो सकता है। अपवाद से निपटने के लिए, कोई अशक्त प्रकार वापस कर सकता है, या एक अपवाद बढ़ा सकता है। उदाहरण के लिए, पायथन में या तो हो सकता है:

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

या, अधिक मुहावरेदार:

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

स्थानीय चर की आवश्यकता नहीं होने और आउटपुट चर का उपयोग करते समय प्रतिफल की प्रतिलिपि बनाने के माइक्रो-ऑप्टिमाइज़ेशन को पारंपरिक कार्यों पर भी उपयोजित किया जा सकता है और पर्याप्त रूप से परिष्कृत अनुभाषकों द्वारा मूल्यों को लौटाया जा सकता है।

सी और संबंधित भाषाओं में आउटपुट पैरामीटर का सामान्य विकल्प सभी प्रतिफल वैल्यू वाले एकल डेटा संरचना को वापस करना है।उदाहरण के लिए, चौड़ाई और ऊंचाई को घेरने वाली संरचना दी गई है, कोई लिख सकता है:

WidthHeight width_and_height = F(x);

ऑब्जेक्ट-ओरिएंटेड भाषाओं में, इनपुट/आउटपुट पैरामीटर का उपयोग करने के बजाय, एक व्यक्ति प्रायः साझा करके कॉल का उपयोग कर सकता है, किसी ऑब्जेक्ट के संदर्भ को पास कर सकता है और फिर ऑब्जेक्ट को म्यूट कर सकता है, हालांकि चर किस ऑब्जेक्ट को संदर्भित नहीं करता है।

यह भी देखें

• कमांड-लाइन तर्क
• मूल्यांकन रणनीति
• ऑपरेटर ओवरलोडिंग
• मुक्त चर और बाध्य चर