C++
मित्र कीवर्ड

परिचय

मित्र समारोह

एक वर्ग या एक संरचना किसी भी कार्य को घोषित कर सकती है जो वह मित्र है। यदि कोई फ़ंक्शन किसी कक्षा का मित्र है, तो वह सभी सुरक्षित और निजी सदस्यों तक पहुँच सकता है:

// Forward declaration of functions.
void friend_function();
void non_friend_function();

class PrivateHolder {
public:
    PrivateHolder(int val) : private_value(val) {}
private:
    int private_value;
    // Declare one of the function as a friend.
    friend void friend_function();
};

void non_friend_function() {
    PrivateHolder ph(10);
    // Compilation error: private_value is private.
    std::cout << ph.private_value << std::endl;
}

void friend_function() {
    // OK: friends may access private values.
    PrivateHolder ph(10);
    std::cout << ph.private_value << std::endl;
}

एक्सेस मॉडिफ़ायर मित्र शब्दार्थों को परिवर्तित नहीं करते हैं। मित्र की सार्वजनिक, संरक्षित और निजी घोषणाएँ बराबर होती हैं।

मित्र घोषणाएँ विरासत में नहीं मिली हैं। उदाहरण के लिए, यदि हम PrivateHolder उपवर्ग:

class PrivateHolderDerived : public PrivateHolder {
public:
    PrivateHolderDerived(int val) : PrivateHolder(val) {}
private:
    int derived_private_value = 0;
};

और इसके सदस्यों तक पहुँचने का प्रयास करें, हम निम्नलिखित प्राप्त करेंगे:

void friend_function() {
    PrivateHolderDerived pd(20);
    // OK.
    std::cout << pd.private_value << std::endl;
    // Compilation error: derived_private_value is private.
    std::cout << pd.derived_private_value << std::endl;
}

ध्यान दें कि PrivateHolderDerived सदस्य फ़ंक्शन PrivateHolder::private_value उपयोग नहीं कर सकता है, जबकि मित्र फ़ंक्शन यह कर सकता है।

मित्र विधि

तरीकों के रूप में अच्छी तरह से दोस्तों के रूप में घोषित किया जा सकता है:

class Accesser {
public:
    void private_accesser();
};

class PrivateHolder {
public:
    PrivateHolder(int val) : private_value(val) {}
    friend void Accesser::private_accesser();
private:
    int private_value;
};

void Accesser::private_accesser() {
    PrivateHolder ph(10);
    // OK: this method is declares as friend.
    std::cout << ph.private_value << std::endl;
}

मित्र वर्ग

एक पूरी कक्षा को मित्र घोषित किया जा सकता है। मित्र वर्ग की घोषणा का अर्थ है कि मित्र का कोई भी सदस्य घोषित वर्ग के निजी और संरक्षित सदस्यों तक पहुंच सकता है:

class Accesser {
public:
    void private_accesser1();
    void private_accesser2();
};

class PrivateHolder {
public:
    PrivateHolder(int val) : private_value(val) {}
    friend class Accesser;
private:
    int private_value;
};

void Accesser::private_accesser1() {
    PrivateHolder ph(10);
    // OK.
    std::cout << ph.private_value << std::endl;
}

void Accesser::private_accesser2() {
    PrivateHolder ph(10);
    // OK.
    std::cout << ph.private_value + 1 << std::endl;
}

मित्र वर्ग की घोषणा प्रतिवर्ती नहीं है। यदि कक्षाओं को दोनों दिशाओं में निजी पहुंच की आवश्यकता होती है, तो दोनों को मित्र घोषणाओं की आवश्यकता होती है।

class Accesser {
public:
    void private_accesser1();
    void private_accesser2();
private:
    int private_value = 0;
};

class PrivateHolder {
public:
    PrivateHolder(int val) : private_value(val) {}
    // Accesser is a friend of PrivateHolder
    friend class Accesser;
    void reverse_accesse() {
        // but PrivateHolder cannot access Accesser's members.
        Accesser a;
        std::cout << a.private_value;
    }
private:
    int private_value;
};