C++
सदस्यों को संकेत

वाक्य - विन्यास

• एक वर्ग का नाम वर्ग मानकर ...

  • प्रकार * ptr = & वर्ग :: सदस्य; // केवल स्थैतिक सदस्यों को इंगित करें
  • टाइप क्लास :: * ptr = & क्लास :: सदस्य; // गैर-स्थिर वर्ग के सदस्यों को इंगित करें

• गैर-स्थिर वर्ग के सदस्यों को संकेत के लिए, निम्नलिखित दो परिभाषाएँ दी गई हैं:

  • कक्षा का उदाहरण;
  • कक्षा * पी = & उदाहरण;

• कक्षा सदस्य चर की ओर संकेत

  • ptr = & वर्ग :: i; // हर वर्ग के भीतर परिवर्तनशील बिंदु की ओर इशारा करता हूं
  • उदाहरण। * ptr = 1; // एक्सेस इंस्टेंस i
  • p -> * ptr = 1; // एक्सेस पी की मैं

• कक्षा के सदस्यों के कार्यों के संकेत

  • पीटीआर = & क्लास :: एफ; // हर कक्षा के भीतर 'एफ' कार्य करने के लिए बिंदु
  • (। उदाहरण * ptr) (5); // कॉल इंस्टेंस का F
  • (पी -> * ptr) (6); // कॉल पी का एफ

स्थिर सदस्य कार्यों के लिए संकेत

एक static मेंबर फंक्शन साधारण सी / सी ++ फंक्शन की तरह होता है, सिवाय स्कोप के:

• यह एक class अंदर है, इसलिए इसे अपने नाम को वर्ग नाम से सजाया जाना चाहिए;
• public , protected या private साथ इसकी पहुंच है।

इसलिए, यदि आपके पास static सदस्य फ़ंक्शन तक पहुंच है और इसे सही ढंग से सजाते हैं, तो आप फ़ंक्शन को किसी class बाहर किसी सामान्य फ़ंक्शन की तरह इंगित कर सकते हैं:

typedef int Fn(int); // Fn is a type-of function that accepts an int and returns an int

// Note that MyFn() is of type 'Fn'
int MyFn(int i) { return 2*i; }

class Class {
public:
    // Note that Static() is of type 'Fn'
    static int Static(int i) { return 3*i; }
}; // Class

int main() {
    Fn *fn;    // fn is a pointer to a type-of Fn

    fn = &MyFn;          // Point to one function
    fn(3);               // Call it
    fn = &Class::Static; // Point to the other function
    fn(4);               // Call it
 } // main()

सदस्य कार्यों के लिए संकेत

किसी वर्ग के सदस्य फ़ंक्शन तक पहुंचने के लिए, आपको किसी विशेष उदाहरण के लिए "हैंडल" की आवश्यकता होती है, या तो उदाहरण के रूप में, या इसके लिए एक संकेतक या संदर्भ। कक्षा के उदाहरण को देखते हुए, आप अपने सदस्यों के विभिन्न बिंदुओं को एक पॉइंटर-टू-मेंबर के साथ इंगित कर सकते हैं, यदि आपको सिंटैक्स सही मिलता है! बेशक, पॉइंटर को उसी प्रकार का घोषित किया जाना चाहिए जैसा आप इंगित कर रहे हैं ...

typedef int Fn(int); // Fn is a type-of function that accepts an int and returns an int

class Class {
public:
    // Note that A() is of type 'Fn'
    int A(int a) { return 2*a; }
    // Note that B() is of type 'Fn'
    int B(int b) { return 3*b; }
}; // Class

int main() {
    Class c;          // Need a Class instance to play with
    Class *p = &c;    // Need a Class pointer to play with

    Fn Class::*fn;    // fn is a pointer to a type-of Fn within Class

    fn = &Class::A;   // fn now points to A within any Class
    (c.*fn)(5);       // Pass 5 to c's function A (via fn)
    fn = &Class::B;   // fn now points to B within any Class
    (p->*fn)(6);      // Pass 6 to c's (via p) function B (via fn)
} // main()

