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

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

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

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

परामित्रीकृत कंस्ट्रक्टर
कंस्ट्रक्टर जो कम से कम एक तर्क ले सकते हैं उन्हें परामित्रीकृत कंस्ट्रक्टर कहा जाता है। जब किसी ऑब्जेक्ट को परामित्रीकृत कन्स्ट्रक्टर में घोषित किया जाता है, तो प्रारंभिक मानों को कन्स्ट्रक्टर फ़ंक्शन के तर्कों के रूप में पारित किया जाना चाहिए। ऑब्जेक्ट डिक्लेरेशन का सामान्य तरीका काम नहीं कर सकता है। कंस्ट्रक्टर को स्पष्ट या अव्यक्त रूप से कहा जा सकता है। कंस्ट्रक्टर को अव्यक्त रूप से कॉल करने की विधि को शॉर्टहैंड विधि भी कहा जाता है। 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 (फ़्लोटिंग-पॉइंट प्रकार), फॉल्स (बूलियन प्रकार) या शून्य (रेफरेंस प्रकार) के प्रारंभिक मान पर छोड़े जाते हैं। class Student { public: Student(int a = 0, int b = 0); // Default constructor int a;  int b; };
 * 1) include

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

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

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

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

 * जावा (प्रोग्रामिंग भाषा), सी ++, सी#, एक्शनस्क्रिप्ट, पीएचपी 4 और एमएटीएलएबी का नामित एक चलन है जिसमें कंस्ट्रक्टर का वही नाम होता है जैसा कि क्लास का होता है जिससे वे संबंधित हैं।
 * पीएचपी 5 में, कंस्ट्रक्टर के लिए अनुशंसित नाम है। पिछली संगतता के लिए, यदि  विधि नहीं मिल पाती है तो क्लास के समान नाम वाली एक विधि को कॉल किया जाएगा। पीएचपी 5.3.3 के उपरान्त, यह केवल गैर-नामस्थान क्लास के लिए काम करता है।
 * पीएचपी 7 में, आपको सदैव कंस्ट्रक्टर को से नामित करना चाहिए। क्लास के समान नाम वाली विधियाँ E_DEPRECATED स्तर की त्रुटि को प्रेरित करेंगी।
 * पर्ल में, कंस्ट्रक्टर्स को समागम द्वारा "नया" नाम दिया गया है और उन्हें उचित मात्रा में ऑब्जेक्ट उत्पन्न करना है।
 * पर्ल के लिए मूस ऑब्जेक्ट सिस्टम में, कन्स्ट्रक्टर (नया नामित) स्वचालित रूप से निर्मित और एक BUILD विधि निर्दिष्ट करके विस्तारित किए जाते हैं।
 * विजुअल बेसिक.नेट में कंस्ट्रक्टर को    कहा जाता है।
 * पायथन में, कंस्ट्रक्टर को दो विधियों, और में विभाजित किया गया है।   उदाहरण के लिए स्मृति आवंटित करने के लिए उत्तरदायी है, और क्लास को तर्क (पारंपरिक रूप से   कहा जाता है) के रूप में पारित किया जाता है।   विधि (जिसे प्रायः "प्रारंभकर्ता" कहा जाता है) नव निर्मित उदाहरण को तर्क (पारंपरिक रूप से   कहा जाता है) के रूप में पारित किया जाता है।
 * ऑब्जेक्ट पास्कल कंस्ट्रक्टर्स को संकेत शब्द   द्वारा दर्शाया जाता है और इसमें उपयोगकर्ता-परिभाषित नाम हो सकते हैं। (किन्तु अधिकतर इन्हें कहा जाता है)
 * ऑब्जेक्टिव-सी में, कंस्ट्रक्टर विधि को दो विधियों और  में विभाजित किया जाता है, जिसमे   विधि को क्लास के दृष्टांत के लिए अलग (आवंटित) मेमोरी के साथ निर्धारित किया जाता है और दृष्टांत को आरंभ करने के लिए   विधि का संचलन किया जाता है। क्लास दृष्टांत के लिए, विधि के कॉल   और यह   दोनों विधियों को आमंत्रित करता है।

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

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

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

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

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

