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

Latest revision as of 20:56, 26 April 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 दोनों विधियों को आमंत्रित करता है।

मेमोरी संगठन

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

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

भाषा विवरण

सी ++

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

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

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

 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.

ओसीएएमएल

ओसीएएमएल (प्रोग्रामिंग लैंग्वेज) में, एक कंस्ट्रक्टर होता है। पैरामीटर्स को क्लास के नाम के ठीक बाद परिभाषित किया गया है। उनका उपयोग आवृत्ति चर को आरंभ करने के लिए किया जा सकता है और सम्पूर्ण क्लास में ऐक्सेस किया जा सकता है। initializer नामक एक अज्ञातकृत प्रच्छन्न विधि, ऑब्जेक्ट के निर्माण के तुरंत बाद एक अभिव्यक्ति का मूल्यांकन करने की अनुमति देती है।^[10]

  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 और इसके बाद के संस्करण में, कंस्ट्रक्टर __construct() नाम की एक विधि है (ध्यान दें कि यह एक डबल अंडरस्कोर है), जिसे new सूचक शब्द ऑब्जेक्ट बनाने के पश्चात् स्वतः कॉल करता है। सामान्यतः इसका उपयोग विशेषताओं के आरंभीकरण जैसे आरंभीकरण को स्वतः निष्पादित करने के लिए किया जाता है। कंस्ट्रक्टर तर्कों को भी स्वीकार कर सकते हैं ऐसे में जब new व्याख्यान लिखा जाता है तो आपको पैरामीटर्स के लिए कंस्ट्रक्टर तर्क भेजने की भी आवश्यकता होती है।^[1]

    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;
# In Perl constructors are named 'new' by convention.
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;

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

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

 package Person;
# enable Moose-style object construction
use Moose;

# first name ( a string) can only be set at construction time ('ro')
has first_name => (is => 'ro', isa => 'Str', required => 1);
# last name ( a string) can only be set at construction time ('ro')
has last_name  => (is => 'ro', isa => 'Str', required => 1);
# age (Integer) can be modified after construction ('rw'), and is not required
# to be passed to be constructor.  Also creates a 'has_age' method which returns
# true if age has been set
has age        => (is => 'rw', isa => 'Int', predicate => 'has_age');

# Check custom requirements
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 );

पायथन

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

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

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

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

राकू

राकू (प्रोग्रामिंग भाषा) के साथ, और भी बॉयलरप्लेट को यह देखते हुए छोड़ा जा सकता है कि डिफ़ॉल्ट नई पद्धति विरासत में मिली है एवं विशेषताओं को निर्दिष्ट किया जा सकता है साथ ही क्या उन्हें व्यवस्थित भी किया जा सकता है या आवश्यक है तो पुनर्व्यवस्थित किया जा सकता है। इसके अलावा किसी भी अतिरिक्त कन्स्ट्रक्टर कार्यक्षमता को 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<Sam>, :last-name<Ashe>, :age(42) );
my $p1 = Person.new( :first-name<Grace>, :last-name<Hopper> );

और क्या आपको नामित पैरामीटर के समान नामों के साथ चर स्थापित करना चाहिए, आप शॉर्टकट का उपयोग कर सकते हैं जो नामित पैरामीटर के लिए चर के नाम का उपयोग करेगा:

my $first-name = "Sam";
my $last-name  = "Ashe";
my $age        = 42;
my $p0 = Person.new( :$first-name, :$last-name, :$age );

रूबी

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

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
=> #<ExampleClass:0x007fb3f4299118>

विजुअल बेसिक .नेट

विजुअल बेसिक में .नेट कंस्ट्रक्टर "New" नाम के साथ एक विधि डिक्लेरेशन का उपयोग करते हैं।

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 समकक्ष, ((कंस्ट्रक्टर)) फ़ंक्शन विशेषता

↑ 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 1: / Line 1: @@
 {{Short description|Special function called to create an object}}
-{{ProgLangCompare}} [[वर्ग आधारित प्रोग्रामिंग]] में क्लास-बेस्ड[[वंशानुक्रम (वस्तु-उन्मुख प्रोग्रामिंग)]], एक कंस्ट्रक्टर (संक्षिप्त नाम: ctor) एक विशेष प्रकार का [[सबरूटीन]] है जिसे [[वस्तु निर्माण]] कहा जाता है। यह उपयोग के लिए नई वस्तु तैयार करता है, अक्सर [[पैरामीटर (कंप्यूटर प्रोग्रामिंग)]] को स्वीकार करता है जिसे निर्माता आवश्यक [[सदस्य चर]] सेट करने के लिए उपयोग करता है।
+{{ProgLangCompare}} [[वर्ग आधारित प्रोग्रामिंग|क्लास बेस्ड (आधारित)]] ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में, कंस्ट्रक्टर(संक्षिप्त नाम:सीटीओआर) एक विशेष प्रकार का [[सबरूटीन|फलन]] है जिसे [[वस्तु निर्माण|ऑब्जेक्ट]] का निर्माण करने के लिए कहा जाता है। यह प्राय: उपयोग किए जाने वाले तर्कों को स्वीकार करने के लिए नए ऑब्जेक्ट का निर्माण करता है जो कंस्ट्रक्टर आवश्यक सदस्य चर निर्धारित करने के लिए उपयोग करता है।
-एक कंस्ट्रक्टर एक [[विधि (कंप्यूटर विज्ञान)]] जैसा दिखता है, लेकिन यह एक विधि से भिन्न होता है जिसमें इसका कोई स्पष्ट रिटर्न प्रकार नहीं होता है, यह निहित रूप से वंशानुक्रम ([[ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग]]) नहीं होता है और इसमें आमतौर पर स्कोप संशोधक के लिए अलग नियम होते हैं। कंस्ट्रक्टर्स का अक्सर डिक्लेयरिंग [[कक्षा (कंप्यूटर विज्ञान)]] के समान नाम होता है। उनके पास ऑब्जेक्ट के [[डेटा सदस्य]]ों को इनिशियलाइज़ेशन (कंप्यूटिंग) करने और [[वर्ग अपरिवर्तनीय]] को स्थापित करने का कार्य है, यदि इनवेरिएंट अमान्य है तो विफल हो जाता है। एक ठीक से लिखा हुआ कंस्ट्रक्टर परिणामी [[वस्तु (कंप्यूटर विज्ञान)]] को 'वैध' स्थिति में छोड़ देता है। कंस्ट्रक्टर में [[अपरिवर्तनीय वस्तु]]ओं को आरंभीकृत किया जाना चाहिए।
+कंस्ट्रक्टर एक इंस्टेंस [[विधि (कंप्यूटर विज्ञान)]] के समान सदृश होता है, किन्तु यह एक विधि के असमान होता है जिसमें इसका कोई स्पष्ट रिटर्न टाइप नहीं होता है, यह निहित रूप से आनुवंशिक ([[ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग]]) नहीं होता है और इसमें सामान्यतः स्कोप मॉडिफायर्स (संशोधक) के लिए विभिन्न नियम होते हैं। कंस्ट्रक्टर का प्रायः वही नाम होता है जो डिक्लेयरिंग [[कक्षा (कंप्यूटर विज्ञान)|क्लास (कंप्यूटर विज्ञान)]] का होता है। उनके पास ऑब्जेक्ट के [[डेटा सदस्य|डेटा मेंबर्स (सदस्य)]] को प्रारंभ (कंप्यूटिंग) करने और [[वर्ग अपरिवर्तनीय|अचर]] के अमान्य होने पर विफल होने वाले क्लास के अचर को स्थापित करने का कार्य है। एक उचित रूप से लिखित कन्स्ट्रक्टर परिणामी [[वस्तु (कंप्यूटर विज्ञान)|ऑब्जेक्ट (कंप्यूटर विज्ञान)]] को 'मान्य' स्थिति में छोड़ देता है। कंस्ट्रक्टर में [[अपरिवर्तनीय वस्तु|अपरिवर्त्य ऑब्जेक्ट]] को आरंभीकृत किया जाना चाहिए।
-अधिकांश भाषाएं कंस्ट्रक्टर को ओवरलोड करने की विधि की अनुमति देती हैं, जिसमें अलग-अलग मापदंडों के साथ एक वर्ग के लिए एक से अधिक कंस्ट्रक्टर हो सकते हैं। कुछ भाषाएँ कुछ विशेष प्रकार के कंस्ट्रक्टरों पर विचार करती हैं। कन्स्ट्रक्टर, जो वस्तुओं को बनाने के लिए ठोस रूप से एकल वर्ग का उपयोग करते हैं और कक्षा का एक नया उदाहरण लौटाते हैं, [[फैक्टरी (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग)]] द्वारा सारणित होते हैं, जो ऑब्जेक्ट भी बनाते हैं लेकिन कई वर्गों या विभिन्न आवंटन योजनाओं का उपयोग करके विभिन्न तरीकों से ऐसा कर सकते हैं। जैसे [[वस्तु पूल]]।
+अधिकांश भाषाएँ कंस्ट्रक्टर को ओवरलोड करने की अनुमति देती हैं, जिसमें विभिन्न पैरामीटर के साथ एक क्लास के लिए एक से अधिक कंस्ट्रक्टर हो सकते हैं। कुछ भाषाएँ कुछ विशेष प्रकार के कंस्ट्रक्टरों पर प्रतिफल प्राप्त करती हैं। कंस्ट्रक्टर्स जो ऑब्जेक्ट का निर्माण करने के लिए वस्तुतः एक क्लास का उपयोग करके क्लास का एक नवीन उदाहरण लौटाते हैं तथा [[फैक्टरी (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग)|ऑब्जेक्ट(ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग)]] द्वारा संक्षिप्त होते हैं जो ऑब्जेक्ट का निर्माण भी करते हैं परंतु क्लास या अनेक विभिन्न आवंटन योजनाओं जैसे ऑब्जेक्ट पूल का उपयोग करके विभिन्न प्रकारों से ऐसा कर सकते हैं।
 == प्रकार ==
