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

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

C++ में डिफ़ॉल्ट आर्गुमेंट

निम्नलिखित फ़ंक्शन घोषणा पर विचार करें:

int MyFunc(int a, int b, int c = 12);

यह फ़ंक्शन तीन आर्गुमेंट लेता है, जिनमें से अंतिम में बारह का डिफ़ॉल्ट होता है। प्रोग्रामर इस फ़ंक्शन को दो प्रकारो से कॉल कर सकता है:

int result = MyFunc(1, 2, 3);
result = MyFunc(1, 2);

पहली स्थिति में c नामक आर्गुमेंट का मान स्पष्ट रूप से निर्दिष्ट किया गया है। दूसरी स्थिति में, आर्गुमेंट छोड़ दिया जाता है, और इसके अतिरिक्त 12 के डिफ़ॉल्ट मान का उपयोग किया जाता था।

कॉल किए गए फ़ंक्शन के लिए, यह जानने का कोई साधन नहीं है कि कॉल करने वाले द्वारा आर्गुमेंट निर्दिष्ट किया गया है या यदि डिफ़ॉल्ट मान का उपयोग किया गया था।

उपर्युक्त विधि विशेष रूप से तब उपयोगी होती है जब कोई डिफ़ॉल्ट मानदंड सेट करना चाहता है जिससे की फ़ंक्शन को मापदंड के साथ या बिना कॉल किया जा सकता हैं।

निम्न पर विचार करें:

void PrintGreeting(std::ostream& stream = std::cout) {
  // This outputs a message to the given stream.
  stream << "hello world!";
}

प्रोग्राम कॉल:

PrintGreeting();

डिफ़ॉल्ट रूप से "हैलो वर्ल्ड" प्रिंट करता हैं ! मानक आउटपुट के लिए std::cout (साधारण तौर पर स्क्रीन)। दूसरी ओर, प्रकार की कोई वस्तु std::ostream अब उसी फ़ंक्शन में पास किया जा सकता है और फ़ंक्शन मानक आउटपुट के स्थान पर दी गई स्ट्रीम पर प्रिंट करता हैं। नीचे दिया गया उदाहरण सेट करता है std::ostream& को std::cerr, और इस प्रकार आउटपुट को मानक त्रुटि स्ट्रीम प्रिंट करता है।

PrintGreeting(std::cerr);

क्योंकि डिफ़ॉल्ट आर्गुमेंट के मान कॉल फ़ंक्शन के मुख्य भाग के स्थान कॉल साइट पर ''फीलड इन'' हैं, वर्चुअल फ़ंक्शंस उनके डिफ़ॉल्ट आर्गुमेंट मानों को पॉइंटर या संदर्भ के स्थिर प्रकार से लेते हैं, जिसके माध्यम से कॉल किया जाता है, अतिरिक्त इसके वर्चुअल फंक्शन बॉडी की आपूर्ति करने वाली वस्तु का गतिशील प्रकार का होता हैं।

struct Base {
  virtual std::pair<int, int> Foo(int x = 1) {
    return {x, 1};
  }
};

struct Derived : public Base {
  std::pair<int, int> Foo(int x = 2) override {
    return {x, 2};
  }
};

int main() {
  Derived d;
  Base& b = d;
  assert(d.Foo() == std::make_pair(2, 2));
  assert(b.Foo() == std::make_pair(1, 2));
}

ओवरलोडेड विधिया

कुछ भाषाएँ, जैसे कि जावा (प्रोग्रामिंग भाषा), में डिफ़ॉल्ट आर्गुमेंट नहीं होते हैं। यद्यपि की, एक ही नाम के ओवरलोडेड विधि को बनाने के लिए विधि ओवरलोडिंग का उपयोग करके एक ही व्यवहार को अनुकरण किया जा सकता है, जो विभिन्न संख्या में आर्गुमेंट लेते हैं; और कम आर्गुमेंट वाले संस्करण केवल अधिक आर्गुमेंट वाले संस्करणों को कॉल करते हैं, डिफ़ॉल्ट आर्गुमेंट को मिसिंग आर्गुमेंट के रूप में कहते हैं:

int MyFunc(int a, int b) { return MyFunc(a, b, 12); }
int MyFunc(int a, int b, int c) { /* main implementation here */ }