एक कॉपी कंस्ट्रक्टर में उसी प्रकार का एक पैरामीटर होता है जिसे कॉन्स्ट रेफरेंस के रूप में पारित किया जाता है, उदाहरण के लिए वेक्टर (कॉन्स्ट वेक्टर और आरएचएस)। यदि यह स्पष्ट रूप से प्रदान नहीं किया गया है तो कम्पाइलर प्रत्येक परिवर्तनशील सदस्य के लिए कॉपी कन्स्ट्रक्टर का उपयोग करता है या पुराने प्रकारों की स्थिति में मूल्यों की प्रतिलिपि बनाता है। डिफ़ॉल्ट कार्यान्वयन सक्षम नहीं होगा यदि वर्ग ने सदस्यों को गतिशील रूप से आवंटित किया है (या अन्य संसाधनों को व्यवस्थित करता है) क्योंकि यह विनाश पर हटाने के लिए दोहरी कॉल (या संसाधनों की दोहरी रिलीज) का कारण बन सकता है। 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");

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

स्टैटिक कंस्ट्रक्टर जटिल स्टैटिक चर आरंभीकरण की अनुमति देते हैं। स्टैटिक कंस्ट्रक्टर्स को अव्यक्तता से कॉल किया जाता है जब क्लास को सर्वप्रथम अभिगम किया जाता है। किसी क्लास (स्टेटिक या कंस्ट्रक्टर कॉल) के लिए कोई भी कॉल स्टैटिक कंस्ट्रक्टर निष्पादन को प्रेरित करता है। स्टेटिक कंस्ट्रक्टर थ्रेड सुरक्षित हैं और सिंगलटन पैटर्न कार्यान्वित करती हैं। जब एक सामान्य प्रोग्रामिंग क्लास में उपयोग किया जाता है, तो स्टेटिक कंस्ट्रक्टर को प्रति नए जेनेरिक इंस्टेंटेशन पर अनेक प्रकार से कॉल किया जाता है। स्टेटिक चर भी दृष्टांतिकृत होते हैं। 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;

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

पनीर.सीएफसी 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; }     }

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

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


 * प्रकार का एक नया प्रत्यक्ष उदाहरण बनाएं।
 * नव निर्मित दृष्टांत के लिए निर्माण प्रक्रिया  को निष्पादित करें।
 * ननई प्रारंभिक ऑब्जेक्ट को इकाई x से संलग्न करें।।

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

सूचक शब्द  क्रियाओं की एक सूची प्रस्तावित करता है जिसका उपयोग दृष्टांत को प्रारंभ करने के लिए किया जा सकता है। इस स्थिति में सूची में   क्लास    से आनुवंशिक रिक्त कार्यान्वयन वाली प्रक्रिया और क्लास के भीतर कोडित    प्रक्रिया सम्मिलित है। 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 ...

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

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

अगला  के लिए एक निर्माण निर्देश है, जो   के निर्देशांकों के लिए प्रारंभिक मान प्रदान करता है। तीसरा निर्देश   के साथ विभिन्न वैल्यू से संलग्न दृष्टांत को पुन: प्रारंभ करने के लिए   प्रक्रिया को सामान्य दृष्टांत कॉल करता है। 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) ...

एफ #
एफ # में, एक कंस्ट्रक्टर में किसी क्लास में परिभाषित कोई भी  या   कथन सम्मिलित हो सकता है।   कथन निजी क्षेत्रों को परिभाषित करते हैं और   कथन कोड निष्पादित करते हैं। अतिरिक्त कंस्ट्रक्टर्स को   सूचक शब्द का उपयोग करके परिभाषित किया जा सकता है। 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"

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


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

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


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

जावा उपयोगकर्ताओं को  सूचक शब्द का उपयोग करके एक कंस्ट्रक्टर को दूसरे कंस्ट्रक्टर में कॉल करने की अनुमति देता है। लेकिन   पहला कथन होना चाहिए। 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; }

जावा  सूचक शब्द के माध्यम से सुपरक्लास (कंप्यूटर साइंस) के कंस्ट्रक्टर तक अभिगमन (ऐक्सेस) प्रदान करता है। 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);

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

