मैं कंस्ट्रक्टर में C++ ऑब्जेक्ट मेंबर वेरिएबल्स को कैसे इनिशियलाइज़ कर सकता हूँ?




constructor class-members (4)

मुझे एक वर्ग मिला है जिसमें सदस्य चर के रूप में कुछ जोड़े हैं। मैं नहीं चाहता कि इन सदस्यों के लिए निर्माणकर्ताओं को घोषित किए जाने पर बुलाया जाए, इसलिए मैं स्पष्ट रूप से ऑब्जेक्ट के लिए एक पॉइंटर को लटकाने की कोशिश कर रहा हूं। मुझे मालुम नहीं मैं क्या कर रहा हूँ। o_O

StackOverflow पर, मैं ऑब्जेक्ट सदस्य चर के अन्य उदाहरण खोजने में सक्षम हो सकता हूं, लेकिन आमतौर पर कंस्ट्रक्टर को तुरंत बुलाया जाता है, जैसे:

class MyClass {
    public:
        MyClass(int n);
    private:
        AnotherClass another(100); // this constructs AnotherClass right away!
};

लेकिन मैं चाहता हूं कि MyClass कंस्ट्रक्टर एक और MyClass constructor को कॉल करे। यहाँ मेरा कोड कैसा दिखता है:

BigMommaClass.h

#include "ThingOne.h"
#include "ThingTwo.h"

class BigMommaClass {

        public:
                BigMommaClass(int numba1, int numba2);

        private:
                ThingOne* ThingOne;
                ThingTwo* ThingTwo;
};

BigMommaClass.cpp

#include "BigMommaClass.h"

BigMommaClass::BigMommaClass(int numba1, int numba2) {
        this->ThingOne = ThingOne(100);
        this->ThingTwo = ThingTwo(numba1, numba2);
}

जब मैं संकलन करने की कोशिश कर रहा हूँ तो यह त्रुटि है:

g++ -Wall -c -Iclasses -o objects/BigMommaClass.o classes/BigMommaClass.cpp
In file included from classes/BigMommaClass.cpp:1:0:
classes/BigMommaClass.h:12:8: error: declaration of âThingTwo* BigMommaClass::ThingTwoâ
classes/ThingTwo.h:1:11: error: changes meaning of âThingTwoâ from âclass ThingTwoâ
classes/BigMommaClass.cpp: In constructor âBigMommaClass::BigMommaClass(int, int)â:
classes/BigMommaClass.cpp:4:30: error: cannot convert âThingOneâ to âThingOne in assignment
classes/BigMommaClass.cpp:5:37: error: â((BigMommaClass*)this)->BigMommaClass::ThingTwoâ cannot be used as a function
make: *** [BigMommaClass.o] Error 1

क्या मैं सही दृष्टिकोण का उपयोग कर रहा हूं लेकिन गलत वाक्य रचना? या मुझे इस पर एक अलग दिशा से आना चाहिए?


आप operator= का उपयोग करके एक ThingOne बनाने की कोशिश कर रहे हैं operator= जो काम नहीं कर रहा है (गलत सिंटैक्स)। इसके अलावा, आप एक वर्ग नाम को एक चर नाम के रूप में उपयोग कर रहे हैं, वह है, ThingOne* ThingOne । सबसे पहले, चर नाम तय करते हैं:

private:
    ThingOne* t1;
    ThingTwo* t2;

चूँकि ये पॉइंटर्स हैं, उन्हें किसी चीज़ की ओर इशारा करना चाहिए। यदि ऑब्जेक्ट का निर्माण अभी तक नहीं हुआ है, तो आपको अपने BigMommaClass कंस्ट्रक्टर में नए के साथ स्पष्ट रूप से करने की आवश्यकता होगी:

BigMommaClass::BigMommaClass(int n1, int n2)
{
    t1 = new ThingOne(100);
    t2 = new ThingTwo(n1, n2);
}

आम तौर पर प्रारंभिक सूचियों को निर्माण के लिए पसंद किया जाता है, लेकिन यह इस तरह दिखेगा:

BigMommaClass::BigMommaClass(int n1, int n2)
    : t1(new ThingOne(100)), t2(new ThingTwo(n1, n2))
{ }

आप निर्दिष्ट कर सकते हैं कि सदस्य को इनिशियलाइज़र सूची में कैसे आरम्भ करें

BigMommaClass {
    BigMommaClass(int, int);

private:
    ThingOne thingOne;
    ThingTwo thingTwo;
};

