c++ - सी++ में संरचना और कक्षा के बीच अंतर क्या हैं?




oop class (19)

यह सवाल पहले ही सी # / नेट के संदर्भ में पूछा गया था।

अब मैं सी ++ में एक संरचना और कक्षा के बीच अंतर सीखना चाहता हूं। तकनीकी मतभेदों के साथ-साथ ओओ डिज़ाइन में एक या दूसरे को चुनने के कारणों पर चर्चा करें।

मैं एक स्पष्ट अंतर से शुरू करूंगा:

  • यदि आप public: निर्दिष्ट नहीं करते हैं public: या private: संरचना के सदस्य डिफ़ॉल्ट रूप से सार्वजनिक होते हैं; कक्षा के सदस्य डिफ़ॉल्ट रूप से निजी होते हैं।

मुझे यकीन है कि सी ++ विनिर्देश के अस्पष्ट कोनों में अन्य अंतर पाए जाते हैं।


आईएसओ आईईसी 14882-2003

9 कक्षाएं

§3

एक संरचना कक्षा-कुंजी struct साथ परिभाषित एक वर्ग है; इसके सदस्य और आधार वर्ग (खंड 10) डिफ़ॉल्ट रूप से सार्वजनिक होते हैं (खंड 11)।


  1. संरचना के सदस्य डिफ़ॉल्ट रूप से सार्वजनिक होते हैं, कक्षा के सदस्य डिफ़ॉल्ट रूप से निजी होते हैं।
  2. किसी अन्य संरचना या वर्ग से संरचना के लिए डिफ़ॉल्ट विरासत सार्वजनिक है। किसी अन्य संरचना या कक्षा से वर्ग के लिए डीफॉल्ट विरासत निजी है।
class A{    
public:    
    int i;      
};

class A2:A{    
};

struct A3:A{    
};


struct abc{    
    int i;
};

struct abc2:abc{    
};

class abc3:abc{
};


int _tmain(int argc, _TCHAR* argv[])
{    
    abc2 objabc;
    objabc.i = 10;

    A3 ob;
    ob.i = 10;

    //A2 obja; //privately inherited
    //obja.i = 10;

    //abc3 obss;
    //obss.i = 10;
}

यह वीएस2005 पर है।


आप इस पर विचार कर सकते हैं कि संरचना या कक्षा के लिए कब जाना है, https://msdn.microsoft.com/en-us/library/ms229017%28v=vs.110%29.aspx पर दिशानिर्देशों के लिए।

√ कंसिडर एक वर्ग की जगह एक संरचना को परिभाषित करता है यदि प्रकार के उदाहरण छोटे होते हैं और आमतौर पर अल्पकालिक होते हैं या आमतौर पर अन्य वस्तुओं में एम्बेडेड होते हैं।

एक्स AVOID एक संरचना को परिभाषित करता है जब तक कि इस प्रकार में निम्नलिखित सभी विशेषताएं नहीं हैं:

यह तार्किक रूप से एक ही मूल्य का प्रतिनिधित्व करता है, जो प्राचीन प्रकारों (int, double, आदि) के समान होता है।

इसमें 16 बाइट्स के तहत एक उदाहरण आकार है।

यह अपरिवर्तनीय है।

इसे अक्सर बॉक्सिंग नहीं करना पड़ेगा।


आप कक्षाओं और structs के बीच मुश्किल दूसरा अंतर भूल जाते हैं।

मानक (§11.2.2 सी ++ 98 में सी ++ 11 के माध्यम से):

बेस क्लास के लिए एक्सेस- एडवाइडर की अनुपस्थिति में, जनता को तब माना जाता है जब व्युत्पन्न वर्ग को घोषित किया जाता है और जब वर्ग को कक्षा घोषित किया जाता है तो निजी माना जाता है।

और केवल पूर्णता के लिए, वर्ग और संरचना के बीच अधिक व्यापक रूप से ज्ञात अंतर परिभाषित किया गया है (11.2):

कीवर्ड वर्ग के साथ परिभाषित कक्षा के सदस्य डिफ़ॉल्ट रूप से निजी होते हैं। कीवर्ड स्ट्रक्चर या यूनियन के साथ परिभाषित कक्षा के सदस्य डिफ़ॉल्ट रूप से सार्वजनिक होते हैं।