-=== पैरामीटरयुक्त निर्माता ===
+=== परामित्रीकृत कंस्ट्रक्टर ===
-कंस्ट्रक्टर जो कम से कम एक तर्क ले सकते हैं उन्हें पैरामिट्रीकृत कंस्ट्रक्टर कहा जाता है। जब किसी ऑब्जेक्ट को पैरामीटरयुक्त कन्स्ट्रक्टर में घोषित किया जाता है, तो प्रारंभिक मानों को कन्स्ट्रक्टर फ़ंक्शन के तर्कों के रूप में पारित किया जाना चाहिए। वस्तु घोषणा का सामान्य तरीका काम नहीं कर सकता है। कंस्ट्रक्टर को स्पष्ट या निहित रूप से कहा जा सकता है। कंस्ट्रक्टर को निहित रूप से कॉल करने की विधि को शॉर्टहैंड विधि भी कहा जाता है।
+कंस्ट्रक्टर जो कम से कम एक तर्क ले सकते हैं उन्हें परामित्रीकृत कंस्ट्रक्टर कहा जाता है। जब किसी ऑब्जेक्ट को परामित्रीकृत कन्स्ट्रक्टर में डिक्लेयर (घोषित) किया जाता है, तो प्रारंभिक मानों को कन्स्ट्रक्टर फ़ंक्शन के तर्कों के रूप में पारण किया जाना चाहिए। ऑब्जेक्ट डिक्लेरेशन का सामान्य तरीका काम नहीं कर सकता है। कंस्ट्रक्टर को सुस्पष्ट या अस्पष्ट कहा जा सकता है। कंस्ट्रक्टर को अस्पष्ट रूप से निर्देशित करने की विधि को शॉर्टहैंड विधि भी कहा जाता है।
+ 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;
+ };
- निजी:
+=== कॉपी कंस्ट्रक्टर ===
-  इंट x_;
+{{see also|कॉपी कंस्ट्रक्टर (सी++)}}
-  इंट वाई_;
-};
-उदाहरण :: उदाहरण () = डिफ़ॉल्ट;
+सी++ के समान, जावा प्रोग्रामिंग में भी “कॉपी कंस्ट्रक्टर” का प्रयोग होता है। लेकिन, सी ++ के विपरीत, यदि आप स्वयं का कन्स्ट्रक्टर नहीं लिखते हैं तो जावा स्वतः निर्धारित (डिफ़ॉल्ट) कॉपी कन्स्ट्रक्टर का निर्माण नहीं करते है। कॉपी कंस्ट्रक्टर्स क्लास ऑब्जेक्ट्स को कॉपी करते समय कम्पाइलर द्वारा की जाने वाली क्रियाओं को परिभाषित करते है। कॉपी कंस्ट्रक्टर में एक औपचारिक पैरामीटर होता है जो कि क्लास का प्रकार होता है (पैरामीटर किसी ऑब्जेक्ट का संदर्भ हो सकता है)। इसका उपयोग समान क्लास के उपस्थित ऑब्जेक्ट की प्रतिलिपि बनाने के लिए किया जाता है। यद्यपि दोनों क्लास समान हैं, तो इसकी गणना कन्वर्जन कंस्ट्रक्टर के रूप में होती है। जबकि कॉपी कंस्ट्रक्टर सामान्यतः संक्षिप्त में कॉपी सीटीओआर या सीसीटीओआर होते हैं, उनका उसी संक्षिप्त नाम का उपयोग करके .नेट में उपयोग किए जाने वाले क्लास कंस्ट्रक्टर्स के साथ कोई संबंध नहीं होता है।
-उदाहरण :: उदाहरण (int x, int y): x_(x), y_(y) {}
+=== कन्वर्जन कंस्ट्रक्टर ===
-</वाक्यविन्यास हाइलाइट>
-<वाक्यविन्यास लैंग = सीपीपी>
+कनवर्ज़न कन्स्ट्रक्टर एक कम्पाइलर (अनुभाषक) के लिए एक अन्य प्रकार के ऑब्जेक्ट पर आधारित क्लास से संबंधित ऑब्जेक्ट का अस्पष्ट रूप से निर्माण करने के लिए साधन प्रदान करते हैं। सामान्यतः इन कंस्ट्रक्टर को तर्कों या ऑपरेंड को अस्पष्टतया एक उचित रूप में परिवर्तित करने के लिए उपयोग किया जाता है, लेकिन उन्हें सुस्पष्ट भी कहा जा सकता है।
-उदाहरण ई = उदाहरण (0, 50); // स्पष्ट कॉल।
-उदाहरण ई2(0, 50); // अंतर्निहित कॉल।
-</वाक्यविन्यास हाइलाइट>
-=== डिफ़ॉल्ट निर्माता ===
+=== मूव कंस्ट्रक्टर ===
-यदि प्रोग्रामर तात्कालिक वर्ग के लिए एक कंस्ट्रक्टर की आपूर्ति नहीं करता है, तो जावा कंपाइलर आपकी ओर से आपके कोड में एक डिफॉल्ट कंस्ट्रक्टर सम्मिलित करता है। इस कंस्ट्रक्टर को डिफॉल्ट कंस्ट्रक्टर के रूप में जाना जाता है। आप इसे अपने स्रोत कोड (जावा फ़ाइल) में नहीं पाएंगे क्योंकि यह संकलन के दौरान कोड में डाला जाएगा और .class फ़ाइल में मौजूद होगा। डिफ़ॉल्ट कन्स्ट्रक्टर का व्यवहार भाषा निर्भर है। यह डेटा सदस्यों को शून्य या अन्य समान मानों से प्रारंभ कर सकता है, या यह कुछ भी नहीं कर सकता है। जावा में, एक डिफॉल्ट कंस्ट्रक्टर एक अशक्त कंस्ट्रक्टर को संदर्भित करता है जो कंपाइलर द्वारा स्वचालित रूप से उत्पन्न होता है यदि क्लास के लिए कोई कंस्ट्रक्टर परिभाषित नहीं किया गया है या किसी प्रोग्रामर-परिभाषित कंस्ट्रक्टर की अनुपस्थिति में (जैसे जावा में, डिफॉल्ट कंस्ट्रक्टर सुपरक्लास के अशक्त को कॉल करता है) कन्स्ट्रक्टर, फिर एक खाली निकाय निष्पादित करता है)। सभी फ़ील्ड 0 (पूर्णांक प्रकार), 0.0 (फ़्लोटिंग-पॉइंट प्रकार), गलत (बूलियन प्रकार), या अशक्त (संदर्भ प्रकार) के प्रारंभिक मान पर छोड़े गए हैं।
-<वाक्यविन्यास लैंग = सीपीपी>
+सी++ में, [[कन्स्ट्रक्टर ले जाएं (सी ++)|मूव कंस्ट्रक्टर(सी ++)]] क्लास के किसी ऑब्जेक्ट के लिए आर मान संबंध निर्देश (रेफरेंस) लेते हैं और पैरामीटर ऑब्जेक्ट स्रोतों के अधिकारिता स्थानांतरण को कार्यान्वित करने के लिए उपयोग किए जाते हैं।
-#शामिल <iostream>
-कक्षा छात्र {
+== वाक्य - विन्यास ==
- जनता:
-  छात्र (इंट ए = 0, इंट बी = 0); // [[डिफ़ॉल्ट कंस्ट्रक्टर]]।
-  इंट ए;
+* [[जावा (प्रोग्रामिंग भाषा)]], [[सी ++]], सी#, [[ActionScript|एक्शनस्क्रिप्ट]], {{nowrap|[[पीएचपी]] 4}} और [[MATLAB|एमएटीएलएबी]] का नामित एक चलन है जिसमें कंस्ट्रक्टर का वही नाम होता है जैसा कि क्लास का होता है जिससे वे संबंधित हैं।
-  इंट बी;
+* पीएचपी 5 में, कंस्ट्रक्टर के लिए <code>__construct</code>अनुशंसित नाम है। पिछली संगतता के लिए, यदि<code>__construct</code> विधि नहीं मिल पाती है तो क्लास के समान नाम वाली एक विधि को कॉल किया जाएगा। पीएचपी 5.3.3 के उपरान्त, यह केवल गैर-नामस्थान क्लास के लिए काम करता है।<ref name="php5cpnstructor">[http://www.php.net/manual/en/language.oop5.decon.php Constructors and Destructors], from PHP online documentation</ref>
-};
+* पीएचपी 7 में, आपको सदैव कंस्ट्रक्टर को <code>__construct</code>से नामित करना चाहिए। क्लास के समान नाम वाली विधियाँ E_DEPRECATED स्तर की त्रुटि को प्रेरित करेंगी।
-</वाक्यविन्यास हाइलाइट>
+*[[पर्ल]] में, कंस्ट्रक्टर्स को समागम द्वारा "नया" नाम दिया गया है और उन्हें उचित मात्रा में ऑब्जेक्ट उत्पन्न करना है।
+* पर्ल के लिए [[मूस पर्ल|मूस ऑब्जेक्ट सिस्टम]] में, कन्स्ट्रक्टर (नया नामित) स्वचालित रूप से निर्मित और एक BUILD विधि निर्दिष्ट करके विस्तारित किए जाते हैं।
-=== कन्स्ट्रक्टर कॉपी करें ===
+* विजुअल बेसिक.नेट में  कंस्ट्रक्टर को  <code>New</code> कहा जाता है।
-{{see also|Copy constructor (C++)}}
+* पायथन में, कंस्ट्रक्टर को दो विधियों, <code>__new__</code>और<code>__init_</code>में विभाजित किया गया है।  <code>__new__</code>उदाहरण के लिए स्मृति आवंटित करने के लिए उत्तरदायी है, और क्लास को तर्क (पारंपरिक रूप से <code>cls</code> कहा जाता है) के रूप में पारित किया जाता है।<code>__init__</code>  विधि (जिसे प्रायः "प्रारंभकर्ता" कहा जाता है) नव निर्मित उदाहरण को तर्क (पारंपरिक रूप से <code>self</code> कहा जाता है) के रूप में पारित किया जाता है।<ref>[https://docs.python.org/3/reference/datamodel.html#basic-customization Data model], from Python online documentation</ref>
-C++ की तरह Java भी Copy Constructor को सपोर्ट करता है। लेकिन, सी ++ के विपरीत, यदि आप अपना खुद का नहीं लिखते हैं तो जावा डिफ़ॉल्ट कॉपी कन्स्ट्रक्टर नहीं बनाता है। कॉपी कंस्ट्रक्टर्स क्लास ऑब्जेक्ट्स को कॉपी करते समय कंपाइलर द्वारा की जाने वाली क्रियाओं को परिभाषित करते हैं। एक कॉपी कंस्ट्रक्टर में एक औपचारिक पैरामीटर होता है जो कि वर्ग का प्रकार होता है (पैरामीटर किसी वस्तु का संदर्भ हो सकता है)। इसका उपयोग उसी वर्ग की मौजूदा वस्तु की प्रतिलिपि बनाने के लिए किया जाता है। भले ही दोनों वर्ग समान हैं, यह रूपांतरण निर्माता के रूप में गिना जाता है।
+* [[वस्तु पास्कल|ऑब्जेक्ट  पास्कल]] कंस्ट्रक्टर्स को संकेत शब्द <code>constructor</code> द्वारा दर्शाया जाता है और इसमें उपयोगकर्ता-परिभाषित नाम हो सकते हैं। (किन्तु अधिकतर इन्हें<code>Create</code>कहा जाता है)
-जबकि कॉपी कंस्ट्रक्टर आमतौर पर संक्षिप्त कॉपी ctor या cctor होते हैं, उनका उसी संक्षिप्त नाम का उपयोग करके .NET में उपयोग किए जाने वाले क्लास कंस्ट्रक्टर्स से कोई लेना-देना नहीं होता है।
+* [[Objective-C|ऑब्जेक्टिव-सी]] में, कंस्ट्रक्टर विधि को दो विधियों <code>alloc</code>और<code>init</code> में विभाजित किया जाता है, जिसमे <code>alloc</code> विधि को क्लास के दृष्टांत के लिए अलग (आवंटित) मेमोरी के साथ निर्धारित किया जाता है और दृष्टांत को आरंभ करने के लिए <code>init</code> विधि का संचलन किया जाता है। क्लास दृष्टांत के लिए, विधि<code>new</code>के कॉल <code>alloc</code> और यह <code>init</code> दोनों विधियों को आमंत्रित करता है।
-=== रूपांतरण निर्माता ===
-कनवर्ज़न कन्स्ट्रक्टर एक कंपाइलर के लिए एक अलग प्रकार की वस्तु के आधार पर एक वर्ग से संबंधित वस्तु को स्पष्ट रूप से बनाने के लिए एक साधन प्रदान करते हैं। इन कंस्ट्रक्टरों को आमतौर पर तर्कों या ऑपरेंड को एक उपयुक्त प्रकार में बदलने के लिए लागू किया जाता है, लेकिन उन्हें स्पष्ट रूप से भी कहा जा सकता है।
-=== कन्स्ट्रक्टर ले जाएं ===
-C++ में, [[कन्स्ट्रक्टर ले जाएं (सी ++)]]C++) वर्ग के किसी ऑब्जेक्ट के लिए Rvalue संदर्भ लेता है, और पैरामीटर ऑब्जेक्ट के संसाधनों के स्वामित्व हस्तांतरण को लागू करने के लिए उपयोग किया जाता है।
-== सिंटेक्स ==
-* [[जावा (प्रोग्रामिंग भाषा)]], [[सी ++]], सी शार्प (प्रोग्रामिंग भाषा)|सी#, [[ActionScript]], {{nowrap|[[PHP]] 4}} और [[MATLAB]] का एक नामकरण सम्मेलन है जिसमें निर्माणकर्ताओं का नाम उसी वर्ग के समान होता है जिसके साथ वे जुड़े होते हैं।
-* PHP 5 में, कंस्ट्रक्टर के लिए अनुशंसित नाम है <code>__construct</code>. पश्चगामी संगतता के लिए, कक्षा के समान नाम वाली विधि को if कहा जाएगा <code>__construct</code> विधि नहीं मिल सकती। PHP 5.3.3 के बाद से, यह केवल गैर-नामित वर्गों के लिए काम करता है।<ref name="php5cpnstructor">[http://www.php.net/manual/en/language.oop5.decon.php Constructors and Destructors], from PHP online documentation</ref>
-* PHP 7 में, आपको हमेशा कंस्ट्रक्टर का नाम इस प्रकार रखना चाहिए <code>__construct</code>. वर्ग के समान नाम वाली विधियाँ E_DEPRECATED स्तर की त्रुटि को ट्रिगर करेंगी।<ref name="php5cpnstructor">[http://www.php.net/manual/en/language.oop5.decon.php Constructors and Destructors], from PHP online documentation</ref>
-* [[पर्ल]] में, कंस्ट्रक्टर्स को, कन्वेंशन द्वारा, नया नाम दिया जाता है और उन्हें उचित मात्रा में ऑब्जेक्ट क्रिएशन करना होता है।
-* पर्ल के लिए [[मूस पर्ल]] में, कंस्ट्रक्टर्स (नया नाम) स्वचालित रूप से बनाए जाते हैं और एक BUILD विधि निर्दिष्ट करके विस्तारित होते हैं।
-* विजुअल बेसिक .NET में कंस्ट्रक्टर को कहा जाता है<code>New</code>.
-* पायथन (प्रोग्रामिंग लैंग्वेज) में, कंस्ट्रक्टर को दो तरीकों से विभाजित किया जाता है,<code>__new__</code>और<code>__init__</code>. <code>__new__</code> e> विधि उदाहरण के लिए मेमोरी आवंटित करने के लिए ज़िम्मेदार है, और कक्षा को एक तर्क के रूप में प्राप्त करती है (पारंपरिक रूप से कहा जाता है<code>cls</code>). <code>__init__</code> e> विधि (जिसे अक्सर इनिशियलाइज़र कहा जाता है) नव निर्मित उदाहरण को एक तर्क के रूप में पारित किया जाता है (पारंपरिक रूप से कहा जाता है<code>self</code>).<ref>[https://docs.python.org/3/reference/datamodel.html#basic-customization Data model], from Python online documentation</ref>
-* [[वस्तु पास्कल]] कंस्ट्रक्टर्स को कीवर्ड द्वारा दर्शाया जाता है<code>constructor</code>और उपयोगकर्ता-परिभाषित नाम हो सकते हैं (लेकिन ज्यादातर कहलाते हैं<code>Create</code>).
-* [[Objective-C]] में, कंस्ट्रक्टर विधि दो विधियों में विभाजित है,<code>alloc</code>और<code>init</code>साथ <code>alloc</code> वर्ग के एक उदाहरण के लिए स्मृति को अलग (आवंटित) करने की विधि, और <code>init</code> उदाहरण को आरंभ करने के थोक को संभालने की विधि। विधि के लिए एक कॉल<code>new</code>दोनों का आह्वान करता है <code>alloc</code> और यह <code>init</code> तरीके, वर्ग उदाहरण के लिए।
 == मेमोरी संगठन ==
-Java, C#, और VB .NET में, कंस्ट्रक्टर एक विशेष मेमोरी स्ट्रक्चर में रेफरेंस टाइप ऑब्जेक्ट बनाता है जिसे कहा जाता है
+जावा, सी# और वीबी .नेट में, कंस्ट्रक्टर एक विशेष स्मृति संरचना (मेमोरी स्ट्रक्चर) में रेफरेंस प्रकार के ऑब्जेक्ट बनाता करता है जिसे " हीप " कहा जाता है। वैल्यू टाइप (जैसे इंट, डबल, आदि) " स्टैक " नामक अनुक्रमिक संरचना में बनाए जाते हैं। वीबी डॉट नेट और C भाषाएं भी नए ऑपरेटर को वैल्यू टाइप ऑब्जेक्ट बनाने की अनुमति देते हैं परंतु ये वैल्यू टाइप ऑब्जेक्ट स्टैक पर बनाए जाते हैं यद्यपि ऑपरेटर का उपयोग किया गया हो या नहीं।
- [[ढेर (डेटा संरचना)]]। मूल्य प्रकार (जैसे int, double, आदि) एक अनुक्रमिक संरचना में बनाए जाते हैं जिन्हें स्टैक (सार डेटा प्रकार) कहा जाता है।
-VB .NET और C# भी नए ऑपरेटर को वैल्यू टाइप ऑब्जेक्ट बनाने की अनुमति देते हैं, लेकिन ये वैल्यू टाइप ऑब्जेक्ट स्टैक पर बनाए जाते हैं, भले ही ऑपरेटर का उपयोग किया गया हो या नहीं।
-सी ++ में, ऑब्जेक्ट स्टैक पर बनाए जाते हैं जब कन्स्ट्रक्टर को नए ऑपरेटर के बिना बुलाया जाता है, और ढेर पर बनाया जाता है जब कन्स्ट्रक्टर को नए ऑपरेटर के साथ बुलाया जाता है। जब वे दायरे से बाहर हो जाते हैं तो ढेर वस्तुओं को स्पष्ट रूप से हटा दिया जाता है, जबकि ढेर वस्तुओं को विनाशक द्वारा स्पष्ट रूप से या स्पष्ट रूप से हटाए गए ऑपरेटर का उपयोग करके हटा दिया जाना चाहिए।
+सी ++ में ऑब्जेक्ट स्टैक पर बनाए जाते हैं जब कन्स्ट्रक्टर को नवीन संचालक के बिना आमंत्रित किया जाता है और जब कन्स्ट्रक्टर को नवीन संचालक के साथ आह्वान किया जाता है तो यह हिप पर बनाया जाता है। जब वे कार्यक्षेत्र से बाहर हो जाते हैं तो स्टैक ऑब्जेक्ट को अव्यक्त रूप से नष्ट कर दिया जाता है जबकि हिप ऑब्जेक्ट को डेस्ट्रक्टर द्वारा अव्यक्त रूप से या डिलीट चालक का उपयोग करके स्पष्ट रूप से मिटा देना चाहिए।
 == भाषा विवरण ==<!-- see also Category:Programming language comparisons -->
 === सी ++ ===
-C++ में कंस्ट्रक्टर का नाम क्लास का नाम होता है। यह कुछ भी नहीं लौटाता है। इसमें किसी भी [[विधि (कंप्यूटर प्रोग्रामिंग)]] जैसे पैरामीटर हो सकते हैं। कंस्ट्रक्टर फ़ंक्शंस आमतौर पर सार्वजनिक अनुभाग में घोषित किए जाते हैं, लेकिन संरक्षित और निजी अनुभागों में भी घोषित किए जा सकते हैं, यदि उपयोगकर्ता उन तक पहुँच को प्रतिबंधित करना चाहता है।
+सी++  में, कंस्ट्रक्टर का नाम क्लास का नाम होता है। इसका कुछ प्रतिलाभ नहीं होता है। इसमें किसी भी सदस्य [[विधि (कंप्यूटर प्रोग्रामिंग)|फ़ंक्शन (कंप्यूटर प्रोग्रामिंग)]] जैसे पैरामीटर हो सकते हैं। कंस्ट्रक्टर फ़ंक्शंस सामान्यतः जन अनुभाग में घोषित किए जाते हैं परंतु सुरक्षित और निजी क्षेत्र में भी घोषित किए जा सकते हैं यदि उपयोगकर्ता उन तक अभिगम को प्रतिबंधित करना चाहता है।
-कंस्ट्रक्टर के दो भाग होते हैं। सबसे पहले प्रारंभिक सूची है जो [[पैरामीटर (कंप्यूटर विज्ञान)]] का पालन करती है और विधि निकाय से पहले होती है। यह एक बृहदान्त्र से शुरू होता है और प्रविष्टियाँ अल्पविराम से अलग होती हैं। [[प्रारंभकर्ता सूची]] की आवश्यकता नहीं है, लेकिन डेटा सदस्यों के लिए मूल्य प्रदान करने और अलग-अलग असाइनमेंट स्टेटमेंट से बचने का अवसर प्रदान करता है। प्रारंभिक सूची आवश्यक है यदि आपके पास कॉन्स्ट या संदर्भ प्रकार डेटा सदस्य हैं, या सदस्य जिनके पास पैरामीटर रहित कन्स्ट्रक्टर तर्क नहीं है। असाइनमेंट उस क्रम के अनुसार होता है जिसमें डेटा सदस्यों को घोषित किया जाता है (भले ही प्रारंभकर्ता सूची में क्रम अलग हो)।<ref>https://stackoverflow.com/questions/1242830/constructor-initialization-list-evaluation-order Constructor</ref> दूसरा भाग बॉडी है, जो घुंघराले ब्रैकेट में संलग्न एक सामान्य विधि बॉडी है।
+कंस्ट्रक्टर के दो भाग होते हैं। सर्वप्रथम प्रारंभकर्ता सूची है जो [[पैरामीटर (कंप्यूटर विज्ञान)]] सूची के साथ जाती है और विधि निकाय से पहले होती है। यह एक कोलन (बृहदान्त्र) से प्रारम्भ होता है और प्रविष्टियाँ अल्पविराम से पृथक होती हैं। [[प्रारंभकर्ता सूची]] की आवश्यकता नहीं है, लेकिन डेटा सदस्यों के लिए मूल्य प्रदान करने और विभिन्न नियतन कथन से परिवर्जन का अवसर प्रदान करता है। प्रारंभिक सूची आवश्यक है यदि आपके पास कॉन्स्ट या संदर्भ प्रकार डेटा सदस्य हैं, या सदस्य जिनके पास पैरामीटरलेस कन्स्ट्रक्टर तर्क नहीं है। नियतन उस क्रम के अनुसार होता है जिसमें डेटा सदस्यों को घोषित किया जाता है (यदि प्रारंभकर्ता सूची में क्रम विभिन्न हो)।<ref>https://stackoverflow.com/questions/1242830/constructor-initialization-list-evaluation-order Constructor</ref> दूसरा भाग निकाय है जो मध्यम कोष्ठक में बंद एक सामान्य विधि निकाय है।
-C++ एक से अधिक कंस्ट्रक्टर की अनुमति देता है। अन्य कंस्ट्रक्टरों के अलग-अलग पैरामीटर होने चाहिए। इसके अतिरिक्त कंस्ट्रक्टर्स जिनमें पैरामीटर होते हैं जिन्हें डिफ़ॉल्ट मान दिए जाते हैं, उन्हें प्रतिबंध का पालन करना चाहिए कि सभी पैरामीटर को डिफ़ॉल्ट मान नहीं दिया जाता है। यह एक ऐसी स्थिति है जो केवल डिफ़ॉल्ट कन्स्ट्रक्टर होने पर ही मायने रखती है। एक [[आधार वर्ग]] (या बेस क्लास) के कंस्ट्रक्टर को एक व्युत्पन्न वर्ग द्वारा भी बुलाया जा सकता है। कंस्ट्रक्टर फ़ंक्शंस विरासत में नहीं मिले हैं और उनके पते को संदर्भित नहीं किया जा सकता है। जब स्मृति आवंटन की आवश्यकता होती है, तो नए और हटाए गए ऑपरेटरों को पूरी तरह से बुलाया जाता है।
+सी++ एक से अधिक कंस्ट्रक्टर की अनुमति देता है। अन्य कंस्ट्रक्टरों के विभिन्न पैरामीटर होने चाहिए। इसके अतिरिक्त कंस्ट्रक्टर्स जिनमें पैरामीटर होते हैं जिन्हें डिफ़ॉल्ट मान दिए जाते हैं, उन्हें प्रतिबंध का पालन करना चाहिए कि सभी पैरामीटर को डिफ़ॉल्ट मान नहीं दिया जाता है। यह एक ऐसी स्थिति है जो केवल डिफ़ॉल्ट कन्स्ट्रक्टर होने पर ही महत्व रखती है। एक [[आधार वर्ग|बेस क्लास]] के कंस्ट्रक्टर को एक व्युत्पन्न क्लास द्वारा भी कॉल किया जा सकता है। कंस्ट्रक्टर फ़ंक्शंस आनुवंशिक नहीं होते हैं और उनके एड्रेस को संदर्भित नहीं किया जा सकता है। जब स्मृति आवंटन की आवश्यकता होती है, तो न्यू और डिलीट ऑपरेटर को अव्यक्त रूप से कॉल किया जाता है।
-एक कॉपी कंस्ट्रक्टर में उसी प्रकार का एक पैरामीटर होता है जिसे कॉन्स्ट रेफरेंस के रूप में पास किया जाता है, उदाहरण के लिए वेक्टर (कॉन्स्ट वेक्टर और rhs)। यदि यह स्पष्ट रूप से प्रदान नहीं किया गया है, तो संकलक प्रत्येक सदस्य चर के लिए कॉपी कंस्ट्रक्टर का उपयोग करता है या आदिम प्रकारों के मामले में मूल्यों की प्रतिलिपि बनाता है। डिफ़ॉल्ट कार्यान्वयन कुशल नहीं है यदि कक्षा में सदस्यों को गतिशील रूप से आवंटित किया गया है (या अन्य संसाधनों को संभालता है), क्योंकि यह विनाश पर (या संसाधनों की दोहरी रिलीज) को हटाने के लिए डबल कॉल का कारण बन सकता है।
+एक कॉपी कंस्ट्रक्टर में उसी प्रकार का एक पैरामीटर होता है जिसे कॉन्स्ट रेफरेंस के रूप में पारित किया जाता है, उदाहरण के लिए वेक्टर (कॉन्स्ट वेक्टर और आरएचएस)। यदि यह स्पष्ट रूप से प्रदान नहीं किया गया है तो कम्पाइलर प्रत्येक परिवर्तनशील सदस्य के लिए कॉपी कन्स्ट्रक्टर का उपयोग करता है या पुराने प्रकारों की स्थिति में मूल्यों की प्रतिलिपि बनाता है। डिफ़ॉल्ट कार्यान्वयन सक्षम नहीं होगा यदि वर्ग ने सदस्यों को गतिशील रूप से आवंटित किया है (या अन्य संसाधनों को व्यवस्थित करता है) क्योंकि यह विनाश पर हटाने के लिए दोहरी कॉल (या संसाधनों की दोहरी रिलीज) का कारण बन सकता है।
+ 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);
-<वाक्यविन्यास लैंग = सीपीपी>
-वर्ग फूबार {
- जनता:
-  फोबार (डबल आर = 1.0,
-         डबल अल्फा = 0.0) // कंस्ट्रक्टर, डिफ़ॉल्ट मान वाले पैरामीटर।
-      : x_(r * cos(alpha)) // <- प्रारंभकर्ता सूची
-  {
-    वाई_ = आर * पाप (अल्फा); // <- सामान्य असाइनमेंट
-  }
- निजी:
-  डबल x_;
-  डबल वाई_;
-};
-</वाक्यविन्यास हाइलाइट>
-उदाहरण मंगलाचरण:
-<वाक्यविन्यास लैंग = सीपीपी>
-फोबार ए,
-       बी (3),
-       सी (5, एम_पीआई/4);
-</वाक्यविन्यास हाइलाइट>
-फ़ंक्शंस से ऑब्जेक्ट वापस करने या ऑब्जेक्ट को मान से पास करने पर, ऑब्जेक्ट कॉपी कंस्ट्रक्टर को निहित रूप से कहा जाएगा, जब तक कि [[वापसी मूल्य अनुकूलन]] लागू नहीं होता।
+फ़ंक्शंस से ऑब्जेक्ट निर्वाचित करने या ऑब्जेक्ट को वैल्यू से पारित करने पर, ऑब्जेक्ट कॉपी कंस्ट्रक्टर को अव्यक्त रूप से कॉल किया जाएगा, जब तक कि [[वापसी मूल्य अनुकूलन|रिटर्न वैल्यू ऑप्टिमाइज़ेशन]] अनप्रयुक्त नहीं होता।
-सी ++ स्पष्ट रूप से एक डिफ़ॉल्ट कॉपी कन्स्ट्रक्टर उत्पन्न करता है जो सभी बेस क्लास और सभी सदस्य चर के लिए कॉपी कन्स्ट्रक्टर को कॉल करेगा जब तक कि प्रोग्रामर एक प्रदान नहीं करता है, स्पष्ट रूप से कॉपी कन्स्ट्रक्टर को हटा देता है (क्लोनिंग को रोकने के लिए) या बेस क्लास या सदस्य चर कॉपी कन्स्ट्रक्टर को हटा दिया जाता है या पहुँच योग्य नहीं (निजी)। अनुकूलित 'कॉपी कन्स्ट्रक्टर' (उदाहरण के लिए [[संदर्भ गिनती]], पॉइंटर्स की [[गहरी प्रति]]लिपि) के लिए कॉल करने वाले अधिकांश मामलों में 'विनाशक' और 'प्रतिलिपि असाइनमेंट ऑपरेटर' को अनुकूलित करने की भी आवश्यकता होती है। इसे आमतौर पर [[तीन का नियम (C++ प्रोग्रामिंग)]] कहा जाता है।
+सी ++ स्पष्ट रूप से डिफॉल्ट कॉपी कंस्ट्रक्टर उत्पन्न करता है जो सभी बेस क्लास और सभी परिवर्तनशील सदस्य के लिए कॉपी कंस्ट्रक्टर को आमंत्रित करेगा जब तक कि प्रोग्रामर स्पष्ट रूप से कॉपी कंस्ट्रक्टर को हटा नहीं देता है (प्रतिरूपण को रोकने के लिए) या बेस क्लास या परिवर्तनशील सदस्य कॉपी कंस्ट्रक्टर में से एक को हटा दिया जाता है या जो उपलब्ध नहीं (निजी) है। स्वनिर्धारित कॉपी कंस्ट्रक्टर (उदाहरण के लिए [[संदर्भ गिनती|रेफरेंस काउंटिंग]], पॉइंटर्स की [[गहरी प्रति|डीप कॉपी]]) के लिए कॉल करने वाले अधिकांश स्थितियों में डिस्ट्रक्टर और कॉपी असाइनमेंट ऑपरेटर को अनुकूल करने की आवश्यकता होती है। इसे सामान्यतः [[तीन का नियम (C++ प्रोग्रामिंग)|रूल ऑफ थ्री (C++ प्रोग्रामिंग)]] से संदर्भित किया जाता है।
 === सी # ===
-उदाहरण सी शार्प (प्रोग्रामिंग लैंग्वेज)|सी# कंस्ट्रक्टर:
+उदाहरण: सी# कंस्ट्रक्टर:
-<वाक्यविन्यास प्रकाश लैंग = csharp>
-पब्लिक क्लास MyClass
-{
-    निजी इंट ए;
-    निजी स्ट्रिंग बी;
-    // कंस्ट्रक्टर
-    सार्वजनिक MyClass (): यह (42, स्ट्रिंग)
-    {
-    }
-    // कंस्ट्रक्टर को ओवरलोड करना
+ public class MyClass
-    सार्वजनिक 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;
+       }
      }
-}
-</वाक्यविन्यास हाइलाइट>
-<वाक्यविन्यास प्रकाश लैंग = csharp>
-// कोड कहीं
-// ऊपर दिए गए कंस्ट्रक्टर के साथ किसी ऑब्जेक्ट को इंस्टेंट करना
-MyClass c = नया MyClass (42, स्ट्रिंग);
-</वाक्यविन्यास हाइलाइट>
-==== सी # स्थिर कन्स्ट्रक्टर ====
-C Sharp (प्रोग्रामिंग लैंग्वेज) | C# में, एक स्टैटिक कंस्ट्रक्टर एक स्टैटिक डेटा इनिशियलाइज़र है। स्टेटिक कंस्ट्रक्टर्स को क्लास कंस्ट्रक्टर्स भी कहा जाता है। चूंकि उत्पन्न वास्तविक विधि का नाम .cctor है इसलिए उन्हें अक्सर cctors भी कहा जाता है।<ref>{{cite web|url=http://ericlippert.com/2013/02/06/static-constructors-part-one/ |title=Fabulous Adventures in Coding |publisher=Eric Lippert |date=2013-02-06|access-date=2014-04-05}}</ref><ref>{{cite book|url=https://books.google.com/books?id=oAcCRKd6EZgC&pg=PA222 |title=Expert .NET 2.0 IL Assembler |publisher=APress |date=2006-01-01|isbn=9781430202233 |access-date=2014-04-05}}</ref>
-स्टैटिक कंस्ट्रक्टर जटिल स्टैटिक वेरिएबल इनिशियलाइज़ेशन की अनुमति देते हैं।<ref>[http://msdn.microsoft.com/en-us/library/k9x6w0hc%28VS.80%29.aspx Static Constructor in C# on MSDN]</ref>
-जब क्लास को पहली बार एक्सेस किया जाता है तो स्टेटिक कंस्ट्रक्टर्स को निहित रूप से कहा जाता है। किसी वर्ग (स्टेटिक या कंस्ट्रक्टर कॉल) के लिए कोई भी कॉल, स्टैटिक कंस्ट्रक्टर निष्पादन को ट्रिगर करता है।
-स्टेटिक कंस्ट्रक्टर थ्रेड सुरक्षित हैं और [[सिंगलटन पैटर्न]] लागू करते हैं। जब एक [[सामान्य प्रोग्रामिंग]] क्लास में उपयोग किया जाता है, तो स्थिर कंस्ट्रक्टर को हर नए जेनेरिक इंस्टेंटेशन पर प्रति प्रकार एक कहा जाता है। स्थैतिक चर भी तत्काल होते हैं।
-<वाक्यविन्यास प्रकाश लैंग = csharp>
+    // Code somewhere
-पब्लिक क्लास MyClass
+    // Instantiating an object with the constructor above)
-{
+   MyClass c = new MyClass(42, "string");
-    निजी स्थिर int _A;
+==== सी# स्टेटिक कन्स्ट्रक्टर ====
-    // सामान्य कंस्ट्रक्टर
+सी# में, स्टेटिक कन्स्ट्रक्टर एक स्थिर डेटा प्रारंभकर्ता है। स्टेटिक कंस्ट्रक्टर्स को क्लास कंस्ट्रक्टर्स भी कहा जाता है। चूँकि उत्पन्न हुई वास्तविक विधि का नाम .सीसीटीओआर होता है उन्हें प्रायः "सीसीटीओआरएस" भी कहा जाता है।<ref>{{cite web|url=http://ericlippert.com/2013/02/06/static-constructors-part-one/ |title=Fabulous Adventures in Coding |publisher=Eric Lippert |date=2013-02-06|access-date=2014-04-05}}</ref><ref>{{cite book|url=https://books.google.com/books?id=oAcCRKd6EZgC&pg=PA222 |title=Expert .NET 2.0 IL Assembler |publisher=APress |date=2006-01-01|isbn=9781430202233 |access-date=2014-04-05}}</ref>
-    स्थिर MyClass ()
-    {
-        _ए = 32;
-    }
-    // स्टैंडर्ड डिफॉल्ट कंस्ट्रक्टर
+स्टैटिक कंस्ट्रक्टर जटिल स्टैटिक चर आरंभीकरण की अनुमति देते हैं।<ref>[http://msdn.microsoft.com/en-us/library/k9x6w0hc%28VS.80%29.aspx Static Constructor in C# on MSDN]</ref>स्टैटिक कंस्ट्रक्टर्स को अव्यक्तता से कॉल किया जाता है जब क्लास को सर्वप्रथम अभिगम किया जाता है। किसी क्लास (स्टेटिक या कंस्ट्रक्टर कॉल) के लिए कोई भी कॉल स्टैटिक कंस्ट्रक्टर निष्पादन को प्रेरित करता है। स्टेटिक कंस्ट्रक्टर थ्रेड सुरक्षित हैं और [[सिंगलटन पैटर्न]] कार्यान्वित करती हैं। जब एक [[सामान्य प्रोग्रामिंग]] क्लास में उपयोग किया जाता है, तो स्टेटिक कंस्ट्रक्टर को प्रति नए जेनेरिक इंस्टेंटेशन पर अनेक प्रकार से कॉल किया जाता है। स्टेटिक चर भी दृष्टांतिकृत होते हैं।
-    सार्वजनिक MyClass ()
+ 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();
-<वाक्यविन्यास प्रकाश लैंग = csharp>
-// कोड कहीं
-// ऊपर दिए गए कंस्ट्रक्टर के साथ किसी ऑब्जेक्ट को इंस्टेंट करना
-// तात्कालिकता से ठीक पहले
-// परिवर्तनीय स्थिर कन्स्ट्रक्टर निष्पादित किया गया है और _A 32 है
-MyClass c = नया MyClass ();
-</वाक्यविन्यास हाइलाइट>
 === [[सीएफएमएल]] ===
-सीएफएमएल 'नामक एक विधि का उपयोग करता है<code>init</code>'एक निर्माता विधि के रूप में।
+सीएफएमएल <code>init</code> नामक एक विधि को कन्स्ट्रक्टर विधि के रूप में उपयोग करता है।
-चीज़.सीएफसी
-<वाक्यविन्यास लैंग = जावास्क्रिप्ट>
-अवयव {
-   // गुण
-   संपत्ति का नाम = पनीर का नाम;
-   // कंस्ट्रक्टर
-   फ़ंक्शन चीज़ इनिट (आवश्यक स्ट्रिंग चीज़नाम) {
-      चर। पनीर नाम = तर्क। पनीर नाम;
-      इसे वापस करो;
-   }
-}
-</वाक्यविन्यास हाइलाइट>
+'''पनीर.सीएफसी'''
+   component {
+   // properties
+      property name="cheeseName";
+   // constructor
+      function Cheese init( required string cheeseName ) {
+      variables.cheeseName = arguments.cheeseName;
+      return this;
+     }
+       }
 एक पनीर का उदाहरण बनाएँ।
-<वाक्यविन्यास लैंग = जावास्क्रिप्ट>
+  myCheese = new Cheese( 'Cheddar' );
-myCheese = नया पनीर ('चेडर');
+चूंकि कोल्डफ्यूजन 10 सीएफएमएल ने भी कन्स्ट्रक्टर विधि का नाम निर्दिष्ट करने का समर्थन किया है:
-</वाक्यविन्यास हाइलाइट>
+  component initmethod="Cheese"
+ {
-कोल्डफ्यूजन 10 के बाद से,<ref>[https://wikidocs.adobe.com/wiki/display/coldfusionen/cfcomponent CFComponent]</ref> सीएफएमएल ने कन्स्ट्रक्टर विधि का नाम निर्दिष्ट करने का भी समर्थन किया है:
+    // properties
+      property name="cheeseName";
-<वाक्यविन्यास लैंग = जावास्क्रिप्ट>
-घटक initmethod = पनीर {
+  // constructor
-    // गुण
+     function Cheese Cheese( required string cheeseName ) {
-   संपत्ति का नाम = पनीर का नाम;
+     variables.cheeseName = arguments.cheeseName;
+     return this;
-   // कंस्ट्रक्टर
+       }
-   फंक्शन चीज़ चीज़ (आवश्यक स्ट्रिंग चीज़नाम) {
-      चर। पनीर नाम = तर्क। पनीर नाम;
-       इसे वापस करो;
     }
-}
-</वाक्यविन्यास हाइलाइट>
 === एफिल ===
-एफिल (प्रोग्रामिंग लैंग्वेज) में, नई वस्तुओं को इनिशियलाइज़ करने वाली दिनचर्या को निर्माण प्रक्रियाएँ कहा जाता है। निर्माण प्रक्रियाओं में निम्नलिखित विशेषताएं हैं:
+एफिल में, नए ऑब्जेक्ट को आरंभ करने वाली नेमका को निर्माण प्रक्रिया कहा जाता है। निर्माण प्रक्रियाओं में निम्नलिखित विशेषताएं हैं:
-* निर्माण प्रक्रियाओं का कोई स्पष्ट वापसी प्रकार नहीं है (प्रक्रिया की परिभाषा के अनुसार)।{{Efn|Eiffel ''routines'' are either ''procedures'' or ''functions''. Procedures never have a return type. Functions always have a return type.}}
+* निर्माण प्रक्रियाओं का कोई स्पष्ट रिटर्न प्रकार नहीं है ( प्रक्रिया की परिभाषा के अनुसार )।{{Efn|Eiffel ''routines'' are either ''procedures'' or ''functions''. Procedures never have a return type. Functions always have a return type.}}
-* निर्माण प्रक्रियाओं का नाम दिया गया है।
+* निर्माण प्रक्रियाएं नामित होती है।
-* निर्माण प्रक्रियाओं को कक्षा के पाठ में निर्माण प्रक्रियाओं के नाम से नामित किया गया है।
+* निर्माण प्रक्रियाओं को क्लास के पाठ में निर्माण प्रक्रियाओं के नाम से नामित किया गया है।
-* मौजूदा वस्तुओं को फिर से शुरू करने के लिए निर्माण प्रक्रियाओं को स्पष्ट रूप से लागू किया जा सकता है।
+* उपस्थित वस्तुओं को पुन: प्रारंभ करने के लिए निर्माण प्रक्रियाओं को स्पष्ट रूप से आह्वान किया जा सकता है।
-* प्रत्येक प्रभावी (यानी, ठोस या गैर-सार) वर्ग को कम से कम एक निर्माण प्रक्रिया निर्दिष्ट करनी चाहिए।
+* प्रत्येक प्रभावी (अर्थात ठोस या गैर-सार) क्लास को न्यूनतम एक निर्माण प्रक्रिया निर्दिष्ट करनी चाहिए।
-* निर्माण प्रक्रियाओं को नए आरंभिक ऑब्जेक्ट को उस अवस्था में छोड़ देना चाहिए जो वर्ग अपरिवर्तनीय को संतुष्ट करता है।{{Efn|Because the inherited class invariant must be satisfied, there is no mandatory call to the parents' constructors.}}
+* निर्माण प्रक्रियाओं को नव आरंभीकृत ऑब्जेक्ट को उस स्थिति में छोड़ देना चाहिए जो क्लास इंवरिएंट को संतुष्ट करता है।{{Efn|Because the inherited class invariant must be satisfied, there is no mandatory call to the parents' constructors.}}
-हालाँकि वस्तु निर्माण में कुछ सूक्ष्मताएँ शामिल हैं,<ref name="eiffel standard">[http://www.ecma-international.org/publications/standards/Ecma-367.htm Eiffel ISO/ECMA specification document]</ref> एक विशिष्ट घोषणा के साथ एक विशेषता का निर्माण <code lang= eiffel >x: T</code> जैसा कि एक निर्माण निर्देश में व्यक्त किया गया है <code lang= eiffel >create x.make</code> में निम्नलिखित चरणों का क्रम शामिल है:
+यद्यपि ऑब्जेक्ट निर्माण में कुछ सूक्ष्मताएँ सम्मिलित हैं,<ref name="eiffel standard">[http://www.ecma-international.org/publications/standards/Ecma-367.htm Eiffel ISO/ECMA specification document]</ref> एक विशिष्ट घोषणा <code lang= eiffel >x: T</code> के साथ एक विशेषता का निर्माण जो एक निर्माण निर्देशन<code lang= eiffel >create x.make</code> में व्यक्त की गई जिसमें निम्नलिखित चरणों के अनुक्रम सम्मिलित है:
 * <code lang= eiffel>T</code> प्रकार का एक नया प्रत्यक्ष उदाहरण बनाएं।{{Efn|The Eiffel standard requires fields to be initialized on first access, so it is not necessary to perform default field initialization during object creation.}}
-* नव निर्मित उदाहरण के लिए निर्माण प्रक्रिया निष्पादित करें।
+* नव निर्मित दृष्टांत के लिए निर्माण प्रक्रिया <code lang="eiffel">make</code> को निष्पादित करें।
-* नई प्रारंभिक वस्तु को इकाई <कोड लैंग = एफिल> x </ कोड> में संलग्न करें।
+* ननई प्रारंभिक ऑब्जेक्ट को इकाई  x से संलग्न करें।।
-नीचे दिए गए पहले स्निपेट में, वर्ग <code lang= eiffel>POINT</code> परिभाषित किया गया है। कार्यविधि <code lang= eiffel>make</code> को <code lang= eiffel>feature</code> कीवर्ड के बाद कोडित किया जाता है।
-कीवर्ड <code lang= eiffel >create</code> प्रक्रियाओं की एक सूची प्रस्तुत करता है जिसका उपयोग उदाहरणों को आरंभ करने के लिए किया जा सकता है। इस मामले में सूची में <code lang= eiffel >default_create</code>, <code lang= eiffel>ANY</code> वर्ग से विरासत में मिली खाली कार्यान्वयन वाली एक प्रक्रिया, और <code lang= eiffel>बनाना</code> शामिल है कोड> प्रक्रिया कक्षा के भीतर कोडित।
-<वाक्यविन्यास लैंग = एफिल>
-कक्षा
-    बिंदु
-बनाएं
-    डिफ़ॉल्ट_क्रिएट, मेक
-विशेषता
-    बनाना (a_x_value: REAL; a_y_value: REAL)
+नीचे दिए गए सर्वप्रथम स्निपेट में, क्लास <code lang= eiffel>POINT</code> परिभाषित किया गया है। कार्यविधि <code lang= eiffel>make</code> सूचक शब्द <code lang= eiffel>feature</code> के पश्चात कोडित किया गया है।
-        करना
-            एक्स := a_x_value
-            y := a_y_value
-        अंत
-    एक्स: असली
+सूचक शब्द <code lang= eiffel >create</code> क्रियाओं की एक सूची प्रस्तावित करता है जिसका उपयोग दृष्टांत को प्रारंभ करने के लिए किया जा सकता है। इस स्थिति में सूची में <code lang= eiffel >default_create</code> क्लास  <code lang= eiffel>ANY</code> से आनुवंशिक रिक्त कार्यान्वयन वाली प्रक्रिया और क्लास के भीतर कोडित <code lang= eiffel>make</code>  प्रक्रिया सम्मिलित है।
-            - एक्स समन्वय
+ 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
+             ...
-    वाई: असली
-            - वाई समन्वय
-        ...
-</वाक्यविन्यास हाइलाइट>
-दूसरे स्निपेट में, एक वर्ग जो कि <code lang= eiffel>POINT</code> का क्लाइंट है, में <code lang= eiffel>my_point_1</code> और <code lang= eiffel>my_point_2</code> का डिक्लेरेशन होता है टाइप करें <कोड लैंग = एफिल> बिंदु </ कोड>।
-प्रक्रियात्मक कोड में, <code lang= eiffel>my_point_1</code> को मूल (0.0, 0.0) के रूप में बनाया जाता है। क्योंकि कोई निर्माण प्रक्रिया निर्दिष्ट नहीं है, प्रक्रिया <code lang= eiffel >default_create</code> वर्ग <code lang= eiffel >ANY</code> से विरासत में मिली है। इस पंक्ति को <code lang= eiffel >create my_point_1.default_create</code> कोडित किया जा सकता था।
+दूसरे स्निपेट में, एक क्लास जो कि <code lang= eiffel>POINT</code> के क्लाइंट है, उसके पास <code lang= eiffel>my_point_1</code> और <code lang= eiffel>my_point_2</code> घोषणाएं  हैं।
-केवल निर्माण प्रक्रियाओं के रूप में नामित प्रक्रियाओं का उपयोग <code lang= eiffel>create</code> कीवर्ड वाले निर्देश में किया जा सकता है।
-अगला <code lang= eiffel >my_point_2</code> के लिए एक निर्माण निर्देश है, जो <code lang= eiffel>my_point_2</code> के निर्देशांकों के लिए आरंभिक मान प्रदान करता है।
-तीसरा निर्देश अलग-अलग मानों के साथ <code lang= eiffel>my_point_2</code> से जुड़े इंस्टेंस को फिर से शुरू करने के लिए <code lang= eiffel>make</code> प्रक्रिया के लिए एक सामान्य उदाहरण कॉल करता है।
-<वाक्यविन्यास लैंग = एफिल>
+प्रक्रियात्मक कोड में, <code lang= eiffel>my_point_1</code> को मूल (0.0, 0.0) के रूप में निर्माण किया गया है। क्योंकि कोई निर्माण प्रक्रिया निर्दिष्ट नहीं है, क्लास <code lang="eiffel">ANY</code> से आनुवंशिक प्रक्रिया <code lang= eiffel >default_create</code> का उपयोग किया जाता है। इस पंक्ति को <code lang= eiffel >create my_point_1.default_create</code> में कोडित किया जा सकता था।<code lang= eiffel>create</code>  सूचक शब्द के साथ निर्देश में केवल निर्माण प्रक्रियाओं के रूप में नामित प्रक्रियाओं का उपयोग किया जा सकता है।
-    my_point_1: बिंदु
-    my_point_2: बिंदु
-        ...
-            my_point_1 बनाएं
+अगला <code lang="eiffel">my_point_2</code> के लिए एक निर्माण निर्देश है, जो <code lang="eiffel">my_point_2</code> के निर्देशांकों के लिए प्रारंभिक मान प्रदान करता है। तीसरा निर्देश <code lang="eiffel">my_point_2</code> के साथ विभिन्न वैल्यू से संलग्न दृष्टांत को पुन: प्रारंभ करने के लिए <code lang="eiffel">make</code> प्रक्रिया को सामान्य दृष्टांत कॉल करता है।
-            my_point_2 बनाएं। मेक (3.0, 4.0)
+ my_point_1: POINT
-            my_point_2. बनाना (5.0, 8.0)
+ 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)
+         ...
 === एफ # ===
-एफ शार्प (प्रोग्रामिंग लैंग्वेज) | एफ # में, एक कंस्ट्रक्टर में कोई भी शामिल हो सकता है <code>let</code> या <code>do</code> एक वर्ग में परिभाषित कथन। <code>let</code> बयान निजी क्षेत्रों को परिभाषित करते हैं और <code>do</code> कथन कोड निष्पादित करते हैं। अतिरिक्त कंस्ट्रक्टर का उपयोग करके परिभाषित किया जा सकता है <code>new</code> कीवर्ड।
+एफ # में, एक कंस्ट्रक्टर में किसी क्लास में परिभाषित कोई भी <code>let</code> या <code>do</code> कथन सम्मिलित हो सकता है। <code>let</code> कथन निजी क्षेत्रों को परिभाषित करते हैं और <code>do</code> कथन कोड निष्पादित करते हैं। अतिरिक्त कंस्ट्रक्टर्स को <code>new</code> सूचक शब्द का उपयोग करके परिभाषित किया जा सकता है।
+ type MyClass(_a: int, _b: string) = class
-<वाक्यविन्यास लैंग = fsharp>
+     // Primary constructor
-टाइप करें MyClass(_a : int, _b : string) = class
+     let a = _a
-    // प्राथमिक कंस्ट्रक्टर
+     let b = _b
-    चलो एक = _ए
+     do printfn "a = %i, b = %s" a b
-    चलो बी = _बी
-    do Printfn a =% i, b =% s a b
+     // Additional constructors
+     new(_a: int) = MyClass(_a, "") then
-    // अतिरिक्त कंस्ट्रक्टर
+         printfn "Integer parameter given"
-    new(_a : int) = MyClass(_a, ) फिर
-        Printfn पूर्णांक पैरामीटर दिया गया
+     new(_b: string) = MyClass(0, _b) then
+         printfn "String parameter given"
-    new(_b : string) = MyClass(0, _b) फिर
-        Printfn स्ट्रिंग पैरामीटर दिया गया
+     new() = MyClass(0, "") then
+         printfn "No parameter given"
-    new() = MyClass(0, ) तब
+ end
-        Printfn कोई पैरामीटर नहीं दिया गया
-अंत
-</वाक्यविन्यास हाइलाइट>
-<वाक्यविन्यास लैंग = fsharp>
-// कोड कहीं
-// प्राइमरी कंस्ट्रक्टर के साथ किसी ऑब्जेक्ट को इंस्टेंट करना
-चलो सी 1 = नया MyClass (42, स्ट्रिंग)
-// अतिरिक्त कंस्ट्रक्टर के साथ किसी ऑब्जेक्ट को इंस्टेंट करना
+ // Code somewhere
-चलो सी 2 = नया MyClass (42)
+ // instantiating an object with the primary constructor
-चलो c3 = नया MyClass (स्ट्रिंग)
+ let c1 = new MyClass(42, "string")
-c4 = MyClass () // नया कीवर्ड वैकल्पिक है
-</वाक्यविन्यास हाइलाइट>
+ // instantiating an object with additional constructors
+ let c2 = new MyClass(42)
+ let c3 = new MyClass("string")
+ let c4 = MyClass() // "new" keyword is optional"
 === जावा ===
-जावा (प्रोग्रामिंग लैंग्वेज) में, कंस्ट्रक्टर अन्य तरीकों से भिन्न होते हैं:
+जावा (प्रोग्रामिंग लैंग्वेज) में, कंस्ट्रक्टर अन्य विधियों से इस प्रकार भिन्न होते हैं कि:
 * कंस्ट्रक्टर्स के पास कभी भी स्पष्ट रिटर्न प्रकार नहीं होता है।
-* कंस्ट्रक्टर्स को सीधे नहीं बुलाया जा सकता (कीवर्ड "<code>new</code>” उन्हें आमंत्रित करता है)।
+* कंस्ट्रक्टर्स को सीधे नहीं आह्वान किया जा सकता है (सूचक शब्द "<code>new</code>” उन्हें आमंत्रित करता है)।
 * कंस्ट्रक्टर्स के पास नॉन-एक्सेस मॉडिफायर्स नहीं होने चाहिए।
 जावा कंस्ट्रक्टर निम्नलिखित क्रम में निम्नलिखित कार्य करते हैं:
-# यदि कोई कंस्ट्रक्टर परिभाषित नहीं है, तो सुपरक्लास के डिफॉल्ट कंस्ट्रक्टर को कॉल करें।
+# यदि कोई कन्स्ट्रक्टर परिभाषित नहीं किया गया है तो सुपरक्लास के डिफ़ॉल्ट कन्स्ट्रक्टर को कॉल करें।
 # निर्दिष्ट मानों के लिए सदस्य चर प्रारंभ करें।
-# कंस्ट्रक्टर के शरीर को निष्पादित करें।
+# कंस्ट्रक्टर के बॉडी को निष्पादित करता है।
-जावा उपयोगकर्ताओं को एक कन्स्ट्रक्टर को दूसरे कन्स्ट्रक्टर में कॉल करने की अनुमति देता है <code>this()</code> कीवर्ड।
+जावा उपयोगकर्ताओं को <code>this()</code> सूचक शब्द का उपयोग करके एक कंस्ट्रक्टर को दूसरे कंस्ट्रक्टर में कॉल करने की अनुमति देता है। लेकिन <code>this()</code> पहला कथन होना चाहिए। <ref>[https://ranjeetkumarmaurya.wordpress.com/2017/02/06/constructor-in-java/ Details on Constructor in java]</ref>
-लेकिन <code>this()</code> पहला कथन होना चाहिए। <ref>[https://ranjeetkumarmaurya.wordpress.com/2017/02/06/constructor-in-java/ Details on Constructor in java]</ref>
+    class Example
-<वाक्यविन्यास प्रकाश लैंग = जावा>
+    {
-वर्ग उदाहरण
+      Example() // Non-parameterized constructor
-{
-    उदाहरण () // गैर-पैरामीटरयुक्त कंस्ट्रक्टर
      {
-        यह (1); // कंस्ट्रक्टर की कॉलिंग
+      this(1);  // Calling of constructor
-        System.out.println (0-तर्क-विपक्ष);
+      System.out.println("0-arg-cons");
      }
-    उदाहरण (इंट ए) // पैरामीटरेटेड कंस्ट्रक्टर
+      Example(int a) // Parameterized constructor
      {
-        System.out.println (1-तर्क-विपक्ष);
+      System.out.println("1-arg-cons");
      }
-}
-सार्वजनिक स्थैतिक शून्य main (String [] args)
-{
-  उदाहरण ई = नया उदाहरण ();
-}
-</वाक्यविन्यास हाइलाइट>
-जावा सुपरक्लास (कंप्यूटर साइंस) | सुपरक्लास के कंस्ट्रक्टर के माध्यम से एक्सेस प्रदान करता है <code>super</code> कीवर्ड।
-<वाक्यविन्यास प्रकाश लैंग = जावा>
-सार्वजनिक वर्ग उदाहरण
-{
-    // कंस्ट्रक्टर की परिभाषा।
-    सार्वजनिक उदाहरण ()
-    {
-        यह (1);
      }
+      public static void main(String[] args)
-    // कंस्ट्रक्टर को ओवरलोड करना
-    सार्वजनिक उदाहरण (इंट इनपुट)
      {
-        डेटा = इनपुट; // यह एक असाइनमेंट है
+      Example e = new Example();
      }
-    // उदाहरण चर (ओं) की घोषणा।
+जावा <code>super</code> सूचक शब्द के माध्यम से सुपरक्लास (कंप्यूटर साइंस) के कंस्ट्रक्टर तक अभिगमन (ऐक्सेस) प्रदान करता है।
-    निजी इंट डेटा;
+      public class Example
-}
+     {
-</वाक्यविन्यास हाइलाइट>
+     // Definition of the constructor.
+     public Example()
-<वाक्यविन्यास प्रकाश लैंग = जावा>
+     {
-// कोड कहीं और
+         this(1);
-// उपरोक्त कंस्ट्रक्टर के साथ किसी वस्तु को इंस्टेंट करना
+     }
-उदाहरण ई = नया उदाहरण (42);
-</वाक्यविन्यास हाइलाइट>
+     // Overloading a constructor
+     public Example(int input)
-शून्य संख्या में तर्क लेने वाले कंस्ट्रक्टर को नो-आर्गुमेंट या नो-आर्ग कंस्ट्रक्टर कहा जाता है।<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>
+     {
+         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);
+शून्य संख्या में तर्क लेने वाले कंस्ट्रक्टर को "नो-आर्गुमेंट्स" या "नो-आर्ग" कंस्ट्रक्टर कहा जाता है।<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>
 === [[जावास्क्रिप्ट]] ===
-ES6 के रूप में, जावास्क्रिप्ट में कई अन्य प्रोग्रामिंग भाषाओं की तरह प्रत्यक्ष रचनाकार हैं। वे इस तरह लिखे गए हैं
+ईएस6 के रूप में, जावास्क्रिप्ट में कई अन्य प्रोग्रामिंग भाषाओं के समान डायरेक्ट कंस्ट्रक्टर हैं। वे इस तरह लिखे गए हैं
+ class FooBar {
+   constructor(baz) {
+     this.baz = baz
+ }
+   }
+इसे इस तरह द्रिश्तान्किक्रित किया जा सकता है
+ const foo = new FooBar('7')
-<वाक्यविन्यास लैंग = जावास्क्रिप्ट>
+ईएस6 से पहले इसके समतुल्य एक ऐसा फंक्शन बना रहा था जो किसी ऑब्जेक्ट को इस तरह से द्रिश्तान्किक्रित करता है
-कक्षा फूबार {
+  function FooBar (baz) {
-  निर्माता (बाज़) {
+     this.baz = baz;
-    यह.बाज़ = बाज़
+  };
-  }
+इसे ऊपर की तरह ही द्रिश्तान्किक्रित किया जाता है।
-}
-</वाक्यविन्यास हाइलाइट>
-इसे इस तरह तत्काल किया जा सकता है
-<वाक्यविन्यास लैंग = जावास्क्रिप्ट>
-कॉन्स्ट फू = नया फूबार ('7')
-</वाक्यविन्यास हाइलाइट>
-ES6 से पहले इसके समतुल्य, एक ऐसा फंक्शन बना रहा था जो किसी वस्तु को इस तरह से इंस्टेंट करता है
-<वाक्यविन्यास लैंग = जावास्क्रिप्ट>
-समारोह FooBar (बाज़) {
-  यह.बाज़ = बाज़;
-}
-</वाक्यविन्यास हाइलाइट>
-इसे ऊपर की तरह ही इंस्टेंट किया जाता है।
 === ऑब्जेक्ट पास्कल ===
-ऑब्जेक्ट पास्कल में, कंस्ट्रक्टर फ़ैक्टरी विधि के समान है। नियमित तरीकों के लिए केवल वाक्यगत अंतर कीवर्ड है <code>constructor</code> नाम के सामने (के बजाय <code>procedure</code> या <code>function</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;
+     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.
-<वाक्यविन्यास लैंग = डेल्फी>
+=== ओसीएएमएल ===
-कार्यक्रम ऊपप्रोग्राम;
-प्रकार
+ओसीएएमएल (प्रोग्रामिंग लैंग्वेज) में, एक कंस्ट्रक्टर होता है। पैरामीटर्स को क्लास के नाम के ठीक बाद परिभाषित किया गया है। उनका उपयोग आवृत्ति चर को आरंभ करने के लिए किया जा सकता है और सम्पूर्ण क्लास में ऐक्सेस किया जा सकता है। <code>initializer</code> नामक एक अज्ञातकृत प्रच्छन्न विधि, ऑब्जेक्ट के निर्माण के तुरंत बाद एक अभिव्यक्ति का मूल्यांकन करने की अनुमति देती है।<ref>[http://caml.inria.fr/pub/docs/manual-ocaml/index.html OCaml manual]</ref>
-  टीपर्सन = क्लास
+   class person first_name last_name =
-  निजी
+      object
-    FName: स्ट्रिंग;
+        val full_name = first_name ^ " " ^ last_name
-  जनता
-    संपत्ति का नाम: स्ट्रिंग FName पढ़ें;
+        initializer
-    निर्माता बनाएँ (नाम: स्ट्रिंग);
+          print_endline("Hello there, I am " ^ full_name ^ ".")
-  अंत;
+        method get_last_name = last_name
-निर्माता TPerson.Create (AName: string);
+      end;;
-शुरू
-  एफनाम: = एनाम;
+   let alonzo = new person "Alonzo" "Church" in (*Hello there, I am Alonzo Church.*)
-अंत;
+   print_endline alonzo#get_last_name (*Church*)
-वर
-  व्यक्ति: टीपीसन;
-शुरू
-  व्यक्ति := TPerson.Create('पीटर'); // TPerson का एक उदाहरण आवंटित करता है और फिर TPerson.Create को पैरामीटर AName = 'Peter' के साथ कॉल करता है
-अंत।
-</वाक्यविन्यास हाइलाइट>
-=== ओकैमल ===
-OCaml (प्रोग्रामिंग लैंग्वेज) में, एक कंस्ट्रक्टर होता है। Parameters को वर्ग के नाम के ठीक बाद परिभाषित किया गया है। उनका उपयोग आवृत्ति चर को आरंभ करने के लिए किया जा सकता है और पूरे वर्ग में पहुँचा जा सकता है। एक अनाम छिपी हुई विधि कहलाती है <code>initializer</code> वस्तु के निर्माण के तुरंत बाद एक अभिव्यक्ति का मूल्यांकन करने की अनुमति देता है।
-<ref>[http://caml.inria.fr/pub/docs/manual-ocaml/index.html OCaml manual]</ref>
-<वाक्यविन्यास प्रकाश लैंग = ओकैमल>
-वर्ग व्यक्ति प्रथम_नाम अंतिम_नाम =
-  वस्तु
-    वैल पूर्ण_नाम = प्रथम_नाम ^ ^ अंतिम_नाम
-    प्रारंभकर्ता
-      Print_endline (नमस्कार, मैं ^ पूर्ण_नाम ^ हूं।)
-    विधि get_last_name = last_name
-  अंत;;
-चलो अलोंजो = नया व्यक्ति अलोंजो चर्च इन (*नमस्कार, मैं अलोंजो चर्च हूं।*)
-print_endline alonzo#get_last_name (*चर्च*)
-</वाक्यविन्यास हाइलाइट>
 === [[पीएचपी]] ===
-PHP संस्करण 5 और इसके बाद के संस्करण में, कंस्ट्रक्टर नाम की एक विधि है <code>__construct()</code> (ध्यान दें कि यह एक डबल अंडरस्कोर है), जो कि कीवर्ड है <code>new</code> ऑब्जेक्ट बनाने के बाद स्वचालित रूप से कॉल करता है। यह आमतौर पर संपत्ति आरंभीकरण जैसे आरंभीकरण को स्वचालित रूप से करने के लिए उपयोग किया जाता है। कंस्ट्रक्टर तर्कों को भी स्वीकार कर सकते हैं, इस मामले में, जब <code>new</code> बयान लिखा गया है, आपको पैरामीटर के लिए कन्स्ट्रक्टर तर्क भी भेजने की जरूरत है।<ref name="php5cpnstructor"/>
+[[पीएचपी]] संस्करण 5 और इसके बाद के संस्करण में, कंस्ट्रक्टर <code>__construct()</code>  नाम की एक विधि है (ध्यान दें कि यह एक डबल अंडरस्कोर है), जिसे <code>new</code>  सूचक शब्द ऑब्जेक्ट बनाने के पश्चात् स्वतः कॉल करता है। सामान्यतः इसका उपयोग विशेषताओं के आरंभीकरण जैसे आरंभीकरण को स्वतः निष्पादित करने के लिए किया जाता है। कंस्ट्रक्टर तर्कों को भी स्वीकार कर सकते हैं ऐसे में जब <code>new</code> व्याख्यान लिखा जाता है तो आपको पैरामीटर्स के लिए कंस्ट्रक्टर तर्क भेजने की भी आवश्यकता होती है।<ref name="php5cpnstructor"/>
+     class Person
-<वाक्यविन्यास लैंग = php>
+ {
-वर्ग व्यक्ति
+     private string $name;
-{
-    निजी स्ट्रिंग $ नाम;
+     public function __construct(string $name): void
+     {
-    सार्वजनिक कार्य __ निर्माण (स्ट्रिंग $ नाम): शून्य
+         $this->name = $name;
-    {
+     }
-        $ यह-> नाम = $ नाम;
-    }
+     public function getName(): string
+     {
-    सार्वजनिक समारोह getName (): स्ट्रिंग
+         return $this->name;
-    {
+     }
-        वापसी $ यह-> नाम;
+  }
-    }
+पीएचपी में एक क्लास को केवल अधिकतम एक कन्स्ट्रक्टर विधि घोषित करने की अनुमति है। स्टैटिक मेथड्स फैक्ट्री क्लासेस या वैकल्पिक कंस्ट्रक्टर तर्क पीएचपी क्लास के ऑब्जेक्ट बनाने के कई तरीकों को सुविधाजनक बनाने के कुछ तरीके हैं।
-}
-</वाक्यविन्यास हाइलाइट>
-PHP में, एक वर्ग को केवल अधिकतम एक कन्स्ट्रक्टर विधि घोषित करने की अनुमति है। स्टैटिक मेथड्स, फैक्ट्री क्लासेस या ऑप्शनल कंस्ट्रक्टर आर्ग्युमेंट्स PHP क्लास के ऑब्जेक्ट्स बनाने के कई तरीकों को सुविधाजनक बनाने के कुछ तरीके हैं।
 === पर्ल 5 ===
-पर्ल संस्करण 5 में, डिफ़ॉल्ट रूप से, कंस्ट्रक्टर फ़ैक्टरी विधियाँ हैं, अर्थात्, वे विधियाँ जो ऑब्जेक्ट बनाती हैं और वापस करती हैं, जिसका अर्थ है एक धन्य संदर्भ बनाना और वापस करना। एक विशिष्ट वस्तु एक हैश का संदर्भ है, हालांकि शायद ही कभी अन्य प्रकार के संदर्भों का भी उपयोग किया जाता है। परंपरा के अनुसार केवल निर्माता को नया नाम दिया गया है, हालांकि इसे अन्यथा नाम देने की अनुमति है, या कई निर्माता हैं। उदाहरण के लिए, एक व्यक्ति वर्ग में नया नाम का एक कन्स्ट्रक्टर हो सकता है और साथ ही एक कन्स्ट्रक्टर new_from_file जो व्यक्ति विशेषताओं के लिए एक फ़ाइल पढ़ता है, और new_from_person जो टेम्पलेट के रूप में किसी अन्य व्यक्ति ऑब्जेक्ट का उपयोग करता है।
+पर्ल प्रोग्रामिंग भाषा संस्करण 5 में डिफॉल्ट रूप से कंस्ट्रक्टर फैक्ट्री मेथड्स हैं जो ऑब्जेक्ट बनाते और वापस करते हैं जिसका अर्थ है श्रेष्ठ संदर्भ बनाना और वापस करना।  विशिष्ट ऑब्जेक्ट हैश का संदर्भ होता है जबकि अन्य प्रकार के संदर्भों का भी उपयोग कदाचित कभी किया जाता हो। परंपरा के अनुसार केवल निर्माता नया नाम दे सकता है जबकि इसे नाम देने की अनुमति है अन्यथा कई निर्माता हों। उदाहरण के लिए एक व्यक्ति क्लास में नया नाम का एक कन्स्ट्रक्टर हो सकता है और साथ ही एक कन्स्ट्रक्टर new_from_file हो सकता है जो व्यक्ति विशेषताओं के लिए एक फ़ाइल पढ़ता है और new_from_person जो टेम्पलेट के रूप में किसी अन्य व्यक्ति ऑब्जेक्ट का उपयोग करता है।
+ package Person;
-<वाक्यविन्यास प्रकाश लैंग = पर्ल>
+ # In Perl constructors are named 'new' by convention.
-पैकेज व्यक्ति;
+ sub new {
-# पर्ल में कंस्ट्रक्टर्स को कन्वेंशन द्वारा 'नया' नाम दिया जाता है।
+     # Class name is implicitly passed in as 0th argument.
-उप नया {
+     my $class = shift;
-    # वर्ग का नाम निहित रूप से 0वें तर्क के रूप में पारित किया गया है।
-    मेरी $ क्लास = शिफ्ट;
+     # 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";
-    अगर ( परिभाषित नहीं $self->{first_name} ) {
+     }
-        व्यक्ति-> नया () में अनिवार्य विशेषता गायब हो जाती है: first_name;
+     if ( not defined $self->{last_name} ) {
-    }
+         die "Mandatory attribute missing in Person->new(): last_name";
-    अगर ( परिभाषित नहीं $self->{last_name} ) {
+     }
-        व्यक्ति-> नया () में अनिवार्य विशेषता गायब हो जाती है: last_name;
+     if ( defined $self->{age} and $self->{age} < 18 ) {
-    }
+         die "Invalid attribute value in Person->new(): age < 18";
-    अगर ( परिभाषित $self->{आयु} और $self->{आयु} <18) {
+     }
-        व्यक्ति में अमान्य विशेषता मान-> नया (): आयु <18;
-    }
+     # Perl makes an object belong to a class by 'bless'.
+     bless $self, $class;
-    # पर्ल किसी वस्तु को 'आशीर्वाद' द्वारा एक वर्ग से संबंधित बनाता है।
+     return $self;
-    $ स्वयं को आशीर्वाद दें, $ वर्ग;
+ }
-    $ स्वयं लौटें;
+;
-}
-;
-</वाक्यविन्यास हाइलाइट>
 ==== मूस के साथ पर्ल 5 ====
-पर्ल के लिए मूस पर्ल के साथ, इस बॉयलरप्लेट में से अधिकांश को छोड़ा जा सकता है, एक डिफ़ॉल्ट नया बनाया जाता है, विशेषताओं को निर्दिष्ट किया जा सकता है, साथ ही साथ उन्हें सेट किया जा सकता है, रीसेट किया जा सकता है या आवश्यक है। इसके अलावा, किसी भी अतिरिक्त कंस्ट्रक्टर कार्यक्षमता को BUILD विधि में शामिल किया जा सकता है, जिसे मूस जनरेटेड कंस्ट्रक्टर तर्कों की जाँच करने के बाद कॉल करेगा। एक BUILDARGS विधि को कन्स्ट्रक्टर तर्कों को संभालने के लिए निर्दिष्ट किया जा सकता है जो हैशफ/कुंजी => मान फॉर्म में नहीं है।
+पर्ल के लिए मूस ऑब्जेक्ट प्रणाली के साथ बॉयलरप्लेट में से अधिकांश को छोड़ा जा सकता है एवं डिफ़ॉल्ट नया बनाया जाता है और विशेषताओं को निर्दिष्ट किया जा सकता है साथ ही साथ उन्हें व्यवस्थित किया जा सकता है या आवश्यक होने पर पुनर्व्यवस्थित किया जा सकता है। इसके अलावा किसी भी अतिरिक्त कंस्ट्रक्टर कार्यक्षमता को एक ''BUILD'' विधि में सम्मिलित किया जा सकता है जिसे मूस जनरेटेड कंस्ट्रक्टर तर्कों की जाँच करने के बाद कॉल करेगा। एक ''BUILDARGS'' विधि को कन्स्ट्रक्टर तर्कों को नियन्त्रित करने के लिए निर्दिष्ट किया जा सकता है जो हैशरेफ/की => मान रूप में नहीं है।
+  package Person;
-<वाक्यविन्यास प्रकाश लैंग = पर्ल>
+ # enable Moose-style object construction
-पैकेज व्यक्ति;
+ use Moose;
-# मूस-शैली वस्तु निर्माण को सक्षम करें
-मूस का प्रयोग करें;
+ # first name ( a string) can only be set at construction time ('ro')
+ has first_name => (is => 'ro', isa => 'Str', required => 1);
-# पहला नाम (एक स्ट्रिंग) केवल निर्माण के समय सेट किया जा सकता है ('आरओ')
+ # last name ( a string) can only be set at construction time ('ro')
-has first_name => (is => 'ro', isa => 'Str',आवश्यक => 1);
+ has last_name  => (is => 'ro', isa => 'Str', required => 1);
-# अंतिम नाम (एक स्ट्रिंग) केवल निर्माण के समय सेट किया जा सकता है ('आरओ')
+ # age (Integer) can be modified after construction ('rw'), and is not required
-has last_name => (is => 'ro', isa => 'Str', needed => 1);
+ # to be passed to be constructor.  Also creates a 'has_age' method which returns
-# आयु (पूर्णांक) को निर्माण ('rw') के बाद संशोधित किया जा सकता है, और इसकी आवश्यकता नहीं है
+ # true if age has been set
-# कंस्ट्रक्टर बनने के लिए पास होना है। एक 'has_age' विधि भी बनाता है जो वापस आती है
+ has age        => (is => 'rw', isa => 'Int', predicate => 'has_age');
-# सच है अगर उम्र निर्धारित की गई है
-उम्र है => (is => 'rw', isa => 'Int', विधेय => 'has_age');
+ # Check custom requirements
+ sub BUILD {
-# कस्टम आवश्यकताओं की जाँच करें
+       my $self = shift;
-उप निर्माण {
+       if ($self->has_age && $self->age < 18) { # no under 18s
-      मेरा $ स्व = शिफ्ट;
+            die "No under-18 Persons";
-      if ($self->has_age && $self->आयु <18) { # 18 वर्ष से कम नहीं
+       }
-           डाई नो अंडर-18 पर्सन;
+ }
-      }
-}
+;
-;
+दोनों ही स्थितियों में व्यक्ति (पर्सन) क्लास इस तरह प्रारंभ होता है:
-</वाक्यविन्यास हाइलाइट>
+ use Person;
+ my $p = Person->new( first_name => 'Sam', last_name => 'Ashe', age => 42 );
-दोनों ही मामलों में व्यक्ति वर्ग इस तरह शुरू होता है:
-<वाक्यविन्यास प्रकाश लैंग = पर्ल>
-व्यक्ति का उपयोग करें;
-मेरा $ पी = व्यक्ति-> नया (पहला_नाम => 'सैम', अंतिम_नाम => 'ऐश', उम्र => 42);
-</वाक्यविन्यास हाइलाइट>
 === पायथन ===
-पायथन (प्रोग्रामिंग लैंग्वेज) में, कंस्ट्रक्टर्स को एक या दोनों द्वारा परिभाषित किया जाता है <code>__new__</code> और <code>__init__</code> तरीके। क्लास को कॉल करके एक नया उदाहरण बनाया जाता है जैसे कि यह एक फ़ंक्शन था, जो कॉल करता है <code>__new__</code> और <code>__init__</code> तरीके। यदि कक्षा में एक कन्स्ट्रक्टर विधि परिभाषित नहीं की गई है, तो कक्षा के सी 3 रैखिकरण में पाए जाने वाले अगले को बुलाया जाएगा।<ref>[https://docs.python.org/3/reference/datamodel.html Data model]</ref>
+पायथन (प्रोग्रामिंग लैंग्वेज) में, कंस्ट्रक्टर्स को एक या दोनों  <code>__new__</code> और <code>__init__</code>  विधियों द्वारा परिभाषित किया किया गया है। क्लास को कॉल करके एक नया उदाहरण बनाया जाता है जैसे कि यह एक फ़ंक्शन था, जो  <code>__new__</code> और <code>__init__</code>  विधियों को कॉल करता है। यदि किसी कंस्ट्रक्टर विधि को क्लास में परिभाषित नहीं किया गया है, तो क्लास के मेथड रेज़ोल्यूशन ऑर्डर में पाए जाने वाली अगली विधि को कॉल किया जाएगा।<ref>[https://docs.python.org/3/reference/datamodel.html Data model]</ref>
-विशिष्ट मामले में, केवल <code>__init__</code> विधि को परिभाषित करने की आवश्यकता है। (सबसे आम अपवाद अपरिवर्तनीय वस्तुओं के लिए है।)
-<वाक्यविन्यास लैंग = पिकॉन>
+विशिष्ट मामले में, केवल <code>__init__</code> विधि को परिभाषित करने की आवश्यकता है। (अत्यन्त सामान्य अपवाद अपरिवर्तनीय ऑब्जेक्ट के लिए है।)
->>> वर्ग उदाहरण वर्ग:
-... def __new__(cls, value):
-... प्रिंट (नया उदाहरण बना रहा है...)
-... # उदाहरण बनाने के लिए सुपरक्लास कंस्ट्रक्टर को कॉल करें।
-... उदाहरण = सुपर (उदाहरण क्लास, cls).__new__(cls)
-... वापसी का उदाहरण
-... def __init__(self, value):
-... प्रिंट (प्रारंभिक उदाहरण... )
-... स्व.पेलोड = मूल्य
->>> उदाहरण इंस्टेंस = उदाहरण क्लास (42)
-नया उदाहरण बनाया जा रहा है...
-इंस्टेंस प्रारंभ किया जा रहा है...
->>> प्रिंट (exampleInstance.payload)
-</वाक्यविन्यास हाइलाइट>
-कक्षाएं सामान्य रूप से स्वयं के नए उदाहरणों के लिए फ़ैक्टरी (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग) के रूप में कार्य करती हैं, अर्थात, एक क्लास एक कॉल करने योग्य ऑब्जेक्ट (एक फ़ंक्शन की तरह) है, जिसमें कॉल कंस्ट्रक्टर है, और क्लास को कॉल करना उस क्लास का एक उदाहरण देता है। हालांकि <code>__new__</code> विधि को विशेष उद्देश्यों के लिए कक्षा के उदाहरण के अलावा कुछ और वापस करने की अनुमति है। उस मामले में, <code>__init__</code> आह्वान नहीं किया जाता है।<ref>[https://docs.python.org/3/reference/datamodel.html#object.__new__ Data model]</ref>
+ >>> 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)
+सामान्यतः क्लास पर स्वयं के नए उदाहरणों के लिए कारखानों के रूप में कार्य करती हैं, अर्थात, एक वर्ग एक कॉल करने योग्य वस्तु (एक फ़ंक्शन की तरह) है, जिसमें कॉल एक कन्स्ट्रक्टर के रूप में कार्य करता है और कॉल करने से उस वर्ग का एक उदाहरण मिलता है। हालांकि <code>__new__</code> विधि को विशेष उद्देश्यों के लिए कक्षा के उदाहरण के अतिरिक्त कुछ और परावर्तन करने की अनुमति है। उस स्थिति में <code>__init__</code> आह्वान नहीं किया जाता है।<ref>[https://docs.python.org/3/reference/datamodel.html#object.__new__ Data model]</ref>
 === राकू ===
-[[राकू (प्रोग्रामिंग भाषा)]] के साथ, और भी बॉयलरप्लेट को छोड़ा जा सकता है, यह देखते हुए कि एक डिफ़ॉल्ट नई विधि विरासत में मिली है, विशेषताओं को निर्दिष्ट किया जा सकता है, साथ ही साथ उन्हें सेट किया जा सकता है, रीसेट किया जा सकता है या आवश्यक है। इसके अतिरिक्त, किसी भी अतिरिक्त कन्स्ट्रक्टर कार्यक्षमता को BUILD विधि में शामिल किया जा सकता है जिसे कस्टम प्रारंभिकरण की अनुमति देने के लिए बुलाया जाएगा। पहले से ही (अंतर्निहित) प्रारंभ की गई किसी भी विशेषता को पोस्ट-प्रोसेस करने के लिए एक TWEAK विधि निर्दिष्ट की जा सकती है।
+[[राकू (प्रोग्रामिंग भाषा)]] के साथ, और भी बॉयलरप्लेट को यह देखते हुए छोड़ा जा सकता है कि डिफ़ॉल्ट नई पद्धति विरासत में मिली है एवं विशेषताओं को निर्दिष्ट किया जा सकता है साथ ही क्या उन्हें व्यवस्थित भी किया जा सकता है या आवश्यक है तो पुनर्व्यवस्थित किया जा सकता है। इसके अलावा किसी भी अतिरिक्त कन्स्ट्रक्टर कार्यक्षमता को ''BUILD'' विधि में सम्मिलित किया जा सकता है जिसे कस्टम प्रारंभिकरण की अनुमति देने के लिए बुलाया जाएगा। पहले से ही (अंतर्निहित) प्रारंभ की गई किसी भी विशेषता को पश्च संसाधित्र करने के लिए एक टीडब्ल्यूईएके विधि निर्दिष्ट की जा सकती है।
+ class Person {
-<वाक्यविन्यास प्रकाश लैंग = perl6>
+     has Str $.first-name is required; # First name (a string) can only be set at
-वर्ग व्यक्ति {
+                                       # construction time (the . means "public").
-    है Str $.first-name आवश्यक है; # पहला नाम (एक स्ट्रिंग) केवल पर सेट किया जा सकता है
+     has Str $.last-name is required;  # Last name (a string) can only be set at
-                                      # निर्माण समय (. का अर्थ है सार्वजनिक)।
+                                       # construction time (a ! would mean "private").
-    है Str $.last-name आवश्यक है; # अंतिम नाम (एक स्ट्रिंग) केवल पर सेट किया जा सकता है
+     has Int $.age is rw;              # Age (an integer) can be modified after
-                                      # निर्माण समय (ए ! का मतलब निजी होगा)।
+                                       # construction ('rw'), and is not required
-    है int $.आयु rw है; # आयु (एक पूर्णांक) के बाद संशोधित किया जा सकता है
+                                       # 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 }
-    # इस विधि को कक्षा के बाहर पहुँचा जा सकता है।
-    विधि का पूरा नाम { $!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 }
-    # इसके नाम के आगे एक !
-    विधि !है-उम्र {self.age.defined}
+     # Check custom requirements
+     method TWEAK {
-    # कस्टम आवश्यकताओं की जाँच करें
+         if self!has-age && $!age < 18 { # No under 18
-    विधि ट्वीक {
+             die "No person under 18";
-        अगर स्वयं!है-उम्र && $!उम्र <18 { # 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 में बृहदान्त्र-जोड़ी वाक्यविन्यास का उपयोग करके निर्दिष्ट किया जा सकता है:
-<वाक्यविन्यास प्रकाश लैंग = perl6>
+ my $p0 = Person.new( :first-name<Sam>, :last-name<Ashe>, :age(42) );
-मेरा $p0 = व्यक्ति.नया (पहला-नाम => 'सैम', अंतिम-नाम => 'ऐश', उम्र => 42);
+ my $p1 = Person.new( :first-name<Grace>, :last-name<Hopper> );
-मेरा $p1 = व्यक्ति.नया (प्रथम-नाम => 'अनुग्रह', अंतिम-नाम => 'कूदनेवाला');
+और क्या आपको नामित पैरामीटर के समान नामों के साथ चर स्थापित करना चाहिए, आप शॉर्टकट का उपयोग कर सकते हैं जो नामित पैरामीटर के लिए चर के नाम का उपयोग करेगा:
-कहना $p1.full-name(); # आउटपुट: «ग्रेस हूपर␤»
+ my $first-name = "Sam";
-</वाक्यविन्यास हाइलाइट>
+ my $last-name  = "Ashe";
+ my $age        = 42;
-वैकल्पिक रूप से, [[नामित पैरामीटर]] पर्ल 6 में कोलन-जोड़ी सिंटैक्स का उपयोग करके निर्दिष्ट किए जा सकते हैं:
+ my $p0 = Person.new( :$first-name, :$last-name, :$age );
-<वाक्यविन्यास प्रकाश लैंग = 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 );
-</वाक्यविन्यास हाइलाइट>
 === रूबी ===
+[[रूबी (प्रोग्रामिंग भाषा)]] में, कंस्ट्रक्टर्स <code>initialize</code> नामक एक विधि को परिभाषित करके बनाए जाते हैं। प्रत्येक नए उदाहरण को आरंभ करने के लिए इस विधि को निष्पादित किया जाता है।
+ 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
+ => #<ExampleClass:0x007fb3f4299118>
-[[रूबी (प्रोग्रामिंग भाषा)]] में, कंस्ट्रक्टर्स नामक एक विधि को परिभाषित करके बनाया जाता है <code>initialize</code>. प्रत्येक नए उदाहरण को आरंभ करने के लिए इस विधि को निष्पादित किया जाता है।
+=== विजुअल बेसिक .नेट ===
-<वाक्यविन्यास प्रकाश लैंग = आरबीकॉन>
-irb(main):001:0> क्लास exampleClass
-irb(main):002:1> डीईएफ़ इनिशियलाइज़ करें
-irb(main):003:2> वहां हैलो डालता है
-आईआरबी (मुख्य): 004: 2> अंत
-आईआरबी (मुख्य): 005: 1> अंत
-=> शून्य
-आईआरबी (मुख्य): 006: 0> उदाहरण क्लास.न्यू
-नमस्ते
-=> #<ExampleClass:0x007fb3f4299118>
-</वाक्यविन्यास हाइलाइट>
-=== विजुअल बेसिक .NET ===
+विजुअल बेसिक में .नेट कंस्ट्रक्टर "<code>New</code>" नाम के साथ एक विधि डिक्लेरेशन का उपयोग करते हैं।
+ Class Foobar
+    Private strData As String
+ ' Constructor
+   Public Sub New(ByVal someParam As String)
+   strData = someParam
+       End Sub
+    End Class
-Visual Basic .NET में, निर्माता नाम के साथ विधि घोषणा का उपयोग करते हैं<code>New</code>.
+ ' code somewhere else
+ ' instantiating an object with the above constructor
-<वाक्यविन्यास लैंग = vbnet>
+ Dim foo As New Foobar(".NET")
-वर्ग फूबर
-    निजी strData स्ट्रिंग के रूप में
-    'निर्माता
-    सार्वजनिक उप नया (ByVal someParam As String)
-        strData = someParam
-    अंत उप
-अंत वर्ग
-</वाक्यविन्यास हाइलाइट>
-<वाक्यविन्यास लैंग = vbnet>
-'कोड कहीं और
-' उपरोक्त कन्स्ट्रक्टर के साथ किसी ऑब्जेक्ट को तुरंत चालू करना
-न्यू फूबार के रूप में डिम फू (.NET)
-</वाक्यविन्यास हाइलाइट>
 == यह भी देखें ==
-* संसाधन_अधिग्रहण_प्रारंभिकीकरण है
+* आरएएआई
 * [[आवंटन स्थल]]
-* [[रचनात्मक पैटर्न]]
+* [[रचनात्मक पैटर्न|रचनात्मक प्रतिरुप]]
-* [[विध्वंसक (कंप्यूटर विज्ञान)]]
+* [[विध्वंसक (कंप्यूटर विज्ञान)|डिस्ट्रक्टर (कंप्यूटर विज्ञान)]]
-* C++ में ग्लोबल [[((निर्माता))]], और इसका C समकक्ष, ((कंस्ट्रक्टर)) फ़ंक्शन विशेषता
+* सी ++ में  [[((निर्माता))|ग्लोबल कंस्ट्रक्टर]] और C समकक्ष, ((कंस्ट्रक्टर)) फ़ंक्शन विशेषता
 == टिप्पणियाँ ==
@@ Line 677: / Line 571: @@
 == संदर्भ ==
 {{Reflist|30em}}
-[[Category: विधि (कंप्यूटर प्रोग्रामिंग)]] [[Category: प्रोग्रामिंग भाषा तुलना]]
-[[Category: Machine Translated Page]]
+[[Category:Articles with hatnote templates targeting a nonexistent page]]
 [[Category:Created On 17/02/2023]]
+[[Category:Lua-based templates]]
+[[Category:Machine Translated Page]]
+[[Category:Pages with script errors]]
+[[Category:Templates Vigyan Ready]]
+[[Category:Templates that add a tracking category]]
+[[Category:Templates that generate short descriptions]]
+[[Category:Templates using TemplateData]]
+[[Category:प्रोग्रामिंग भाषा तुलना]]
+[[Category:विधि (कंप्यूटर प्रोग्रामिंग)]]

Anonymous

Search