कंस्ट्रक्टर (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग): Difference between revisions

Revision as of 20:57, 23 March 2023

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

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

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

प्रकार

परामित्रीकृत कंस्ट्रक्टर

कंस्ट्रक्टर जो कम से कम एक तर्क ले सकते हैं उन्हें परामित्रीकृत कंस्ट्रक्टर कहा जाता है। जब किसी ऑब्जेक्ट को पैरामीटरयुक्त कन्स्ट्रक्टर में घोषित किया जाता है, तो प्रारंभिक मानों को कन्स्ट्रक्टर फ़ंक्शन के तर्कों के रूप में पारित किया जाना चाहिए। ऑब्जेक्ट घोषणा का सामान्य तरीका काम नहीं कर सकता है। कंस्ट्रक्टर को स्पष्टता या अव्यक्तता कहा जा सकता है। कंस्ट्रक्टर को अव्यक्तता से कॉल करने की विधि को शॉर्टहैंड विधि भी कहा जाता है।

class Example {
public:
  Example();  
  Example(int a, int b);  // Parameterized constructor.
private:
  int x_;
  int y_;
};
Example::Example() = default;

Example::Example(int x, int y): x_(x), y_(y) {}

Example e = Example(0, 50);  // Explicit call.
 Example e2(0, 50);  // Implicit call.

डिफ़ॉल्ट कंस्ट्रक्टर

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

#include <iostream>

class Student {
  public:
Student(int a = 0, int b = 0);  // Default constructor
  int a;
  int b;
};

कॉपी कंस्ट्रक्टर

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

कन्वर्जन कंस्ट्रक्टर

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

मूव कंस्ट्रक्टर

सी++ में, मूव कंस्ट्रक्टर(सी ++) क्लास के किसी ऑब्जेक्ट के लिए आरवैल्यू रेफरेंस लेते हैं, और पैरामीटर ऑब्जेक्ट के संसाधनों के स्वामित्व हस्तांतरण को लागू करने के लिए उपयोग किए जाते हैं।

वाक्य - विन्यास

जावा (प्रोग्रामिंग भाषा), सी ++, सी#, एक्शनस्क्रिप्ट, पीएचपी 4 और एमएटीएलएबी का नामित एक चलन है जिसमें कंस्ट्रक्टर का वही नाम होता है जैसा कि क्लास का होता है जिससे वे संबंधित हैं।
पीएचपी 5 में, कंस्ट्रक्टर के लिए __constructअनुशंसित नाम है। पिछली संगतता के लिए, यदि__construct विधि नहीं मिल पाती है तो क्लास के समान नाम वाली एक विधि को कॉल किया जाएगा। पीएचपी 5.3.3 के उपरान्त, यह केवल गैर-नामस्थान क्लास के लिए काम करता है।^[1]
पीएचपी 7 में, आपको सदैव कंस्ट्रक्टर को __constructसे नामित करना चाहिए। क्लास के समान नाम वाली विधियाँ E_DEPRECATED स्तर की त्रुटि को प्रेरित करेंगी।
पर्ल में, कंस्ट्रक्टर्स को समागम द्वारा "नया" नाम दिया गया है और उन्हें उचित मात्रा में ऑब्जेक्ट उत्पन्न करना है।
पर्ल के लिए मूस ऑब्जेक्ट सिस्टम में, कन्स्ट्रक्टर (नया नामित) स्वचालित रूप से निर्मित और एक BUILD विधि निर्दिष्ट करके विस्तारित किए जाते हैं।
विजुअल बेसिक.नेट में कंस्ट्रक्टर को New कहा जाता है।
पायथन में, कंस्ट्रक्टर को दो विधियों, __new__और__init_में विभाजित किया गया है। __new__उदाहरण के लिए स्मृति आवंटित करने के लिए उत्तरदायी है, और क्लास को तर्क (पारंपरिक रूप से cls कहा जाता है) के रूप में पारित किया जाता है।__init__ विधि (जिसे प्रायः "प्रारंभकर्ता" कहा जाता है) नव निर्मित उदाहरण को तर्क (पारंपरिक रूप से self कहा जाता है) के रूप में पारित किया जाता है।^[2]
ऑब्जेक्ट पास्कल कंस्ट्रक्टर्स को संकेत शब्द constructor द्वारा दर्शाया जाता है और इसमें उपयोगकर्ता-परिभाषित नाम हो सकते हैं (किन्तु अधिकतर इन्हेंCreateकहा जाता है)
ऑब्जेक्टिव-सी में, कंस्ट्रक्टर विधि दो विधियों allocऔरinit में विभाजित किया जाता है, जिसमे क्लास के एक उदाहरण के लिए मेमोरी को अलग (आवंटित) करने की विधि alloc के साथ, और init विधि दृष्टांत को प्रारंभ करने के स्थूलता को संभालने के लिए। क्लास दृष्टांत के लिए, विधिnewके कॉल alloc और यह init दोनों विधियों को आमंत्रित करता है।

मेमोरी संगठन

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

