कॉपी प्रारंभिकरण की तरह क्यों है? कॉपी कन्स्ट्रक्टर की आवश्यकता क्यों है?

Question

संभव डुप्लिकेट:
What’s the motivation behind having copy and direct initialization behave differently?

और प्रतिलिपि प्रारंभ से, मैं इतना की तरह मतलब है:

struct MyStruct 
{ 
    MyStruct(int) {} 
    MyStruct(const MyStruct&) {} 
}; 

MyStruct s = 5; // needs *both* the int and copy constructor 

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

गुडलिंग की एक सभ्य राशि के बाद, मुझे यह पता चलता है कि यह कैसे काम करता है। मेरा प्रश्न है क्यों यह वही तरीका है?

मानक क्यों नहीं बनाया गया है कि उपर्युक्त उदाहरण को कॉपी कन्स्ट्रक्टर की आवश्यकता नहीं है? क्या कोई विशिष्ट मामला/उदाहरण है जो दिखाता है कि इस प्रकार के प्रारंभिकरण में कॉपी कन्स्ट्रक्टर की आवश्यकता महत्वपूर्ण है?

की एक सभ्य विवरण के बिना क्यों बातें मैं सिर्फ एक कष्टप्रद विरूपण साक्ष्य के रूप में देखते वे जिस तरह से वे कर रहे हैं कर रहे हैं, लेकिन वहाँ कुछ महत्वपूर्ण है कि मैं याद कर रहा हूँ कि अगर मैं नहीं बल्कि नहीं अज्ञानी होगा।

Answer 1

किसी ऑब्जेक्ट की प्रारंभिक प्रतिलिपि प्रारंभिक प्रारंभ करने के लिए संदिग्ध है, दोनों एक दूसरे के बराबर मान सेट करने के लिए उसी हद तक उपयोग किए जा सकते हैं।

int a = 4; 
int a = int(4); 
int a(4); 

इन कॉल के सभी अस्पष्ट हैं, वे सब 4. करने के लिए एक समान सेट एक पूर्णांक के मामले में एक प्रति निर्माता के लिए कारण सुविधा है, इस

int a(foo(b,r)); //a little messy for a variable declaration 
int a = foo(b,r) //ok, cleaner 

बिना C++ डेटा प्रकार की कल्पना आप भी हो सकता है एक अंतर्निहित और स्पष्ट प्रतिलिपि निर्माता का उपयोग करने के हो सकता है, यहां एक उदाहरण कार्यक्रम स्पष्ट रूप से एक प्रतिलिपि निर्माता का उपयोग करता है काल्पनिक संख्याओं को संभालने के लिए है:

#include <iostream> 
using std::cout; 
using std::endl; 
class complexNumbers { 
    double real, img; 
public: 
    complexNumbers() : real(0), img(0) { } 
    complexNumbers(const complexNumbers& c) { real = c.real; img = c.img; } 
    explicit complexNumbers(double r, double i = 0.0) { real = r; img = i; } 
    friend void display(complexNumbers cx); 
}; 
void display(complexNumbers cx){ 
    cout<<&quot;Real Part: &quot;<<cx.real<<&quot; Imag Part: &quot;<<cx.img<<endl; 
} 
int main() { 
    complexNumbers one(1); 
    display(one); 
    complexNumbers two =2; 
    display(200); 
    return 0; 
}