अतिरिक्त अंतर: कीवर्ड class का उपयोग टेम्पलेट पैरामीटर घोषित करने के लिए किया जा सकता है, जबकि struct कीवर्ड का इतना उपयोग नहीं किया जा सकता है।


एक अन्य बात ध्यान देने योग्य है, यदि आपने एक विरासत ऐप अपडेट किया है जिसमें वर्गों का उपयोग करने के लिए structs थे, तो आप निम्न समस्या में भाग सकते हैं:

पुराने कोड में structs हैं, कोड साफ़ किया गया था और ये कक्षाओं में बदल गया। फिर एक वर्चुअल फ़ंक्शन या दो को नए अद्यतन वर्ग में जोड़ा गया था।

जब आभासी कार्य कक्षाओं में होते हैं तो आंतरिक रूप से संकलक कार्यों को इंगित करने के लिए कक्षा डेटा में अतिरिक्त सूचक जोड़ देगा।

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


एकमात्र अन्य अंतर कक्षाओं और structs की डिफ़ॉल्ट विरासत है, जो, अनिश्चित रूप से, निजी और सार्वजनिक क्रमशः है।


कक्षा सॉफ्टवेयर इंजीनियरिंग के संदर्भ में केवल सार्थक है। डेटा संरचनाओं और एल्गोरिदम के संदर्भ में, वर्ग और संरचना अलग नहीं हैं। किसी भी नियम को प्रतिबंधित नहीं किया गया है कि वर्ग के सदस्य को संदर्भित किया जाना चाहिए।

कक्षा के बिना बहुत से लोगों के साथ बड़ी परियोजना विकसित करते समय, आप अंततः जटिल युग्मित कोड प्राप्त कर सकते हैं क्योंकि हर कोई जो भी कार्य और डेटा चाहता है उसका उपयोग करता है। वर्ग कोड नियंत्रण और पुन: उपयोग कोड को बढ़ाने के लिए अनुमति नियंत्रण और अंतर्निहित प्रदान करता है।

यदि आप कुछ सॉफ्टवेयर इंजीनियरिंग सिद्धांतों को पढ़ते हैं, तो आप पाएंगे कि अधिकांश मानकों को कक्षा के बिना आसानी से लागू नहीं किया जा सकता है। उदाहरण के लिए: http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29

बीटीडब्लू, जब एक स्ट्रक्चर मेमोरी की एक क्रंच आवंटित करता है और इसमें कई चर शामिल होते हैं, तो वैल्यू टाइप वैरिएबल इंगित करता है कि स्ट्रक्चर आवंटित किए जाने पर मूल्यों को गले लगाया जाता है। इसके विपरीत, संदर्भ प्रकार चर के मान बाहरी होते हैं और एक सूचक द्वारा संदर्भित होते हैं जो संरचना को आवंटित करने में भी एम्बेडेड होता है।


कक्षाएं संदर्भ प्रकार हैं और संरचनाएं मूल्य प्रकार हैं।
जब मैं कहता हूं कि कक्षाएं संदर्भ प्रकार हैं,
मूल रूप से वे एक आवृत्ति चर का पता होगा।

उदाहरण के लिए:

Class MyClass
{
    Public Int DataMember;  //By default, accessibility of class data members 
                            //will be private. So I am making it as Public which 
                            //can be accessed outside of the class.
}

मुख्य विधि में,
मैं इस वर्ग के लिए नए ऑपरेटर का उपयोग कर इस वर्ग का एक उदाहरण बना सकता हूं जो इस वर्ग के लिए स्मृति आवंटित करता है
और उस के मूल पते को MyClass प्रकार चर (_myClassObject2) में संग्रहीत करता है।

Static Public void Main (string[] arg)
{
    MyClass _myClassObject1 = new MyClass();
    _myClassObject1.DataMember = 10;

    MyClass _myClassObject2 = _myClassObject1;
    _myClassObject2.DataMember=20;
}