सी ++ में, ऑब्जेक्ट स्टैक पर बनाए जाते हैं जब कन्स्ट्रक्टर को नए ऑपरेटर के बिना आमंत्रित किया जाता है, और जब कन्स्ट्रक्टर को नए ऑपरेटर के साथ आह्वान किया जाता है तो यह हिप पर बनाया जाता है। जब वे विषय क्षेत्र से बाहर हो जाते हैं तो स्टैक ऑब्जेक्ट को अव्यक्त रूप से मिटा दिया जाता है, जबकि हिप ऑब्जेक्ट को डेस्ट्रक्टर द्वारा अव्यक्त रूप से या डिलीट ऑपरेटर का उपयोग करके स्पष्ट रूप से मिटा देना चाहिए।

भाषा विवरण

सी ++

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

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

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

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

class Foobar {
public:
   Foobar(double r = 1.0,
          double alpha = 0.0)  // Constructor, parameters with default values.
       : x_(r * cos(alpha))    // <- Initializer list
   {
         y_ = r * sin(alpha);  // <- Normal assignment
   }
      private:
      double x_;
      double y_;
   };

उदाहरण उत्क्रियण:

 Foobar a,
        b(3),
        c(5, M_PI/4);

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

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

सी #

उदाहरण: सी# कंस्ट्रक्टर:

public class MyClass
   {
       private int a;   
       private string b;

       // Constructor
       public MyClass() : this(42, "string")
      {
      }

      // Overloading a constructor
      public MyClass(int a, string b)
      {
        this.a = a;
        this.b = b;
      }
   }

   // Code somewhere
   // Instantiating an object with the constructor above)
  MyClass c = new MyClass(42, "string");

सी# स्टेटिक कन्स्ट्रक्टर

सी# में, स्टेटिक कन्स्ट्रक्टर एक स्थिर डेटा प्रारंभकर्ता है। स्टेटिक कंस्ट्रक्टर्स को क्लास कंस्ट्रक्टर्स भी कहा जाता है। चूँकि उत्पन्न हुई वास्तविक विधि का नाम .सीसीटीओआर होता है उन्हें प्रायः "सीसीटीओआरएस" भी कहा जाता है।^[4]^[5]

स्टैटिक कंस्ट्रक्टर जटिल स्टैटिक चर आरंभीकरण की अनुमति देते हैं।^[6]स्टैटिक कंस्ट्रक्टर्स को अव्यक्तता से कॉल किया जाता है जब क्लास को सर्वप्रथम अभिगम किया जाता है। क्लास (स्टेटिक या कंस्ट्रक्टर कॉल) के लिए कोई भी कॉल, स्टैटिक कंस्ट्रक्टर के निष्पादन को प्रेरित करता है। स्टेटिक कंस्ट्रक्टर थ्रेड सुरक्षित हैं और सिंगलटन पैटर्न कार्यान्वित करते हैं। जब एक सामान्य प्रोग्रामिंग क्लास में उपयोग किया जाता है, तो स्टेटिक कंस्ट्रक्टर को प्रति नए सामान्य दृष्टांतिकरण पर प्रति प्रकार से कॉल किया जाता है। स्टेटिक चर भी दृष्टांतिकृत होते हैं।

public class MyClass
{
    private static int _A;

    // Normal constructor
    static MyClass()
    {
        _A = 32;
    }

    // Standard default constructor
    public MyClass()
    {

    }
}

  // Code somewhere
  // Instantiating an object with the constructor above
  // right before the instantiation
  // The variable static constructor is executed and _A is 32
     MyClass c = new MyClass();

सीएफएमएल

सीएफएमएल init 'नामक एक विधि को कन्स्ट्रक्टर विधि के रूप में उपयोग करता है।

पनीर.सीएफसी

  component {
  // properties
     property name="cheeseName";

  // constructor
     function Cheese init( required string cheeseName ) {
     variables.cheeseName = arguments.cheeseName;
     return this;
    }
      }

एक पनीर का उदाहरण बनाएँ।

 myCheese = new Cheese( 'Cheddar' );

चूंकि कोल्डफ्यूजन 10 सीएफएमएल ने भी कन्स्ट्रक्टर विधि का नाम निर्दिष्ट करने का समर्थन किया है:

 component initmethod="Cheese" 
{
  // properties
     property name="cheeseName";

 // constructor
    function Cheese Cheese( required string cheeseName ) {
    variables.cheeseName = arguments.cheeseName;
    return this;
     }   
  }

एफिल

एफिल में, नए ऑब्जेक्ट को आरंभ करने वाली दिनचर्या को निर्माण प्रक्रिया कहा जाता है। निर्माण प्रक्रियाओं में निम्नलिखित विशेषताएं हैं:

निर्माण प्रक्रियाओं का कोई स्पष्ट रिटर्न प्रकार नहीं है ( प्रक्रिया की परिभाषा के अनुसार )।^{[lower-alpha 1]}
निर्माण प्रक्रियाएं नामित होती है।
निर्माण प्रक्रियाओं को क्लास के पाठ में निर्माण प्रक्रियाओं के नाम से नामित किया गया है।
उपस्थित वस्तुओं को पुन: प्रारंभ करने के लिए निर्माण प्रक्रियाओं को स्पष्ट रूप से आह्वान किया जा सकता है।
प्रत्येक प्रभावी (यानी, ठोस या गैर-सार) क्लास को न्यूनतम एक निर्माण प्रक्रिया निर्दिष्ट करनी चाहिए।
निर्माण प्रक्रियाओं को नव आरंभीकृत ऑब्जेक्ट को उस स्थिति में छोड़ देना चाहिए जो क्लास अपरिवर्तनीय को संतुष्ट करता है।^{[lower-alpha 2]}

यद्यपि ऑब्जेक्ट निर्माण में कुछ सूक्ष्मताएँ सम्मिलित हैं,^[7] एक विशिष्ट घोषणा x: T के साथ एक विशेषता का निर्माण जो एक निर्माण निर्देशनcreate x.make में व्यक्त की गई जिसमें निम्नलिखित चरणों के अनुक्रम सम्मिलित है:

T प्रकार का एक नया प्रत्यक्ष उदाहरण बनाएं।^{[lower-alpha 3]}
नव निर्मित दृष्टांत के लिए निर्माण प्रक्रिया make को निष्पादित करें।
ननई प्रारंभिक ऑब्जेक्ट को इकाई x से संलग्न करें।।

नीचे दिए गए सर्वप्रथम स्निपेट में, क्लास POINT परिभाषित किया गया है। कार्यविधि make सूचक शब्द feature के पश्चात कोडित किया गया है।

सूचक शब्द create क्रियाओं की एक सूची प्रस्तावित करता है जिसका उपयोग दृष्टांत को प्रारंभ करने के लिए किया जा सकता है। इस स्थिति में सूची में default_create क्लास ANY से आनुवंशिक रिक्त कार्यान्वयन वाली प्रक्रिया और क्लास के भीतर कोडित make प्रक्रिया सम्मिलित है।

class
    POINT
create
    default_create, make

feature

    make (a_x_value: REAL; a_y_value: REAL)
        do
            x := a_x_value
            y := a_y_value
        end

    x: REAL
            -- X coordinate

    y: REAL
            -- Y coordinate


            ...

दूसरे स्निपेट में, एक क्लास जो कि POINT के क्लाइंट है, उसके पास my_point_1 और my_point_2 घोषणाएं हैं।

प्रक्रियात्मक कोड में, my_point_1 को मूल (0.0, 0.0) के रूप में निर्माण किया गया है। क्योंकि कोई निर्माण प्रक्रिया निर्दिष्ट नहीं है, क्लास ANY से आनुवंशिक प्रक्रिया default_create का उपयोग किया जाता है। इस पंक्ति को create my_point_1.default_create में कोडित किया जा सकता था।create सूचक शब्द के साथ निर्देश में केवल निर्माण प्रक्रियाओं के रूप में नामित प्रक्रियाओं का उपयोग किया जा सकता है। अगला my_point_2 के लिए एक निर्माण निर्देश है, जो my_point_2 के निर्देशांकों के लिए प्रारंभिक मान प्रदान करता है। तीसरा निर्देश my_point_2 के साथ विभिन्न वैल्यू से संलग्न दृष्टांत को पुन: प्रारंभ करने के लिए make प्रक्रिया को सामान्य दृष्टांत कॉल करता है।

my_point_1: POINT    
my_point_2: POINT
        ...

            create my_point_1
            create my_point_2.make (3.0, 4.0)
            my_point_2.make (5.0, 8.0)

        ...

एफ #

एफ # में, एक कंस्ट्रक्टर में किसी क्लास में परिभाषित कोई भी let या do कथन सम्मिलित हो सकता है। let कथन निजी क्षेत्रों को परिभाषित करते हैं और do कथन कोड निष्पादित करते हैं। अतिरिक्त कंस्ट्रक्टर्स को new सूचक शब्द का उपयोग करके परिभाषित किया जा सकता है।

type MyClass(_a : int, _b : string) = class
    // Primary constructor
    let a = _a
    let b = _b
    do printfn "a = %i, b = %s" a b

    // Additional constructors
    new(_a : int) = MyClass(_a, "") then
        printfn "Integer parameter given"

    new(_b : string) = MyClass(0, _b) then
        printfn "String parameter given"

    new() = MyClass(0, "") then
        printfn "No parameter given"
end

// Code somewhere
// instantiating an object with the primary constructor
let c1 = new MyClass(42, "string")

// instantiating an object with additional constructors
let c2 = new MyClass(42)
let c3 = new MyClass("string")
let c4 = MyClass() // "new" keyword is optional"

जावा

जावा (प्रोग्रामिंग लैंग्वेज) में, कंस्ट्रक्टर अन्य विधियों से इस प्रकार भिन्न होते हैं कि:

कंस्ट्रक्टर्स के पास कभी भी स्पष्ट रिटर्न प्रकार नहीं होता है।
कंस्ट्रक्टर्स को सीधे नहीं आह्वान किया जा सकता है (सूचक शब्द "new” उन्हें आमंत्रित करता है)।
कंस्ट्रक्टर्स के पास नॉन-एक्सेस मॉडिफायर्स नहीं होने चाहिए।

जावा कंस्ट्रक्टर निम्नलिखित क्रम में निम्नलिखित कार्य करते हैं:

यदि कोई कन्स्ट्रक्टर परिभाषित नहीं किया गया है तो सुपरक्लास के डिफ़ॉल्ट कन्स्ट्रक्टर को कॉल करें।
निर्दिष्ट मानों के लिए सदस्य चर प्रारंभ करें।
कंस्ट्रक्टर के बॉडी को निष्पादित करता है।

जावा उपयोगकर्ताओं को this() सूचक शब्द का उपयोग करके एक कंस्ट्रक्टर को दूसरे कंस्ट्रक्टर में कॉल करने की अनुमति देता है। लेकिन this() पहला कथन होना चाहिए। ^[8]

   class Example
   {
         Example() // Non-parameterized constructor
   {
         this(1);  // Calling of constructor
         System.out.println("0-arg-cons");
   }
         Example(int a) // Parameterized constructor
   {
         System.out.println("1-arg-cons");
  }
}
         public static void main(String[] args)
{
        Example e = new Example();
}

जावा super सूचक शब्द के माध्यम से सुपरक्लास (कंप्यूटर साइंस) के कंस्ट्रक्टर तक अभिगमन (ऐक्सेस) प्रदान करता है।

     public class Example
    {
    // Definition of the constructor.
    public Example()
    {
        this(1);
    }

    // Overloading a constructor
    public Example(int input)
    {
        data = input; // This is an assignment
    }

    // Declaration of instance variable(s).
    private int data;
    }

// Code somewhere else
// Instantiating an object with the above constructor
Example e = new Example(42);

शून्य संख्या में तर्क लेने वाले कंस्ट्रक्टर को "नो-आर्गुमेंट्स" या "नो-आर्ग" कंस्ट्रक्टर कहा जाता है।^[9]

जावास्क्रिप्ट

ईएस6 के रूप में, जावास्क्रिप्ट में कई अन्य प्रोग्रामिंग भाषाओं के समान डायरेक्ट कंस्ट्रक्टर हैं। वे इस तरह लिखे गए हैं

class FooBar {
  constructor(baz) {

    this.baz = baz
}
  }

इसे इस तरह द्रिश्तान्किक्रित किया जा सकता है

const foo = new FooBar('7')

ES6 से पहले इसके समतुल्य एक ऐसा फंक्शन बना रहा था जो किसी ऑब्जेक्ट को इस तरह से द्रिश्तान्किक्रित करता है

 function FooBar (baz) {
    this.baz = baz;
};

इसे ऊपर की तरह ही द्रिश्तान्किक्रित किया जाता है।

ऑब्जेक्ट पास्कल

ऑब्जेक्ट पास्कल में, कंस्ट्रक्टर फ़ैक्टरी विधि के समान है। सामान्य विधियों के लिए केवल वाक्यगत अंतर प्रतिष्ठा के सामने (बदले में procedure या function) सूचक शब्द constructorहै। इसका कोई भी नाम हो सकता है, हालाँकि रूढ़ि संकेत में CreateWithFormatting जैसे उपसर्ग के रूप में Create है। एक क्लास का एक उदाहरण बनाना एक क्लास की स्थिर विधि को कॉल करने जैसा काम करता है: TPerson.Create('Peter')।

program OopProgram;
type
  TPerson = class
  private
    FName: string;
  public
    property Name: string read FName;
    constructor Create(AName: string);
  end;

constructor TPerson.Create(AName: string);
begin
  FName := AName;
end;

var
  Person: TPerson;
begin
  Person := TPerson.Create('Peter'); // allocates an instance of TPerson and then calls TPerson.Create with the parameter AName = 'Peter'
end.

ओकैमल

OCaml (प्रोग्रामिंग लैंग्वेज) में, एक कंस्ट्रक्टर होता है। Parameters को वर्ग के नाम के ठीक बाद परिभाषित किया गया है। उनका उपयोग आवृत्ति चर को आरंभ करने के लिए किया जा सकता है और पूरे वर्ग में पहुँचा जा सकता है। एक अनाम छिपी हुई विधि कहलाती है initializer वस्तु के निर्माण के तुरंत बाद एक अभिव्यक्ति का मूल्यांकन करने की अनुमति देता है। ^[10] <वाक्यविन्यास प्रकाश लैंग = ओकैमल> वर्ग व्यक्ति प्रथम_नाम अंतिम_नाम =

 वस्तु
   वैल पूर्ण_नाम = प्रथम_नाम ^ ^ अंतिम_ना

   प्रारंभकर्ता
     Print_endline (नमस्कार, मैं ^ पूर्ण_नाम ^ हूं।)

   विधि get_last_name = last_name
 अंत;;

चलो अलोंजो = नया व्यक्ति अलोंजो चर्च इन (*नमस्कार, मैं अलोंजो चर्च हूं।*)

print_endline alonzo#get_last_name (*चर्च*) </वाक्यविन्यास हाइलाइट>

पीएचपी

PHP संस्करण 5 और इसके बाद के संस्करण में, कंस्ट्रक्टर नाम की एक विधि है __construct() (ध्यान दें कि यह एक डबल अंडरस्कोर है), जो कि कीवर्ड है new ऑब्जेक्ट बनाने के बाद स्वचालित रूप से कॉल करता है। यह आमतौर पर संपत्ति आरंभीकरण जैसे आरंभीकरण को स्वचालित रूप से करने के लिए उपयोग किया जाता है। कंस्ट्रक्टर तर्कों को भी स्वीकार कर सकते हैं, इस मामले में, जब new बयान लिखा गया है, आपको पैरामीटर के लिए कन्स्ट्रक्टर तर्क भी भेजने की जरूरत है।^[1]

<वाक्यविन्यास लैंग = php> वर्ग व्यक्ति {

   निजी स्ट्रिंग $ नाम;

   सार्वजनिक कार्य __ निर्माण (स्ट्रिंग $ नाम): शून्य
   {
       $ यह-> नाम = $ नाम;
   }

   सार्वजनिक समारोह getName (): स्ट्रिंग
   {
       वापसी $ यह-> नाम;
   }

} </वाक्यविन्यास हाइलाइट>

PHP में, एक वर्ग को केवल अधिकतम एक कन्स्ट्रक्टर विधि घोषित करने की अनुमति है। स्टैटिक मेथड्स, फैक्ट्री क्लासेस या ऑप्शनल कंस्ट्रक्टर आर्ग्युमेंट्स PHP क्लास के ऑब्जेक्ट्स बनाने के कई तरीकों को सुविधाजनक बनाने के कुछ तरीके हैं।

पर्ल 5

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

<वाक्यविन्यास प्रकाश लैंग = पर्ल> पैकेज व्यक्ति;

पर्ल में कंस्ट्रक्टर्स को कन्वेंशन द्वारा 'नया' नाम दिया जाता है।

उप नया {

   # वर्ग का नाम निहित रूप से 0वें तर्क के रूप में पारित किया गया है।
   मेरी $ क्लास = शिफ्ट;

   # डिफ़ॉल्ट विशेषता मान, यदि आपके पास कोई है।
   मेरा% डिफ़ॉल्ट = (फू => बार);

   # पारित किए गए डिफ़ॉल्ट मानों और तर्कों के संयोजन के रूप में विशेषताओं को प्रारंभ करें।
   मेरा $ स्वयं = {% डिफ़ॉल्ट, @_};

   # आवश्यक तर्कों, वर्ग अपरिवर्तनीय आदि की जाँच करें।
   अगर ( परिभाषित नहीं $self->{first_name} ) {
       व्यक्ति-> नया () में अनिवार्य विशेषता गायब हो जाती है: first_name;
   }
   अगर ( परिभाषित नहीं $self->{last_name} ) {
       व्यक्ति-> नया () में अनिवार्य विशेषता गायब हो जाती है: last_name;
   }
   अगर ( परिभाषित $self->{आयु} और $self->{आयु} <18) {
       व्यक्ति में अमान्य विशेषता मान-> नया (): आयु <18;
   }

   # पर्ल किसी वस्तु को 'आशीर्वाद' द्वारा एक वर्ग से संबंधित बनाता है।
   $ स्वयं को आशीर्वाद दें, $ वर्ग;
   $ स्वयं लौटें;

} 1; </वाक्यविन्यास हाइलाइट>

मूस के साथ पर्ल 5

पर्ल के लिए मूस पर्ल के साथ, इस बॉयलरप्लेट में से अधिकांश को छोड़ा जा सकता है, एक डिफ़ॉल्ट नया बनाया जाता है, विशेषताओं को निर्दिष्ट किया जा सकता है, साथ ही साथ उन्हें सेट किया जा सकता है, रीसेट किया जा सकता है या आवश्यक है। इसके अलावा, किसी भी अतिरिक्त कंस्ट्रक्टर कार्यक्षमता को BUILD विधि में शामिल किया जा सकता है, जिसे मूस जनरेटेड कंस्ट्रक्टर तर्कों की जाँच करने के बाद कॉल करेगा। एक BUILDARGS विधि को कन्स्ट्रक्टर तर्कों को संभालने के लिए निर्दिष्ट किया जा सकता है जो हैशफ/कुंजी => मान फॉर्म में नहीं है।

<वाक्यविन्यास प्रकाश लैंग = पर्ल> पैकेज व्यक्ति;

मूस-शैली वस्तु निर्माण को सक्षम करें

मूस का प्रयोग करें;

पहला नाम (एक स्ट्रिंग) केवल निर्माण के समय सेट किया जा सकता है ('आरओ')

has first_name => (is => 'ro', isa => 'Str',आवश्यक => 1);

अंतिम नाम (एक स्ट्रिंग) केवल निर्माण के समय सेट किया जा सकता है ('आरओ')

has last_name => (is => 'ro', isa => 'Str', needed => 1);

आयु (पूर्णांक) को निर्माण ('rw') के बाद संशोधित किया जा सकता है, और इसकी आवश्यकता नहीं है
कंस्ट्रक्टर बनने के लिए पास होना है। एक 'has_age' विधि भी बनाता है जो वापस आती है
सच है अगर उम्र निर्धारित की गई है

उम्र है => (is => 'rw', isa => 'Int', विधेय => 'has_age');

कस्टम आवश्यकताओं की जाँच करें

उप निर्माण {

     मेरा $ स्व = शिफ्ट;
     if ($self->has_age && $self->आयु <18) { # 18 वर्ष से कम नहीं
          डाई नो अंडर-18 पर्सन;
     }

} 1; </वाक्यविन्यास हाइलाइट>

दोनों ही मामलों में व्यक्ति वर्ग इस तरह शुरू होता है: <वाक्यविन्यास प्रकाश लैंग = पर्ल> व्यक्ति का उपयोग करें; मेरा $ पी = व्यक्ति-> नया (पहला_नाम => 'सैम', अंतिम_नाम => 'ऐश', उम्र => 42); </वाक्यविन्यास हाइलाइट>

पायथन

पायथन (प्रोग्रामिंग लैंग्वेज) में, कंस्ट्रक्टर्स को एक या दोनों द्वारा परिभाषित किया जाता है __new__ और __init__ तरीके। क्लास को कॉल करके एक नया उदाहरण बनाया जाता है जैसे कि यह एक फ़ंक्शन था, जो कॉल करता है __new__ और __init__ तरीके। यदि कक्षा में एक कन्स्ट्रक्टर विधि परिभाषित नहीं की गई है, तो कक्षा के सी 3 रैखिकरण में पाए जाने वाले अगले को बुलाया जाएगा।^[11] विशिष्ट मामले में, केवल __init__ विधि को परिभाषित करने की आवश्यकता है। (सबसे आम अपवाद अपरिवर्तनीय वस्तुओं के लिए है।)

<वाक्यविन्यास लैंग = पिकॉन> >>> वर्ग उदाहरण वर्ग: ... def __new__(cls, value): ... प्रिंट (नया उदाहरण बना रहा है...) ... # उदाहरण बनाने के लिए सुपरक्लास कंस्ट्रक्टर को कॉल करें। ... उदाहरण = सुपर (उदाहरण क्लास, cls).__new__(cls) ... वापसी का उदाहरण ... def __init__(self, value): ... प्रिंट (प्रारंभिक उदाहरण... ) ... स्व.पेलोड = मूल्य >>> उदाहरण इंस्टेंस = उदाहरण क्लास (42) नया उदाहरण बनाया जा रहा है... इंस्टेंस प्रारंभ किया जा रहा है... >>> प्रिंट (exampleInstance.payload) 42 </वाक्यविन्यास हाइलाइट>

कक्षाएं सामान्य रूप से स्वयं के नए उदाहरणों के लिए फ़ैक्टरी (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग) के रूप में कार्य करती हैं, अर्थात, एक क्लास एक कॉल करने योग्य ऑब्जेक्ट (एक फ़ंक्शन की तरह) है, जिसमें कॉल कंस्ट्रक्टर है, और क्लास को कॉल करना उस क्लास का एक उदाहरण देता है। हालांकि __new__ विधि को विशेष उद्देश्यों के लिए कक्षा के उदाहरण के अलावा कुछ और वापस करने की अनुमति है। उस मामले में, __init__ आह्वान नहीं किया जाता है।^[12]

राकू

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

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

   है Str $.first-name आवश्यक है; # पहला नाम (एक स्ट्रिंग) केवल पर सेट किया जा सकता है
                                     # निर्माण समय (. का अर्थ है सार्वजनिक)।
   है Str $.last-name आवश्यक है; # अंतिम नाम (एक स्ट्रिंग) केवल पर सेट किया जा सकता है
                                     # निर्माण समय (ए ! का मतलब निजी होगा)।
   है int $.आयु rw है; # आयु (एक पूर्णांक) के बाद संशोधित किया जा सकता है
                                     # निर्माण ('आरडब्ल्यू'), और इसकी आवश्यकता नहीं है
                                     # ऑब्जेक्ट इन्स्टेन्शियशन के दौरान।
   
   # एक 'पूर्ण-नाम' विधि बनाएँ जो व्यक्ति का पूरा नाम लौटाती है।
   # इस विधि को कक्षा के बाहर पहुँचा जा सकता है।
   विधि का पूरा नाम { $!first-name.tc ~ ~ $!last-name.tc }

   # एक 'है-एज' मेथड बनाएं, जो उम्र सेट होने पर ट्रू रिटर्न करता है।
   # इस पद्धति का उपयोग केवल कक्षा के अंदर किया जाता है इसलिए इसे निजी घोषित किया जाता है
   # इसके नाम के आगे एक !
   विधि !है-उम्र {self.age.defined}
 
   # कस्टम आवश्यकताओं की जाँच करें
   विधि ट्वीक {
       अगर स्वयं!है-उम्र && $!उम्र <18 { # 18 से कम नहीं
           18 वर्ष से कम आयु का कोई व्यक्ति नहीं मरता;
       }
   }

} </वाक्यविन्यास हाइलाइट>