जावास्क्रिप्ट
ईएस6 के रूप में, जावास्क्रिप्ट में कई अन्य प्रोग्रामिंग भाषाओं के समान डायरेक्ट कंस्ट्रक्टर हैं। वे इस तरह लिखे गए हैं class FooBar { constructor(baz) { this.baz = baz }  } इसे इस तरह द्रिश्तान्किक्रित किया जा सकता है const foo = new FooBar('7')

ईएस6 से पहले इसके समतुल्य एक ऐसा फंक्शन बना रहा था जो किसी ऑब्जेक्ट को इस तरह से द्रिश्तान्किक्रित करता है function FooBar (baz) { this.baz = baz; }; इसे ऊपर की तरह ही द्रिश्तान्किक्रित किया जाता है।

ऑब्जेक्ट पास्कल
ऑब्जेक्ट पास्कल में, कंस्ट्रक्टर फ़ैक्टरी विधि के समान है। सामान्य विधियों के लिए केवल वाक्यगत अंतर प्रतिष्ठा के सामने (बदले में  या  ) कीवर्ड   है।  इसका कोई भी नाम हो सकता है, हालाँकि कन्वेंशन में   जैसे उपसर्ग के रूप में   है। एक क्लास का एक उदाहरण बनाना एक क्लास की स्थिर (स्टैटिक) विधि को कॉल करने जैसा काम करता है: 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.

ओसीएएमएल
ओसीएएमएल (प्रोग्रामिंग लैंग्वेज) में, एक कंस्ट्रक्टर होता है। पैरामीटर्स को क्लास के नाम के ठीक बाद परिभाषित किया गया है। उनका उपयोग आवृत्ति चर को आरंभ करने के लिए किया जा सकता है और सम्पूर्ण क्लास में ऐक्सेस किया जा सकता है।  नामक एक अज्ञातकृत प्रच्छन्न विधि, ऑब्जेक्ट के निर्माण के तुरंत बाद एक अभिव्यक्ति का मूल्यांकन करने की अनुमति देती है। class person first_name last_name = object val full_name = first_name ^ " " ^ last_name initializer print_endline("Hello there, I am " ^ full_name ^ ".") method get_last_name = last_name end;; let alonzo = new person "Alonzo" "Church" in (*Hello there, I am Alonzo Church.*) print_endline alonzo#get_last_name (*Church*)

पीएचपी
पीएचपी संस्करण 5 और इसके बाद के संस्करण में, कंस्ट्रक्टर   नाम की एक विधि है (ध्यान दें कि यह एक डबल अंडरस्कोर है), जिसे    सूचक शब्द ऑब्जेक्ट बनाने के पश्चात् स्वतः कॉल करता है। सामान्यतः इसका उपयोग विशेषताओं के आरंभीकरण जैसे आरंभीकरण को स्वतः निष्पादित करने के लिए किया जाता है। कंस्ट्रक्टर तर्कों को भी स्वीकार कर सकते हैं ऐसे में जब   व्याख्यान लिखा जाता है तो आपको पैरामीटर्स के लिए कंस्ट्रक्टर तर्क भेजने की भी आवश्यकता होती है। class Person {    private string $name; public function __construct(string $name): void {        $this->name = $name; }    public function getName: string {        return $this->name; } } पीएचपी में एक क्लास को केवल अधिकतम एक कन्स्ट्रक्टर विधि घोषित करने की अनुमति है। स्टैटिक मेथड्स फैक्ट्री क्लासेस या वैकल्पिक कंस्ट्रक्टर तर्क पीएचपी क्लास के ऑब्जेक्ट बनाने के कई तरीकों को सुविधाजनक बनाने के कुछ तरीके हैं।

