सी ++ ऑपरेटर जटिल संख्या संचालन

Question

मैं सी में एक काम है ++ और मैं समस्या हो रही है के लिए अधिक भार शुरू हो रही है। लक्ष्य "जटिल श्रेणी के लिए निम्न अधिभारित ऑपरेटरों का उपयोग करने वाली कक्षा को डिज़ाइन करना है: >> < < + - * /"

मेरा प्रश्न इस के वाक्यविन्यास के बारे में नहीं है, बल्कि तर्क के बारे में अधिक है। मैं कुछ मदद मस्तिष्क तूफान का उपयोग कर सकते हैं।

इनपुट नमूना:
2,5 -2,2
1,0 1,0

उत्पादन नमूना:
एक = (2,5) + (-2,2) मैं
बी = (1.0) + (1.0) मैं

ए + बी = (3.5) + (-1.2) मैं
ए - बी = ..............
ए * बी = ........ ......
ए/बी = ..............

तो मैं इस कैसे शुरू करूँ? वर्ग "जटिल" इन ऑपरेटरों overloads, तो इसका मतलब यह है कि मैं केवल कक्षा में इन ऑपरेटरों का उपयोग कर सकते हैं (यानी सार्वजनिक कार्यों के अंदर)? यदि ऐसा है तो मैं इसे इस तरह से करना चाहूंगा? या मैं इसे अपने क्लाइंट/ड्राइवर कोड में करना चाहता हूं?

दूसरा, यह सिर्फ प्रत्येक पंक्ति के दूसरे मूल्य के लिए मैं जोड़ रहा है? यह बहुत आसान लगता है। किसी भी दिशा की सराहना की जाएगी। (बस रिकॉर्ड के लिए, मैं किसी के लिए अपना होमवर्क करने की तलाश नहीं कर रहा हूं ... केवल कुछ इनपुट का उपयोग कर सकता है)

Answer 1

ऐसा लगता है कि बिंदु क्लास ऑपरेशन ओवरलोडिंग का प्रदर्शन करना है, इसलिए मुझे लगता है कि विचार आपके लिए क्लास कॉम्प्लेक्स बनाना है जिसमें वास्तविक संख्या और काल्पनिक संख्या (मेरा मतलब है कि यह काल्पनिक है) के बारे में जानकारी रखता है। ऑपरेटर में जटिल संख्याओं के बीच विभिन्न परिचालनों को संभालें जो आप स्वयं करते हैं।

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

उम्मीद है कि मदद करता है। सौभाग्य!

Answer 2

वे मान के जोड़े की तरह:

A = N1 + I1i 
B = N2 + I2i 


A + B = (N1 + I1i) + (N2 + I2i) 
     = N1 + I1i + N2 + I2i 
     = (N1 + N2) + (I1i + I2i) 
     = (N1 + N2) + (I1 + I2)i 
A - B = (N1 + I1i) - (N2 + I2i) 
     = N1 + I1i - N2 - I2i 
     = (N1 - N2) + (I1i - I2i) 
     = (N1 - N2) + (I1 - I2)i 

// N1, N2, I1, I2 are all just normal numbers. 
// You can multiply them like normal. You just have to keep track of the `i` 
// Also not that i = sqrt(-1) 
// Therefore i * i = sqrt(-1) * sqrt(-1) 
//     = sqrt(-1)^2 
//     = -1 
A * B = (N1 + I1i) * (N2 + I2i) 
     = (N1 * N2) + (N1 * I2i) + (I1i * N2) + (I1i * I2i) 
     = (N1 * N2) + (N1 * I2)i + (N2 * I1)i + (i * i * I1 * I2) 
     = (N1 * N2) + i((N1 * I2) + (N2 * I1)) + (-1 * I1 * I2) 

     // Simplest form 
     = ((N1 * N2) - (I1 * I2)) + ((N1 * I2) + (N2 * I1))i 


A/B = Repeat as above. 

Answer 3

आप एक वर्ग बुलाया परिसर भी शामिल डिजाइन करने के लिए की जरूरत कम से कम:

• एक निर्माता आप वास्तविक और काल्पनिक से एक परिसर वस्तु के निर्माण के लिए अनुमति देता है घटक मूल्य उदा परिसर (1, 5)

• + ऑपरेटर ताकि आप दो परिसर वस्तुओं जोड़ सकते हैं ओवरराइड करता है, एक नया परिसर वस्तु जैसे लौटनेपरिसर (1, 5) + परिसर (3, 7) परिसर है (4, 12)

• अन्य ऑपरेटरों

लेकिन पहले आपको जटिल संख्याओं के पीछे बुनियादी गणित को समझने की जरूरत के लिए इसी तरह

ताकि आप ऑपरेटर ओवरलोड विधियों को लिख सकते हैं।

एक श्रेणी (उदाहरण परिसर) को परिभाषित है कि एक जटिल संख्या के वास्तविक और काल्पनिक भाग के लिए डेटा रखने कर सकते हैं:

Answer 4

कुछ चीजें आप इस कार्य को पूरा करने क्या करना है कर रहे हैं।

अधिभार संबंधित ऑपरेटरों (जैसे):

class Complex 
{ 
public: 
    // other declarations here 
    Complex operator+ (const Complex& rhs) const; 
    // other stuff here 
}; 

संबंधित ऑपरेटरों को लागू वास्तव में गणितीय कार्रवाई करने के लिए (उदाहरण के लिए):

Complex Complex::operator+ (const Complex& rhs) const 
{ 
    Complex result = *this; 
    result.Real += rhs.Real; 
    result.Imaginary += rhs.Imaginary; 
    return result; 
}