उपरोक्त कार्यक्रम में, MyClass _myClassObject2 = _myClassObject1; निर्देश इंगित करता है कि MyClass टाइप करने के दोनों चर

  1. myClassObject1
  2. myClassObject2

और उसी स्मृति स्थान को इंगित करेगा।
यह मूल रूप से उसी स्मृति स्थान को उसी प्रकार के दूसरे चर में निर्दिष्ट करता है।

इसलिए यदि किसी भी वस्तु में हम किसी भी प्रकार के परिवर्तन करते हैं तो MyClass का दूसरा प्रभाव होगा
चूंकि दोनों एक ही स्मृति स्थान पर इशारा कर रहे हैं।

"_myClassObject1.डेटामेन = 10;" इस पंक्ति पर ऑब्जेक्ट के डेटा सदस्यों में 10 का मान होगा।
"_myClassObject2.डेटामेन = 20;" इस पंक्ति पर ऑब्जेक्ट के डेटा सदस्य दोनों में 20 का मान होगा।
आखिरकार, हम पॉइंटर्स के माध्यम से ऑब्जेक्ट के डाटामैम्बर एक्सेस कर रहे हैं।

कक्षाओं के विपरीत, संरचनाएं मूल्य प्रकार हैं। उदाहरण के लिए:

Structure MyStructure
{
    Public Int DataMember;  //By default, accessibility of Structure data 
                            //members will be private. So I am making it as 
                            //Public which can be accessed out side of the structure.
}

Static Public void Main (string[] arg)
{
    MyStructure _myStructObject1 = new MyStructure();
    _myStructObject1.DataMember = 10;

    MyStructure _myStructObject2 = _myStructObject1;
    _myStructObject2.DataMember = 20;
}

उपर्युक्त कार्यक्रम में,
नए ऑपरेटर का उपयोग करके MyStructure प्रकार की वस्तु को तुरंत चालू करना और
प्रकार MyStructure और _myStructObject चर में पता संग्रह
"_myStructObject1.DataMember = 10" का उपयोग करके संरचना के डेटा सदस्य को मान 10 असाइन करना।

अगली पंक्ति में,
मैं एक और वैरिएबल _myStructObject2 को MyStructure टाइप करने और उसमें _myStructObject1 असाइन करने की घोषणा कर रहा हूं।
यहां .NET C # कंपाइलर _myStructureObject1 ऑब्जेक्ट की एक और प्रति बनाता है और
उस मेमोरी लोकेशन को MyStructure variable _myStructObject2 में असाइन करता है।

तो _myStructObject1 पर जो भी बदलाव हम करते हैं, उसका कोई अन्य चर _myStructObject2 पर MyStructrue प्रकार का प्रभाव नहीं पड़ेगा।
यही कारण है कि हम कह रहे हैं संरचनाएं मूल्य प्रकार हैं।

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

हम यह कैसे कह रहे हैं?
और उसके पीछे क्या कारण है?
जवाब कक्षा है।

यह अमूर्त, मुहरबंद, स्थैतिक और आंशिक हो सकता है और यह निजी, संरक्षित और संरक्षित आंतरिक नहीं हो सकता है।


जबकि अन्य उत्तरों से निहित, यह स्पष्ट रूप से उल्लेख नहीं किया गया है - कि संरचनाएं सी के अनुकूल हैं, उपयोग के आधार पर; कक्षाएं नहीं हैं

इसका अर्थ यह है कि यदि आप एक हेडर लिख रहे हैं जिसे आप सी संगत बनाना चाहते हैं तो आपके पास स्ट्रक्चर के अलावा कोई विकल्प नहीं है (जिसमें सी दुनिया में फ़ंक्शन नहीं हो सकते हैं, लेकिन फ़ंक्शन पॉइंटर्स हो सकते हैं)।


टेम्पलेट्स की बात आती है जब एक और मुख्य अंतर है। जहां तक ​​मुझे पता है, आप एक वर्ग का उपयोग कर सकते हैं जब आप टेम्पलेट को परिभाषित करते हैं लेकिन संरचना नहीं।

template<class T> // OK
template<struct T> // ERROR, struct not allowed here