सदस्य चर (पिछले उदाहरण में) के विपरीत, वर्ग उदाहरण और सदस्य सूचक के बीच संबंध को कोष्ठक के साथ एक साथ कसकर बाध्य करने की आवश्यकता होती है, जो थोड़ा अजीब लगता है (जैसा कि हालांकि .* और ->* अजीब नहीं हैं। बस!)

सदस्य चर के लिए संकेत

किसी class सदस्य तक पहुँचने के लिए, आपको किसी विशेष उदाहरण के लिए "हैंडल" की आवश्यकता होती है, या तो उदाहरण के रूप में, या इसके लिए एक संकेतक या संदर्भ। class उदाहरण को देखते हुए, आप अपने सदस्यों के विभिन्न बिंदुओं को एक पॉइंटर-टू-मेंबर के साथ इंगित कर सकते हैं, यदि आपको सिंटैक्स सही मिलता है! बेशक, पॉइंटर को उसी प्रकार का घोषित किया जाना चाहिए जैसा आप इंगित कर रहे हैं ...

class Class {
public:
    int x, y, z;
    char m, n, o;
}; // Class

int x;  // Global variable

int main() {
    Class c;        // Need a Class instance to play with
    Class *p = &c;  // Need a Class pointer to play with

    int *p_i;       // Pointer to an int

    p_i = &x;       // Now pointing to x
    p_i = &c.x;     // Now pointing to c's x

    int Class::*p_C_i; // Pointer to an int within Class

    p_C_i = &Class::x; // Point to x within any Class
    int i = c.*p_C_i;  // Use p_c_i to fetch x from c's instance
    p_C_i = &Class::y; // Point to y within any Class
    i = c.*p_C_i;      // Use p_c_i to fetch y from c's instance

    p_C_i = &Class::m; // ERROR! m is a char, not an int!

    char Class::*p_C_c = &Class::m; // That's better...
} // main()

पॉइंटर-टू-मेंबर के सिंटैक्स को कुछ अतिरिक्त सिंटैक्टिक तत्वों की आवश्यकता होती है:

• पॉइंटर के प्रकार को परिभाषित करने के लिए, आपको आधार प्रकार का उल्लेख करने की आवश्यकता है, साथ ही साथ यह तथ्य है कि यह एक वर्ग के अंदर है: int Class::*ptr; ।
• आप एक वर्ग या संदर्भ है और एक सूचक करने वाली किसी सदस्य के साथ इसका उपयोग करना चाहते हैं, तो आप उपयोग करने की आवश्यकता .* ऑपरेटर (जैसा . ऑपरेटर)।
• यदि आपके पास एक कक्षा के लिए एक पॉइंटर है और इसका उपयोग पॉइंटर-टू-मेंबर के साथ करना चाहते हैं, तो आपको ->* ऑपरेटर (akin -> the -> ऑपरेटर) का उपयोग करने की आवश्यकता है।

स्थिर सदस्य चर की ओर संकेत करता है

एक static मेंबर वेरिएबल साधारण C / C ++ वैरिएबल की तरह है, जिसमें स्कोप नहीं है:

• यह एक class अंदर है, इसलिए इसे अपने नाम को वर्ग नाम से सजाया जाना चाहिए;
• public , protected या private साथ इसकी पहुंच है।

इसलिए, यदि आपके पास static सदस्य चर है और इसे सही ढंग से सजा सकते हैं, तो आप किसी class बाहर किसी भी सामान्य चर की तरह चर को इंगित कर सकते हैं:

class Class {
public:
    static int i;
}; // Class

int Class::i = 1; // Define the value of i (and where it's stored!)

int j = 2;   // Just another global variable

int main() {
    int k = 3; // Local variable

    int *p;

    p = &k;   // Point to k
    *p = 2;   // Modify it
    p = &j;   // Point to j
    *p = 3;   // Modify it
    p = &Class::i; // Point to Class::i
    *p = 4;   // Modify it
} // main()