BigMommaClass::BigMommaClass(int numba1, int numba2)
    : thingOne(numba1 + numba2), thingTwo(numba1, numba2) {}

मैं इस तथ्य से अवगत हूँ कि यह प्रश्न पुराना है, फिर भी मैं @chris के पहले ( और महान ) उत्तर के बारे में कुछ बताना चाहता था जिसने उस स्थिति का समाधान प्रस्तावित किया जहाँ कक्षा के सदस्य रहते हैं एक " सच्चे समग्र " सदस्यों के रूप में (यानी, बिंदु NOR संदर्भ के रूप में नहीं )। नोट थोड़ा बड़ा है इसलिए मैं इसे कुछ नमूना कोड के साथ यहां प्रदर्शित करूंगा।

जब आपने सदस्यों को रखने का फैसला किया जैसा कि मैंने उल्लेख किया है, तो आपको इन दो बातों को भी ध्यान में रखना होगा:

1) प्रत्येक "कंपोज़्ड ऑब्जेक्ट" के लिए, जिसमें डिफ़ॉल्ट ctor नहीं है - आप इसे "पिता" वर्ग ( BigMommaClass या MyClass के मूल उदाहरणों और MyClass के मूल कोड में सभी के आरंभिक सूची में आरंभीकृत कर सकते हैं) ), मामले में कई हैं (नीचे के उदाहरण में InnerClass1 1 देखें)। मतलब, आप m_innerClass1(a) और m_innerClass1(15) केवल "टिप्पणी" कर सकते हैं यदि आप InnerClass1 डिफ़ॉल्ट ctor को सक्षम करते हैं।

2) प्रत्येक "कंपोज्ड ऑब्जेक्ट" के लिए, InnerClass2 का InnerClass2 - आप इसे इनिशियलाइज़ेशन लिस्ट में इनिशियलाइज़ करते हैं, लेकिन यह तब भी काम करेगा जब आपने इसे नहीं चुना (नीचे उदाहरण में InnerClass2 देखें)।

नमूना कोड देखें (जीयू g++ संस्करण 7.3.0 के साथ उबंटू 18.04 के तहत अनुपालन):

#include <iostream>

using namespace std;

class InnerClass1
{
    public:
        InnerClass1(int a) : m_a(a)
        {
            cout << "InnerClass1::InnerClass1 - set m_a:" << m_a << endl;
        }

        /* No default cotr
        InnerClass1() : m_a(15)
        {
            cout << "InnerClass1::InnerClass1() - set m_a:" << m_a << endl;
        }
        */

        ~InnerClass1()
        {
            cout << "InnerClass1::~InnerClass1" << endl;
        }

    private:
        int m_a;
};

class InnerClass2
{
    public:
        InnerClass2(int a) : m_a(a)
        {
            cout << "InnerClass2::InnerClass2 - set m_a:" << m_a << endl;
        }

        InnerClass2() : m_a(15)
        {
            cout << "InnerClass2::InnerClass2() - set m_a:" << m_a << endl;
        }

        ~InnerClass2()
        {
            cout << "InnerClass2::~InnerClass2" << endl;
        }

    private:
        int m_a;
};

class MyClass
{
    public:
        MyClass(int a, int b) : m_innerClass1(a), /* m_innerClass2(a),*/ m_b(b)
        {
            cout << "MyClass::MyClass(int b) - set m_b to:" << m_b << endl;
        }

         MyClass() : m_innerClass1(15), /*m_innerClass2(15),*/ m_b(17) 
        {
            cout << "MyClass::MyClass() - m_b:" << m_b << endl;
        }

        ~MyClass()
        {
            cout << "MyClass::~MyClass" << endl;
        }

    private:
        InnerClass1 m_innerClass1;
        InnerClass2 m_innerClass2;
        int m_b;
};

int main(int argc, char** argv)
{

    cout << "main - start" << endl;

    MyClass obj;

    cout << "main - end" << endl;
    return 0;
}

यह प्रश्न थोड़ा पुराना है, लेकिन यहाँ अपने खाता चर को शुरू करने से पहले निर्माणकर्ता में "अधिक काम करने" के c ++ 11 में एक और तरीका है:

BigMommaClass::BigMommaClass(int numba1, int numba2)
    : thingOne([](int n1, int n2){return n1+n2;}(numba1,numba2), 
      thingTwo(numba1, numba2) {}

ऊपर लंबो फ़ंक्शन को लागू किया जाएगा और परिणाम thingOnes निर्माता को दिया जाएगा। आप निश्चित रूप से मेमने को जितना चाहें उतना जटिल बना सकते हैं।





object-construction