मैं डिफ़ॉल्ट प्रारंभिकरण के साथ करने वाले structs और कक्षाओं के बीच एक और अलग देख रहा हूं।

struct Foo {
    int a;
};

class Bar {
    int a;
};

class Tester {
    Foo m_Foo = Foo();
    Bar m_Bar = Bar();

public:
    Tester() {}
};

int main() {
    auto myTester = Tester();
}

उस कोड को चलाएं और myTester की जांच करें। आप पाएंगे कि m_Foo के लिए, संरचना, m_Foo.a को 0 से प्रारंभ किया गया है, लेकिन m_Bar के लिए, वर्ग, m_Bar.a अनियमित है। तो संरचना बनाम वर्ग के लिए डिफ़ॉल्ट कन्स्ट्रक्टर क्या करता है में एक अंतर दिखाई देता है। मैं इसे विजुअल स्टूडियो के साथ देख रहा हूं।


यह सिर्फ एक सम्मेलन है। सरल डेटा रखने के लिए संरचनाएं बनाई जा सकती हैं लेकिन बाद में सदस्य कार्यों और रचनाकारों के अतिरिक्त समय के साथ विकसित हो जाती हैं। दूसरी तरफ जनता के अलावा कुछ भी देखना असामान्य है: एक संरचना में पहुंच।


विनिर्देश में नहीं, नहीं। मुख्य अंतर प्रोग्रामर अपेक्षाओं में होता है जब वे 2 साल में अपना कोड पढ़ते हैं। structs अक्सर पीओडी माना जाता है। स्ट्रक्चर का उपयोग टेम्पलेट मेटाप्रोग्रामिंग में भी किया जाता है जब आप वस्तुओं को परिभाषित करने के अलावा अन्य उद्देश्यों के लिए एक प्रकार परिभाषित कर रहे हैं।


संरचना और वर्ग के बीच मुख्य अंतर यह है कि संरचना में आप केवल विभिन्न डेटा प्रकारों के डेटा चर घोषित कर सकते हैं जबकि कक्षा में आप डेटा चर, सदस्य कार्य घोषित कर सकते हैं और इस प्रकार आप कार्यों के माध्यम से डेटा चर का उपयोग कर सकते हैं।

-> कक्षा बनाम संरचना में मुझे एक और आसान चीज यह है कि एक प्रोग्राम में फाइलों को लागू करते समय यदि आप संचालन के हर नए सेट पर बार-बार संरचना के कुछ संचालन करना चाहते हैं तो आपको एक अलग कार्य करने की आवश्यकता है और आपको इसकी आवश्यकता है फ़ाइल से इसे पढ़ने के बाद संरचना के ऑब्जेक्ट को पास करें ताकि इस पर कुछ ऑपरेशन कर सकें। कक्षा में रहते हुए, यदि आप एक ऐसा फ़ंक्शन करते हैं जो हर समय आवश्यक डेटा पर कुछ संचालन करता है .. यह आसान है कि आपको फ़ाइल से ऑब्जेक्ट को पढ़ना होगा और फ़ंक्शन को कॉल करना होगा ..

लेकिन यह प्रोग्रामर पर निर्भर करता है जिस तरह से उसे उपयुक्त लगता है ... मेरे अनुसार मैं हर बार कक्षा पसंद करता हूं क्योंकि यह ओओपी का समर्थन करता है और यही कारण है कि इसे लगभग हर भाषाओं में लागू किया जाता है और यह सभी समय प्रोग्रामिंग की अद्भुत विशेषता है; - )

और हाँ सबसे अपरिचित अंतर मैं उल्लेख करना भूल गया कि वर्ग डेटा छिपाने का समर्थन करता है और संरचनाओं के दौरान डेटा प्रकारों में बनाए गए संचालन का भी समर्थन करता है!


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


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

कक्षाएं एक अलग प्रकार के अमूर्त डेटा प्रकार हैं जो सूचना छिपाने की कोशिश करने का प्रयास करती हैं। आंतरिक रूप से, विभिन्न प्रकार की मशीनें, विधियां, अस्थायी चर, राज्य चर हो सकते हैं। इत्यादि का उपयोग किसी भी कोड को एक सतत एपीआई प्रस्तुत करने के लिए किया जाता है जो कक्षा का उपयोग करना चाहता है।