व्यक्ति वर्ग इस तरह तत्काल होता है: <वाक्यविन्यास प्रकाश लैंग = perl6> मेरा $p0 = व्यक्ति.नया (पहला-नाम => 'सैम', अंतिम-नाम => 'ऐश', उम्र => 42); मेरा $p1 = व्यक्ति.नया (प्रथम-नाम => 'अनुग्रह', अंतिम-नाम => 'कूदनेवाला'); कहना $p1.full-name(); # आउटपुट: «ग्रेस हूपर␤» </वाक्यविन्यास हाइलाइट>

वैकल्पिक रूप से, नामित पैरामीटर पर्ल 6 में कोलन-जोड़ी सिंटैक्स का उपयोग करके निर्दिष्ट किए जा सकते हैं: <वाक्यविन्यास प्रकाश लैंग = perl6> my $p0 = person.new( :first-name<Sam>, :last-name<Ashe>, :age(42) ); my $p1 = person.new( :first-name<Grace>, :last-name<Hopper> ); </वाक्यविन्यास हाइलाइट>

और क्या आपको नामित पैरामीटर के समान नामों के साथ चर सेट अप करना चाहिए, आप शॉर्टकट का उपयोग कर सकते हैं जो नामित पैरामीटर के लिए चर के 'नाम' का उपयोग करेगा: <वाक्यविन्यास प्रकाश लैंग = perl6> मेरा $ पहला-नाम = सैम; मेरा $ अंतिम-नाम = ऐश; मेरी उम्र = 42; my $p0 = person.new( :$first-name, :$last-name, :$age ); </वाक्यविन्यास हाइलाइट>