पर्ल 5
पर्ल प्रोग्रामिंग भाषा संस्करण 5 में डिफॉल्ट रूप से कंस्ट्रक्टर फैक्ट्री मेथड्स हैं जो ऑब्जेक्ट बनाते और वापस करते हैं जिसका अर्थ है श्रेष्ठ संदर्भ बनाना और वापस करना। विशिष्ट ऑब्जेक्ट हैश का संदर्भ होता है जबकि अन्य प्रकार के संदर्भों का भी उपयोग कदाचित कभी किया जाता हो। परंपरा के अनुसार केवल निर्माता नया नाम दे सकता है जबकि इसे नाम देने की अनुमति है अन्यथा कई निर्माता हों। उदाहरण के लिए एक व्यक्ति क्लास में नया नाम का एक कन्स्ट्रक्टर हो सकता है और साथ ही एक कन्स्ट्रक्टर new_from_file हो सकता है जो व्यक्ति विशेषताओं के लिए एक फ़ाइल पढ़ता है और new_from_person जो टेम्पलेट के रूप में किसी अन्य व्यक्ति ऑब्जेक्ट का उपयोग करता है। package Person; sub new { # Class name is implicitly passed in as 0th argument. my $class = shift; # Default attribute values, if you have any. my %defaults = ( foo => "bar" ); # Initialize attributes as a combination of default values and arguments passed. my $self = { %defaults, @_ }; # Check for required arguments, class invariant, etc.    if ( not defined $self->{first_name} ) { die "Mandatory attribute missing in Person->new: first_name"; }    if ( not defined $self->{last_name} ) { die "Mandatory attribute missing in Person->new: last_name"; }    if ( defined $self->{age} and $self->{age} < 18 ) { die "Invalid attribute value in Person->new: age < 18"; }    # Perl makes an object belong to a class by 'bless'. bless $self, $class; return $self; } 1;
 * 1) In Perl constructors are named 'new' by convention.

मूस के साथ पर्ल 5
पर्ल के लिए मूस ऑब्जेक्ट प्रणाली के साथ बॉयलरप्लेट में से अधिकांश को छोड़ा जा सकता है एवं डिफ़ॉल्ट नया बनाया जाता है और विशेषताओं को निर्दिष्ट किया जा सकता है साथ ही साथ उन्हें व्यवस्थित किया जा सकता है या आवश्यक होने पर पुनर्व्यवस्थित किया जा सकता है। इसके अलावा किसी भी अतिरिक्त कंस्ट्रक्टर कार्यक्षमता को एक BUILD विधि में सम्मिलित किया जा सकता है जिसे मूस जनरेटेड कंस्ट्रक्टर तर्कों की जाँच करने के बाद कॉल करेगा। एक BUILDARGS विधि को कन्स्ट्रक्टर तर्कों को नियन्त्रित करने के लिए निर्दिष्ट किया जा सकता है जो हैशरेफ/की => मान रूप में नहीं है। package Person; use Moose; has first_name => (is => 'ro', isa => 'Str', required => 1); has last_name => (is => 'ro', isa => 'Str', required => 1); has age       => (is => 'rw', isa => 'Int', predicate => 'has_age'); sub BUILD { my $self = shift; if ($self->has_age && $self->age < 18) { # no under 18s die "No under-18 Persons"; } } 1; दोनों ही स्थितियों में व्यक्ति (पर्सन) क्लास इस तरह प्रारंभ होता है: use Person; my $p = Person->new( first_name => 'Sam', last_name => 'Ashe', age => 42 );
 * 1) enable Moose-style object construction
 * 1) first name ( a string) can only be set at construction time ('ro')
 * 1) last name ( a string) can only be set at construction time ('ro')
 * 1) age (Integer) can be modified after construction ('rw'), and is not required
 * 2) to be passed to be constructor.  Also creates a 'has_age' method which returns
 * 3) true if age has been set
 * 1) Check custom requirements

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

विशिष्ट मामले में, केवल  विधि को परिभाषित करने की आवश्यकता है। (अत्यन्त सामान्य अपवाद अपरिवर्तनीय ऑब्जेक्ट के लिए है।)

>>> class ExampleClass: ...    def __new__(cls, value): ...        print("Creating new instance...") ...        # Call the superclass constructor to create the instance. ...        instance = super(ExampleClass, cls).__new__(cls) ...        return instance ...    def __init__(self, value): ...        print("Initialising instance...") ...        self.payload = value >>> exampleInstance = ExampleClass(42) Creating new instance... Initialising instance... >>> print(exampleInstance.payload) 42 सामान्यतः क्लास पर स्वयं के नए उदाहरणों के लिए कारखानों के रूप में कार्य करती हैं, अर्थात, एक वर्ग एक कॉल करने योग्य वस्तु (एक फ़ंक्शन की तरह) है, जिसमें कॉल एक कन्स्ट्रक्टर के रूप में कार्य करता है और कॉल करने से उस वर्ग का एक उदाहरण मिलता है। हालांकि  विधि को विशेष उद्देश्यों के लिए कक्षा के उदाहरण के अतिरिक्त कुछ और परावर्तन करने की अनुमति है। उस स्थिति में   आह्वान नहीं किया जाता है।

