C++
नकल बनाम असाइनमेंट

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

• कापी कंस्ट्रक्टर
• MyClass (const MyClass & other);
• MyClass (MyClass & अन्य);
• MyClass (वाष्पशील कास्ट MyClass & अन्य);
• MyClass (वाष्पशील MyClass और अन्य);
• असाइनमेंट कंस्ट्रक्टर
• MyClass और ऑपरेटर = (const MyClass & rhs);
• MyClass और ऑपरेटर = (MyClass & rhs);
• MyClass और ऑपरेटर = (MyClass rhs);
• const MyClass & ऑपरेटर = (const MyClass & rhs);
• const MyClass & ऑपरेटर = (MyClass & rhs);
• const MyClass & ऑपरेटर = (MyClass rhs);
• MyClass ऑपरेटर = (const MyClass & rhs);
• MyClass ऑपरेटर = (MyClass & rhs);
• MyClass ऑपरेटर = (MyClass rhs);

पैरामीटर

टिप्पणियों

असाइनमेंट ऑपरेटर

असाइनमेंट ऑपरेटर तब होता है जब आप डेटा को पहले से मौजूद (पहले आरंभीकृत) ऑब्जेक्ट के साथ किसी अन्य ऑब्जेक्ट के डेटा से बदल देते हैं। इसे एक उदाहरण के रूप में लेते हैं:

// Assignment Operator
#include <iostream>
#include <string>

using std::cout;
using std::endl;

class Foo
{
  public:
    Foo(int data)
    {
        this->data = data;    
    }
    ~Foo(){};
    Foo& operator=(const Foo& rhs)
    {
            data = rhs.data; 
            return *this;
    }

    int data;
};

int main()
{
   Foo foo(2); //Foo(int data) called
   Foo foo2(42);
   foo = foo2; // Assignment Operator Called
   cout << foo.data << endl; //Prints 42
}

आप देख सकते हैं कि मैं असाइनमेंट ऑपरेटर को कॉल करता हूं जब मैंने पहले से ही foo ऑब्जेक्ट इनिशियलाइज़ किया था। फिर बाद में मैं foo को foo2 असाइन करता हूं। जब आप कहते हैं कि समान साइन ऑपरेटर को आपके operator= फ़ंक्शन में परिभाषित किया गया है, तो प्रकट होने वाले सभी परिवर्तन। आप यहां रन करने योग्य आउटपुट देख सकते हैं: http://cpp.sh/3qtbm

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

दूसरी ओर कॉपी कंस्ट्रक्टर, असाइनमेंट कंस्ट्रक्टर के पूर्ण विपरीत है। इस बार, इसका उपयोग पहले से मौजूद कोई नहीं (या गैर-पहले आरंभीकृत) ऑब्जेक्ट को इनिशियलाइज़ करने के लिए किया जाता है। इसका मतलब है कि यह उस ऑब्जेक्ट के सभी डेटा को कॉपी करता है जिसे आप इसे असाइन कर रहे हैं, वास्तव में उस ऑब्जेक्ट को इनिशियलाइज़ किए बिना जिसे कॉपी किया जा रहा है। अब पहले के समान कोड पर एक नज़र डालते हैं लेकिन असाइनमेंट कंस्ट्रक्टर को कॉपी कंस्ट्रक्टर बनने के लिए संशोधित करते हैं:

// Copy Constructor
#include <iostream>
#include <string>

using std::cout;
using std::endl;

class Foo
{
  public:
    Foo(int data)
    {
        this->data = data;    
    }
    ~Foo(){};
    Foo(const Foo& rhs)
    {
            data = rhs.data; 
    }

    int data;
};

int main()
{
   Foo foo(2); //Foo(int data) called
   Foo foo2 = foo; // Copy Constructor called
   cout << foo2.data << endl;
}

आप यहाँ देख सकते हैं Foo foo2 = foo; मुख्य समारोह में मैं वास्तव में इसे वास्तव में प्रारंभिक करने से पहले ऑब्जेक्ट असाइन करता हूं, जैसा कि पहले कहा गया था कि यह एक कॉपी कंस्ट्रक्टर है। और ध्यान दें कि मुझे foo2 ऑब्जेक्ट के लिए पैरामीटर int पास करने की आवश्यकता नहीं थी क्योंकि मैंने स्वचालित रूप से ऑब्जेक्ट फू से पिछले डेटा को खींच लिया था। यहाँ एक उदाहरण आउटपुट है: http://cpp.sh/5iu7

कॉपी कंस्ट्रक्टर बनाम असाइनमेंट कंस्ट्रक्टर

ठीक है, हमने संक्षेप में इस बात पर ध्यान दिया है कि कॉपी कंस्ट्रक्टर और असाइनमेंट कंस्ट्रक्टर ऊपर हैं और प्रत्येक के उदाहरण दिए हैं चलो अब दोनों को एक ही कोड में देखते हैं। यह कोड दो से ऊपर के समान होगा। आइए इसे लेते हैं:

// Copy vs Assignment Constructor
#include <iostream>
#include <string>

using std::cout;
using std::endl;

class Foo
{
  public:
    Foo(int data)
    {
        this->data = data;    
    }
    ~Foo(){};
    Foo(const Foo& rhs)
    {
            data = rhs.data; 
    }

    Foo& operator=(const Foo& rhs)
    {
        data = rhs.data; 
        return *this;
    }

    int data;
};

int main()
{
   Foo foo(2); //Foo(int data) / Normal Constructor called
   Foo foo2 = foo; //Copy Constructor Called
   cout << foo2.data << endl;

   Foo foo3(42);
   foo3=foo; //Assignment Constructor Called
   cout << foo3.data << endl;
}

आउटपुट:

2
2

यहाँ आप देख सकते हैं कि हम पहली बार कॉपी निर्माता को Foo foo2 = foo; लाइन निष्पादित करके कॉल करते हैं Foo foo2 = foo; । चूंकि हमने इसे पहले शुरू नहीं किया था। और फिर अगला हम foo3 पर असाइनमेंट ऑपरेटर को कॉल करते हैं क्योंकि यह पहले से ही foo3=foo इनिशियलाइज़ हो गया था;