असल में, structs डेटा के बारे में हैं, वर्ग कोड के बारे में हैं।

हालांकि, आपको यह समझने की आवश्यकता है कि ये केवल अमूर्त हैं। Structs बनाने के लिए यह पूरी तरह से संभव है जो वर्गों और वर्गों की तरह दिखते हैं जो structs की तरह दिखते हैं। वास्तव में, सबसे शुरुआती सी ++ कंपाइलर्स केवल पूर्व-कंपाइलर थे जो सी ++ कोड को सी में अनुवाद करते हैं। इस प्रकार ये अवशोषण तार्किक सोच का लाभ हैं, न कि कंप्यूटर के लिए आवश्यक रूप से एक संपत्ति।

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


सी ++ एफएक्यू का उद्धरण,

[7.8] कीवर्ड संरचना और कक्षा के बीच क्या अंतर है?

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

संरचना और वर्ग अन्यथा कार्यात्मक रूप से समकक्ष हैं।

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


1) कक्षा के सदस्य डिफ़ॉल्ट रूप से निजी होते हैं और संरचना के सदस्य डिफ़ॉल्ट रूप से सार्वजनिक होते हैं।

उदाहरण के लिए प्रोग्राम 1 संकलन में विफल रहता है और प्रोग्राम 2 ठीक काम करता है।

// Program 1
#include <stdio.h>

class Test {
    int x; // x is private
};
int main()
{
  Test t;
  t.x = 20; // compiler error because x is private
  getchar();
  return 0;
}
Run on IDE
// Program 2
#include <stdio.h>

struct Test {
    int x; // x is public
};
int main()
{
  Test t;
  t.x = 20; // works fine because x is public
  getchar();
  return 0;
}

2) किसी वर्ग / संरचना से संरचना प्राप्त करते समय, बेस क्लास / स्ट्रक्चर के लिए डिफ़ॉल्ट पहुंच-विनिर्देशक सार्वजनिक होता है। और जब कक्षा प्राप्त होती है, डिफ़ॉल्ट पहुंच विनिर्देशक निजी होता है।

उदाहरण के लिए प्रोग्राम 3 संकलन और प्रोग्राम 4 में विफल रहता है ठीक काम करता है।

// Program 3
#include <stdio.h>

class Base {
public:
    int x;
};

class Derived : Base { }; // is equilalent to class Derived : private Base {}

int main()
{
  Derived d;
  d.x = 20; // compiler error becuase inheritance is private
  getchar();
  return 0;
}
Run on IDE
// Program 4
#include <stdio.h>

class Base {
public:
    int x;
};

struct Derived : Base { }; // is equilalent to struct Derived : public Base {}

int main()
{
  Derived d;
  d.x = 20; // works fine becuase inheritance is public
  getchar();
  return 0;
}

  • । कक्षाओं में सभी सदस्यों को डिफ़ॉल्ट रूप से निजी होते हैं लेकिन संरचना सदस्यों में डिफ़ॉल्ट रूप से सार्वजनिक होते हैं।

    1. Structs के लिए कन्स्ट्रक्टर और विनाशक की तरह कोई शब्द नहीं है, लेकिन यदि आप प्रदान नहीं करते हैं तो क्लास कंपाइलर डिफ़ॉल्ट बनाता है।

    2. रिक्त संरचना का आकार 0 बाइट्स वेयर है जो खाली वर्ग के आकार के रूप में है 1 बाइट संरचना डिफ़ॉल्ट पहुंच प्रकार सार्वजनिक है। डेटा को समूहबद्ध करने के लिए आमतौर पर एक स्ट्रक्चर का उपयोग किया जाना चाहिए।

    कक्षा डिफ़ॉल्ट पहुंच प्रकार निजी है, और विरासत के लिए डिफ़ॉल्ट मोड निजी है। उस डेटा पर चलने वाले डेटा और विधियों को समूहीकृत करने के लिए एक वर्ग का उपयोग किया जाना चाहिए।

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

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







c++-faq