रूबी

रूबी (प्रोग्रामिंग भाषा) में, कंस्ट्रक्टर्स नामक एक विधि को परिभाषित करके बनाया जाता है initialize. प्रत्येक नए उदाहरण को आरंभ करने के लिए इस विधि को निष्पादित किया जाता है। <वाक्यविन्यास प्रकाश लैंग = आरबीकॉन> irb(main):001:0> क्लास exampleClass irb(main):002:1> डीईएफ़ इनिशियलाइज़ करें irb(main):003:2> वहां हैलो डालता है आईआरबी (मुख्य): 004: 2> अंत आईआरबी (मुख्य): 005: 1> अंत => शून्य आईआरबी (मुख्य): 006: 0> उदाहरण क्लास.न्यू नमस्ते => #<ExampleClass:0x007fb3f4299118> </वाक्यविन्यास हाइलाइट>

विजुअल बेसिक .NET

Visual Basic .NET में, निर्माता नाम के साथ विधि घोषणा का उपयोग करते हैंNew.

<वाक्यविन्यास लैंग = vbnet> वर्ग फूबर

Class Foobar
   Private strData As String

' Constructor
  Public Sub New(ByVal someParam As String)
  strData = someParam
      End Sub
   End Class

' code somewhere else

' instantiating an object with the above constructor