यद्यपि की, कई अन्य नुकसान के अतिरिक्त, चूंकि डिफ़ॉल्ट आर्गुमेंट को टाइप सिस्टम में मॉडल नहीं किया गया है, कॉलबैक का प्रकार (अर्थात उच्च-क्रम फ़ंक्शन) यह व्यक्त नहीं कर सकता कि यह ओवरलोड में से किसी एक को स्वीकार करता है और न ही ओवरलोडेड फ़ंक्शंस के साथ डिफ़ॉल्ट आर्गुमेंट का अनुकरण करता है। जबकि, जावास्क्रिप्ट में गैर-ओवरलोडेड फ़ंक्शन परिभाषा इनपुट मान होने पर डिफ़ॉल्ट को प्रतिस्थापित कर सकती है undefined (भले ही यह निहित था undefined कॉल साइट पर आर्गुमेंट की अनुपस्थिति या स्पष्ट रूप से पारित होने के माध्यम से undefined मूल्य); जिसे एक वैकल्पिक आर्गुमेंट मापदंड प्रकार के रूप में तैयार किया गया है ?: टाइपस्क्रीप्ट में। जावास्क्रिप्ट का समाधान स्थिर रूप से हल नहीं किया गया है (अर्थात् संकलन-समय पर नहीं, यही कारण है कि टाइपस्क्रिप्ट केवल वैकल्पिकता को मॉडल करता है और फ़ंक्शन के प्रकार संकेत में डिफ़ॉल्ट मान नहीं) इस प्रकार अतिरिक्त रनटाइम ओवरहेड होता है, यद्यपि की यह उस कॉलबैक में अधिक सुगमता प्रदान करता है, जो कॉलबैक इनपुट के फ़ंक्शन के टाइप संकेत (कॉलबैक के प्रकार संकेत) द्वारा केंद्रीय रूप से निर्धारित करने के स्थान पर स्वतंत्र रूप से अपने डिफ़ॉल्ट को नियंत्रित कर सकता है। टाइपस्क्रिप्ट समाधान जावा में सिम्युलेटेड हो सकता है Optional निहित के अनुरूप को छोड़कर टाइप करें undefined प्रत्येक अनुपस्थित तर्क के लिए कॉल साइट पर Optional.<Integer>absent() स्पष्ट होता है।

मूल्यांकन

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

पायथन एक उल्लेखनीय भाषा है जो फ़ंक्शन घोषणा के मूल्यांकन के समय एक बार डिफ़ॉल्ट आर्गुमेंट में अभिव्यक्तियों का मूल्यांकन करती है। यदि प्रति फ़ंक्शन कॉल का मूल्यांकन वांछित है, तो इसे डिफ़ॉल्ट आर्गुमेंट के रूप में सेंटिनल मान होने पर दोहराया जा सकता है, जैसे None, और उसके बाद फ़ंक्शन का मुख्य भाग होने पर डिफ़ॉल्ट मान के दुष्प्रभाव का मूल्यांकन केवल तभी किया जाता है जब सेंटीनेल मान पारित किया गया हो।

उदाहरण के लिए:

import random

def eager(a=random.random()):
    return a

x = eager()
y = eager()
assert x == y

def lazy(a=None):
    if a is None:
        a = random.random()
    return a

x = lazy()
y = lazy()
assert x != y

विस्तार

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

अन्य स्थितियों में इसके स्थान पर एक डिफ़ॉल्ट आर्गुमेंट स्थिर रूप से आवंटित किया जा सकता है। यदि वेरिएबल परिवर्तनशील है, तो यह स्थैतिक वेरिएबल के साथ फंक्शन कॉल्स में अपना मान बनाए रखता हैं।

यह व्यवहार पायथन में परिवर्तनशील प्रकारों जैसे कि सूचियों के लिए पाया जाता है। मूल्यांकन के साथ, स्थानीय वेरिएबल के समान सीमा सुनिश्चित करने के लिए, सेंटिनल मूल्य का उपयोग कर सकते हैं:

def eager(a=[]):
    return a

x = eager()
x += [1]
assert eager() == [1]

def lazy(a=None):
    if a is None:
        a = []
    return a

x = lazy()
x += [1]
assert lazy() == []