सी ++ ऑपरेटर ओवरलोड टेम्पलेट विभिन्न तर्कों के साथ

Question

मैं सी ++ खोज रहा हूं और मैं टेम्पलेट का उपयोग करके एक मिनी गणित मैट्रिक्स लिब्रायरी बनाना चाहता हूं।

यहां, मैं ऑपरेटर * को अधिभारित करना चाहता हूं।

तो मैं इस तरह एक मैट्रिक्स का वर्णन: M साथ M(y, x) मैट्रिक्स नाम, y और x ऊंचाई और चौड़ाई, एक आव्यूह गुणन कि तरह दिखना चाहिए:

M(a, b) * N(b, c) = R(a, c) 

वर्तमान में मैं इस कोड है:

template<unsigned int y, unsigned int x> 
class Matrix 
{ 
public: 
    Matrix() { } 
    ~Matrix() { } 

    Matrix<y, x2>& operator*(const Matrix<y2, x2>& right) 
    { 
     // code... 
    } 
private: 
    std::array<std::array<double, x>, y> m_values; 
}; 

तो मैं उस तरह मैट्रिक्स दो विभिन्न गुणा करने के लिए सक्षम होने के लिए करना चाहते हैं:

Matrix<3, 4> m; 
Matrix<4, 2> n; 

// fill the matrix with values 

Matrix<3, 2> o = m * n; 

मैंने खोज की है लेकिन मुझे इस प्रश्न का उत्तर नहीं मिला (शायद क्योंकि मुझे नहीं पता कि मुझे वास्तव में क्या खोजना चाहिए)।

धन्यवाद आपकी मदद :)

Answer 1

के लिए आप बनाने की जरूरत है अपने operator* एक टेम्पलेट सदस्य समारोह, तो कुछ इस तरह:

template <unsigned int y2, unsigned int x2> 
Matrix<y, x2> operator*(const Matrix<y2, x2>& right) 
{ 
    // code... 
} 

सूचना है कि वापसी प्रकार कोई संदर्भ है, के रूप में operator* को एक नया मान वापस करना चाहिए - यदि आप चाहें, तो आप एक पूरक operator*= परिभाषित कर सकते हैं जो एलएचएस मैट्रिक्स को जगह में संशोधित करता है।

ध्यान देने योग्य एक और बात यह है कि मैट्रिक्स गुणा केवल समझ में आता है अगर मैट्रिस के आयाम सहमत हैं: यानी, यदि एलएचएस में कॉलम की संख्या आरएचएस में पंक्तियों की संख्या से मेल खाती है। इस को लागू करने के लिए, आप यह सुनिश्चित करें कि टेम्प्लेट पैरामीटर सहमत करने के लिए अपने सदस्य समारोह के भीतर एक static_assert इस्तेमाल कर सकते हैं:

template <unsigned int y2, unsigned int x2> 
Matrix<y, x2> operator*(const Matrix<y2, x2>& right) 
{ 
    static_assert(y2 == x, "Matrix dimensions mismatched"); 
    // code... 
} 

Answer 2

यह काफी सरल है, एक समारोह टेम्पलेट के रूप में operator* परिभाषित करते हैं। उदाहरण मुक्त समारोह टेम्पलेट:

template<unsigned y1, unsigned x1, unsigned y2, unsigned x2> 
Matrix<y1, x2> operator*(Matrix<y1, x1> const& l, Matrix<y2, x2> const& r) 
{ 
    // static_assert(x1 == y2, "Matrices cannot be multiplied"); 
    Matrix<y1, x2> ret{}; 
    // multiply 
    return ret; 
} 

ध्यान दें मूल्य द्वारा कि operator* रिटर्न करें। यह विशेष रूप से महत्वपूर्ण है क्योंकि आप एक अलग प्रकार को वापस करते हैं और इसके संदर्भ में कोई ऑब्जेक्ट नहीं है (मूर्खतापूर्ण शुद्धता को अलग करता है)।