Dim foo As New Foobar(".NET")

यह भी देखें

संसाधन_अधिग्रहण_प्रारंभिकीकरण है
आवंटन स्थल
रचनात्मक पैटर्न
विध्वंसक (कंप्यूटर विज्ञान)
C++ में ग्लोबल ((निर्माता)), और इसका C समकक्ष, ((कंस्ट्रक्टर)) फ़ंक्शन विशेषता

↑ Eiffel routines are either procedures or functions. Procedures never have a return type. Functions always have a return type.
↑ Because the inherited class invariant must be satisfied, there is no mandatory call to the parents' constructors.
↑ The Eiffel standard requires fields to be initialized on first access, so it is not necessary to perform default field initialization during object creation.

संदर्भ

↑ ^1.0 ^1.1 Constructors and Destructors, from PHP online documentation
↑ Data model, from Python online documentation
↑ https://stackoverflow.com/questions/1242830/constructor-initialization-list-evaluation-order Constructor
↑ "Fabulous Adventures in Coding". Eric Lippert. 2013-02-06. Retrieved 2014-04-05.
↑ Expert .NET 2.0 IL Assembler. APress. 2006-01-01. ISBN 9781430202233. Retrieved 2014-04-05.
↑ Static Constructor in C# on MSDN
↑ Eiffel ISO/ECMA specification document
↑ Details on Constructor in java
↑ "Providing Constructors for Your Classes". Oracle Corporation. 2013. Retrieved 2013-12-20.
↑ OCaml manual
↑ Data model
↑ Data model

[7] Eiffel routines are either procedures or functions. Procedures never have a return type. Functions always have a return type.

