मैंने दो वर्ग बनाए हैं: stack1 और stack2 और पुश (), पॉप (), isempty () और isfull () के अपने स्वयं के स्टैक संचालन को परिभाषित किया है। मैं एक इनपुट से एक पोस्टफिक्स अभिव्यक्ति की गणना करने की कोशिश कर रहा हूँ। मैंने ऑपरेशन नामक एक और वर्ग बनाया है जो stack1 और stack2 का बच्चा है, इसलिए मैं पुश (), पॉप ( ), आदि.. ऑपरेशन के भीतर। मेरे पास ऑपरेशन के भीतर एक फंक्शन है जिसे ऑपरेट () कहा जाता है जो स्टैक पर गंदा काम करता है। इस फ़ंक्शन के भीतर मेरे पास थोड़ी देर का लूप है जो stack1 पर निर्भर करता है जब तक कि ऑपरेशन पूरा न हो जाए; हालांकि, जब मैं इस फ़ंक्शन के माध्यम से शीर्ष 1 पर कदम रखता हूं, जहां stack1 इंगित कर रहा है, 0 पर रीसेट कर दिया गया है। क्या इसे दूर करने का कोई तरीका है/क्या मैं कुछ गलत कर रहा हूं? यह पहली बार है जब मैं कक्षाओं और इस तरह का उपयोग कर रहा हूं, इसलिए मुझे इन और आउट के बारे में निश्चित नहीं है।

यहाँ मेरी कक्षाओं की परिभाषाएँ हैं:

class stack1 {
    private:
        int num1[SIZE/2];       int top1;
    public:
        void push1(int data)
        {
            if (is_full1());
            else
            {
                num1[top1] = data;
                top1++;
            }
        }
        int pop1(void)
        {
            if(is_empty1());
            else
            {
                top1--;
                return num1[top1];
            }
        }
        int is_empty1(void)
        {
            if(top1 == 0)
            {
                return 1;
            }else
            {
                return 0;
            }
        }
        int is_full1(void)
        {
            if(top1 == SIZE)
            {
                return 1;
            }else
            {
                return 0;
            }
        }

        stack1()
        {
            top1 = 0;           num1[SIZE/2] = {0};
        } };

class stack2 {
    private:
        int num2[SIZE/2];       int top2;   public:
        void push2(int data)
        {
            if (is_full2());
            else
            {
                num2[top2] = data;
                top2++;
            }
        }
        int pop2(void)
        {
            if(is_empty2());
            else
            {
                top2--;
            return num2[top2];
            }
        }
        int is_empty2(void)
        {
            if(top2 == 0)
            {
                return 1;
            }else
            {
                return 0;
            }
        }
        int is_full2(void)
        {
            if(top2 == SIZE)
            {
                return 1;
            }else
            {
                return 0;
            }
        }

        stack2()
        {
            top2 = 0;           num2[SIZE/2] = {0};
        } };

class operation: public stack2, public stack1 {
    private:
        int answer;
        int a;
        int b;
        int num_cnt;
        int ans;
        int from_st1;
        int from_st2;
    public:
        int c;
        int oper(void)
        {
            answer = 0;
            a = 0;
            b = 0;
            num_cnt = 0;
            ans = 0;
            c = 0;
            stack1 st1;
            stack2 st2;
            while(!st1.is_empty1())
            {
                from_st1 = st1.pop1();
                if(from_st1 == plus)
                {
                    st2.push2(from_st1);
                }else if(from_st1 == minus)
                {
                    st2.push2(from_st1);
                }else if(from_st1 == mult)
                {
                    st2.push2(from_st1);
                }else if (from_st1 == divide)
                {
                    st2.push2(from_st1);
                }else if(num_cnt == 1)
                {
                    num_cnt = 0;
                    if(ans == 0)
                    {
                        answer = b;
                        ans++;
                    }
                    a = from_st1;
                    from_st2 = st2.pop2();
                    if(from_st2 == plus)
                    {
                        c = a+answer;
                    }else if(from_st2 == minus)
                    {
                        c = a-answer;
                    }else if(from_st2 == mult)
                    {
                        c = a*answer;
                    }else if(from_st2 == divide)
                    {
                        c = a/answer;
                    }
                }else
                {
                    b = from_st1;
                }
                num_cnt++;
            }
        return c;
        }

        operation()
        {
            answer = 0;
            a = 0;
            b = 0;
            num_cnt = 0;
            ans = 0;
            from_st1 = 0;
            from_st2 = 0;
        } };
0
Chris_skelton 22 फरवरी 2020, 06:38
आप स्थानीय st1 और st2 क्यों बना रहे हैं?
 – 
