C# में मेथड्स को पॉइंटर्स पैरामीटर्स के रूप में पास करना

C# में पॉइंटर्स को मेथड पैरामीटर्स के रूप में पास करना

C# डिफ़ॉल्ट रूप से **सेफ कोड** है और पॉइंटर्स का सीधा समर्थन नहीं करता। पॉइंटर्स का उपयोग करने के लिए unsafe कॉन्टेक्स्ट और कंपाइलर ऑप्शन /unsafe या प्रोजेक्ट सेटिंग "Allow unsafe code" की आवश्यकता होती है।

सिंटैक्स

// अनसेफ मेथड
public unsafe void Swap(int* p, int* q) {
    int temp = *p;
    *p = *q;
    *q = temp;
}

पूर्ण उदाहरण

using System;

class Program {
    // अनसेफ मेथड: पॉइंटर्स स्वीकार करता है
    public unsafe void Swap(int* p, int* q) {
        int temp = *p;
        *p = *q;
        *q = temp;
    }
    
    public unsafe static void Main() {
        Program p = new Program();
        int var1 = 10;
        int var2 = 20;
        
        // एड्रेस-ऑफ ऑपरेटर & से पॉइंटर प्राप्त करें
        int* x = &var1;
        int* y = &var2;
        
        Console.WriteLine($"Before Swap: var1={var1}, var2={var2}");
        
        // अनसेफ मेथड कॉल
        p.Swap(x, y);
        
        Console.WriteLine($"After Swap:  var1={var1}, var2={var2}");
    }
}

आउटपुट

Before Swap: var1=10, var2=20
After Swap:  var1=20, var2=10

महत्वपूर्ण बिंदु

• unsafe कीवर्ड मेथड, टाइप, या कोड ब्लॉक पर लागू हो सकता है।
• पॉइंटर डिक्लेरेशन: int* p; (C# स्टाइल) या int *p; (C स्टाइल)।
• &variable वेरिएबल का एड्रेस देता है।
• *pointer डिरेफरेंस करता है (वैल्यू एक्सेस/मोडिफाई)।
• fixed स्टेटमेंट मूवेबल वेरिएबल्स (जैसे एरे एलिमेंट्स) को पिन करता है ताकि GC उन्हें मूव न करे।

fixed स्टेटमेंट उदाहरण

unsafe void ProcessArray(int[] arr) {
    fixed (int* p = &arr[0]) {
        // p अब पिन किए गए एरे के पहले एलिमेंट को पॉइंट करता है
        for (int i = 0; i < arr.Length; i++) {
            Console.WriteLine(p[i]);
        }
    } // fixed ब्लॉक के अंत में पिन रिलीज़
}

सेफ विकल्प: ref/out पैरामीटर्स

अधिकांश मामलों में ref/out पॉइंटर्स से सुरक्षित और पठनीय हैं:

public void Swap(ref int a, ref int b) {
    int temp = a; a = b; b = temp;
}

// कॉल
Swap(ref var1, ref var2); // कोई unsafe जरूरी नहीं

कब unsafe उपयोग करें

• नेटिव API इंटरऑप (P/Invoke)।
• उच्च-प्रदर्शन बिट मैनिपुलेशन / इमेज प्रोसेसिंग।
• मौजूदा C/C++ कोड पोर्ट करते समय।