[8] Because the inherited class invariant must be satisfied, there is no mandatory call to the parents' constructors.

[10] The Eiffel standard requires fields to be initialized on first access, so it is not necessary to perform default field initialization during object creation.

[php5cpnstructor-1] 1.0 ^1.1 Constructors and Destructors, from PHP online documentation

[2] Data model, from Python online documentation

[3] ttps://stackoverflow.com/questions/1242830/constructor-initialization-list-evaluation-order Constructor

[4] "Fabulous Adventures in Coding". Eric Lippert. 2013-02-06. Retrieved 2014-04-05.

[5] Expert .NET 2.0 IL Assembler. APress. 2006-01-01. ISBN 9781430202233. Retrieved 2014-04-05.

[6] Static Constructor in C# on MSDN

[eiffel_standard-9] Eiffel ISO/ECMA specification document

[11] Details on Constructor in java

[12] "Providing Constructors for Your Classes". Oracle Corporation. 2013. Retrieved 2013-12-20.

[13] OCaml manual

[14] Data model

[15] Data model

[1]

[2]

[3]

[4]

[5]

[6]

[lower-alpha 1]

[lower-alpha 2]

[7]

[lower-alpha 3]

[8]

[9]

[10]

[11]

[12]

@@ Line 328: / Line 328: @@
   Example e = new Example(42);
+शून्य संख्या में तर्क लेने वाले कंस्ट्रक्टर को "नो-आर्गुमेंट्स" या "नो-आर्ग" कंस्ट्रक्टर कहा जाता है।<ref>{{cite web|url=http://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html|title= Providing Constructors for Your Classes |publisher=Oracle Corporation|date=2013|access-date=2013-12-20}}</ref>
- शून्य संख्या में तर्क लेने वाले कंस्ट्रक्टर को "नो-आर्गुमेंट्स" या "नो-आर्ग" कंस्ट्रक्टर कहा जाता है।<ref>{{cite web|url=http://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html|title= Providing Constructors for Your Classes |publisher=Oracle Corporation|date=2013|access-date=2013-12-20}}</ref>
 === [[जावास्क्रिप्ट]] ===
@@ Line 351: / Line 349: @@
 === ऑब्जेक्ट पास्कल ===
-ऑब्जेक्ट पास्कल में, कंस्ट्रक्टर फ़ैक्टरी विधि के समान है। सामान्य विधियों के लिए केवल वाक्यगत अंतर नाम के सामने (के बजाय <code>procedure</code> या <code>function</code>) कीवर्ड <code>constructor</code>है।  इसका कोई भी नाम हो सकता है, हालाँकि सम्मेलन होना है <code>Create</code> उपसर्ग के रूप में, जैसे में <code>CreateWithFormatting</code>. एक वर्ग का एक उदाहरण बनाना एक वर्ग की स्थिर विधि को कॉल करने जैसा काम करता है: <code>TPerson.Create('Peter')</code>.
+ऑब्जेक्ट पास्कल में, कंस्ट्रक्टर फ़ैक्टरी विधि के समान है। सामान्य विधियों के लिए केवल वाक्यगत अंतर प्रतिष्ठा के सामने (बदले में <code>procedure</code> या <code>function</code>) सूचक शब्द  <code>constructor</code>है।  इसका कोई भी नाम हो सकता है, हालाँकि रूढ़ि संकेत में <code>CreateWithFormatting</code> जैसे उपसर्ग के रूप में <code>Create</code> है।  एक क्लास का एक उदाहरण बनाना एक क्लास की स्थिर विधि को कॉल करने जैसा काम करता है: <code>TPerson.Create('Peter')।</code>
+ program OopProgram;
-<वाक्यविन्यास लैंग = डेल्फी>
+ type
-कार्यक्रम ऊपप्रोग्राम;
+   TPerson = class
+   private
-प्रकार
+     FName: string;
-  टीपर्सन = क्लास
+   public
-  निजी
+     property Name: string read FName;
-    FName: स्ट्रिंग;
+     constructor Create(AName: string);
-  जनता
+   end;
-    संपत्ति का नाम: स्ट्रिंग FName पढ़ें;
-    निर्माता बनाएँ (नाम: स्ट्रिंग);
+ constructor TPerson.Create(AName: string);
-  अंत;
+ begin
+   FName := AName;
-निर्माता TPerson.Create (AName: string);
+ end;
-शुरू
-  एफनाम: = एनाम;
+ var
-अंत;
+   Person: TPerson;
+ begin
-वर
+   Person := TPerson.Create('Peter'); // allocates an instance of TPerson and then calls TPerson.Create with the parameter AName = 'Peter'
-  व्यक्ति: टीपीसन;
+ end.
-शुरू
-  व्यक्ति := TPerson.Create('पीटर'); // TPerson का एक उदाहरण आवंटित करता है और फिर TPerson.Create को पैरामीटर AName = 'Peter' के साथ कॉल करता है
-अंत।
-</वाक्यविन्यास हाइलाइट>
 === ओकैमल ===

Anonymous

Search