Rust
ऑपरेटर्स और ओवरलोडिंग

परिचय

अतिरिक्त ऑपरेटर को लोड करना (+)

अतिरिक्त ऑपरेटर (+) को ओवरलोड करने के लिए std::ops::Add trait को लागू करना होगा।

प्रलेखन से, लक्षण की पूरी परिभाषा है:

pub trait Add<RHS = Self> {
    type Output;
    fn add(self, rhs: RHS) -> Self::Output;
}

यह कैसे काम करता है?

• लक्षण बाएं हाथ की ओर प्रकार के लिए लागू किया गया है
• विशेषता बाएं हाथ की ओर एक के रूप में एक ही प्रकार के होने के लिए, एक दाईं ओर तर्क के लिए लागू किया जाता है जब तक कि यह चूक निर्दिष्ट
• संबद्ध प्रकार के Output में जोड़ के परिणाम का प्रकार निर्दिष्ट किया गया है

इस प्रकार, 3 अलग-अलग प्रकार होना संभव है।

ध्यान दें: उपयोग किए जाने वाले लक्षण बाईं ओर और दाईं ओर के तर्क हैं, आप इसे नंगे प्रकारों के बजाय अपने प्रकार के संदर्भों के लिए लागू करना पसंद कर सकते हैं।

कस्टम प्रकार के लिए + लागू करना:

use std::ops::Add;

#[derive(Clone)]
struct List<T> {
    data: Vec<T>,
}
//  Implementation which consumes both LHS and RHS
impl<T> Add for List<T> {
    type Output = List<T>;

    fn add(self, rhs: List<T>) -> List<T> {
        self.data.extend(rhs.data.drain(..));
        self
    }
}

//  Implementation which only consumes RHS (and thus where LHS != RHS)
impl<'a, T: Clone> Add<List<T>> for &'a List<T> {
    type Output = List<T>;

    fn add(self, rhs: List<T>) -> List<T> {
        self.clone() + rhs
    }
}