राकू
राकू (प्रोग्रामिंग भाषा) के साथ, और भी बॉयलरप्लेट को यह देखते हुए छोड़ा जा सकता है कि डिफ़ॉल्ट नई पद्धति विरासत में मिली है एवं विशेषताओं को निर्दिष्ट किया जा सकता है साथ ही क्या उन्हें व्यवस्थित भी किया जा सकता है या आवश्यक है तो पुनर्व्यवस्थित किया जा सकता है। इसके अलावा किसी भी अतिरिक्त कन्स्ट्रक्टर कार्यक्षमता को BUILD विधि में सम्मिलित किया जा सकता है जिसे कस्टम प्रारंभिकरण की अनुमति देने के लिए बुलाया जाएगा। पहले से ही (अंतर्निहित) प्रारंभ की गई किसी भी विशेषता को पश्च संसाधित्र करने के लिए एक टीडब्ल्यूईएके विधि निर्दिष्ट की जा सकती है। class Person { has Str $.first-name is required; # First name (a string) can only be set at                                      # construction time (the . means "public"). has Str $.last-name is required; # Last name (a string) can only be set at                                       # construction time (a ! would mean "private"). has Int $.age is rw;             # Age (an integer) can be modified after # construction ('rw'), and is not required # during the object instantiation. # Create a 'full-name' method which returns the person's full name. # This method can be accessed outside the class. method full-name { $!first-name.tc ~ " " ~ $!last-name.tc } # Create a 'has-age' method which returns true if age has been set. # This method is used only inside the class so it's declared as "private" # by prepending its name with a ! method !has-age { self.age.defined } # Check custom requirements method TWEAK { if self!has-age && $!age < 18 { # No under 18 die "No person under 18"; }    } } व्यक्ति (पर्सन) क्लास इस तरह प्रारंभ होता है: my $p0 = Person.new( first-name => 'Sam', last-name => 'Ashe', age => 42 ); my $p1 = Person.new( first-name => 'grace', last-name => 'hopper' ); say $p1.full-name; # OUTPUT: «Grace Hopper␤» वैकल्पिक रूप से नामित पैरामीटर को पर्ल 6 में बृहदान्त्र-जोड़ी वाक्यविन्यास का उपयोग करके निर्दिष्ट किया जा सकता है: my $p0 = Person.new( :first-name, :last-name, :age(42) ); my $p1 = Person.new( :first-name, :last-name ); और क्या आपको नामित पैरामीटर के समान नामों के साथ चर स्थापित करना चाहिए, आप शॉर्टकट का उपयोग कर सकते हैं जो नामित पैरामीटर के लिए चर के नाम का उपयोग करेगा: my $first-name = "Sam"; my $last-name = "Ashe"; my $age       = 42; my $p0 = Person.new( :$first-name, :$last-name, :$age );

रूबी
रूबी (प्रोग्रामिंग भाषा) में, कंस्ट्रक्टर्स  नामक एक विधि को परिभाषित करके बनाए जाते हैं। प्रत्येक नए उदाहरण को आरंभ करने के लिए इस विधि को निष्पादित किया जाता है। irb(main):001:0> class ExampleClass irb(main):002:1>  def initialize irb(main):003:2>    puts "Hello there" irb(main):004:2>  end irb(main):005:1> end => nil irb(main):006:0> ExampleClass.new Hello there => #

विजुअल बेसिक .नेट
विजुअल बेसिक में .नेट कंस्ट्रक्टर " " नाम के साथ एक विधि डिक्लेरेशन का उपयोग करते हैं। 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 समकक्ष, ((कंस्ट्रक्टर)) फ़ंक्शन विशेषता