Eljay
22 फरवरी 2020, 06:54
operation को stack1 और stack2 का उपवर्ग बनाना एक डिज़ाइन त्रुटि प्रतीत होती है। यह आपके कोड का कोई अच्छा काम नहीं करता है, क्योंकि आप तत्काल कर रहे हैं और वैसे भी अलग-अलग स्टैक-ऑब्जेक्ट्स का उपयोग कर रहे हैं, यह आपकी operation ऑब्जेक्ट को जितना बड़ा होना चाहिए उससे कहीं अधिक बड़ा बनाता है (चूंकि प्रत्येक operation ऑब्जेक्ट में अब एक शामिल है stack1 ऑब्जेक्ट्स और एक stack2 ऑब्जेक्ट जो कभी किसी चीज़ के लिए उपयोग नहीं किए जाते हैं), और इसका कोई मतलब नहीं है (चूंकि एक ऑपरेशन एक विशेष प्रकार का स्टैक 1 या एक विशेष प्रकार का स्टैक 2 नहीं है, जो कि क्या है उन वर्गों को उपवर्गित करने का अर्थ होगा)
 – 
Jeremy Friesner
22 फरवरी 2020, 07:05
"मैंने ऑपरेशन नामक एक और वर्ग बनाया है जो स्टैक 1 और स्टैक 2 का बच्चा है, इसलिए मैं ऑपरेशन के भीतर पुश (), पॉप (), आदि के कार्यों तक पहुंच सकता हूं।" वह गलत डिजाइन है! एक ऑपरेशन किसी भी प्रकार का ढेर नहीं है! एक वर्ग के तरीके दूसरे वर्ग के डेटा के साथ काम कर सकते हैं, इसका मतलब यह नहीं है कि आपको इनहेरिट करना होगा। अगर ऐसा है तो सभी वर्गों को एक दूसरे से विरासत में मिलाना होगा। तो एक नए डिजाइन के साथ शुरुआत करें!
 – 
Klaus
22 फरवरी 2020, 12:18
एक और विचित्रता: stack1 और stack2 वर्ग लगभग समान हैं, केवल अंतर चर और विधियों के नाम का है। समान व्यवहार के साथ दो वर्ग (अर्थात दो भिन्न प्रकार) बनाने का कोई कारण नहीं है: संभवतः आपको एक प्रकार और फिर 2 या अधिक उदाहरण बनाने की आवश्यकता है। मैं> उस प्रकार का?
 – 
Gian Paolo
22 फरवरी 2020, 12:27

1 उत्तर

मैं उस समस्या कथन से लेता हूं जिसे आप चार ऑपरेटरों के साथ एक बुनियादी कैलकुलेटर बनाने की कोशिश कर रहे हैं और स्टैक का उपयोग करके मूल अभिव्यक्ति मूल्यांकन की आवश्यकता है। मान लें कि आपके पास एक व्यंजक है: a+b-cd/e स्टैक में इस तरह दिखता है: TOP e->/->d->->c->-->b->+->a EMPTY और इस ट्रैक का मूल्यांकन करने की आवश्यकता है।

इनके आधार पर .. आप नीचे की तरह कुछ ढूंढ रहे होंगे:

class stack {
    private:
        int num[SIZE];       
        int top;
    public:
        void push(int data)
        {
            if (is_full1());
            else
            {
                num[top] = data;
                top++;
            }
        }
        int pop(void)
        {
            if(is_empty());
            else
            {
                top--;
                return num[top];
            }
        }
        int is_empty(void)
        {
            if(top == 0)
            {
                return 1;
            }else
            {
                return 0;
            }
        }
        int is_full(void)
        {
            if(top == SIZE)
            {
                return 1;
            }else
            {
                return 0;
            }
        }

        stack()
        {
            top = 0;           num[SIZE] = {0};
        } 
};

class operation {
    private:
        int answer;
        int op1;
        int op;

    boolean isOperator(int val) {
        boolen retVal = false;;

        if (val == plus ||
            val == minus ||
            val == divide ||
            val == mult) {
                retVal = true;
            } 
        else {
            retVal = false;
        }
        return retVal;
    }
    public:
        int oper(stack st1)
        {
            int from_st1 = 0;
            while(!st1.is_empty())
            {
                from_st1 = st1.pop();
                if(isOperator(from_st1))
                {
                    op = from_st1;
                }
                else if(answer != 0)
                {
                    op1 = from_st1;
                    if(op == plus)
                    {
                        answer = op1 + answer;
                    }else if(op == minus)
                    {
                        answer = op1 - answer;
                    }else if(op == mult)
                    {
                        answer = op1 * answer;
                    }else if(op == divide)
                    {
                        answer = op1 / answer;
                    }
                }
                else
                {
                    answer = from_st1;
                }
            }
        return answer;
        }

        operation()
        {
            answer = 0;
            op1 = 0;
            op = 0;
        } 
};

नोट: आप एक स्टैक के साथ सभी मूल्यांकन कर सकते हैं, दो स्टैक की आवश्यकता नहीं है। इस असाइनमेंट के लिए आपके ऑपरेंड +, -, * और / के पूर्णांक मानों के बराबर नहीं हो सकते। आपके पास main() कोड में स्टैक में एक मान्य एक्सप्रेशन इनपुट है।

0
Ravi Kappagantu 22 फरवरी 2020, 09:39