सी ++/सीएलआई में, मैं एक 'आउट' पैरामीटर के साथ फ़ंक्शन कैसे घोषित और कॉल करूं?

Question

मेरे पास एक ऐसा फ़ंक्शन है जो एक स्ट्रिंग को दो तारों में पार करता है। सी # में मैं इसे इस तरह घोषणा करेंगे:

void ParseQuery(string toParse, out string search, out string sort) 
{ 
    ... 
} 

और मैं इसे इस तरह फोन चाहते हैं:

string searchOutput, sortOutput; 
ParseQuery(userInput, out searchOutput, out sortOutput); 

चालू परियोजना C++/CLI में किया जा सकता है। मैं

using System::Runtime::InteropServices; 

... 

void ParseQuery(String^toParse, [Out] String^ search, [Out] String^ sort) 
{ 
    ... 
} 

की कोशिश की है, लेकिन अगर मैं इसे इस तरह कहते हैं:

String^searchOutput,^sortOutput; 
ParseQuery(userInput, [Out] searchOutput, [Out] sortOutput); 

मैं एक संकलक त्रुटि मिलती है, और अगर मैं इस तरह इसे कहते: तो

String^searchOutput,^sortOutput; 
ParseQuery(userInput, searchOutput, sortOutput); 

मैं रनटाइम पर एक त्रुटि। मुझे अपने फ़ंक्शन को कैसे घोषित और कॉल करना चाहिए?

Answer 1

सी ++/सीएलआई स्वयं वास्तविक 'आउट' तर्क का समर्थन नहीं करता है, लेकिन आप संदर्भ को एक तर्क के रूप में चिह्नित कर सकते हैं ताकि अन्य भाषाओं को इसे वास्तविक तर्क के रूप में देखा जा सके।

आप संदर्भ प्रकार के लिए ऐसा कर सकते हैं के रूप में:

void ReturnString([Out] String^% value) 
{ 
    value = "Returned via out parameter"; 
} 

// Called as 
String^ result; 
ReturnString(result); 

और मूल्य प्रकार के लिए के रूप में:

void ReturnInt([Out] int% value) 
{ 
    value = 32; 
} 

// Called as 
int result; 
ReturnInt(result); 

% यह एक 'रेफरी' पैरामीटर बनाता है और OutAttribute के निशान है कि यह केवल है आउटपुट मूल्यों के लिए प्रयोग किया जाता है।

Answer 2

यह समर्थित नहीं है। निकटतम आप प्राप्त कर सकते हैं

माना जाता है कि आप इसे नकली बना सकते हैं, लेकिन आप एक संकलन समय की जांच खो देते हैं।

Answer 3

विजुअल स्टूडियो 2008 का उपयोग करके, यह काम करता है और मेरे काम पर एक बड़ी समस्या हल करता है। धन्यवाद!

// header 
// Use namespace for Out-attribute. 
using namespace System::Runtime::InteropServices; 
namespace VHT_QMCLInterface { 
    public ref class Client 
    { 
    public: 
     Client(); 
     void ReturnInteger(int a, int b, [Out]int %c); 
     void ReturnString(int a, int b, [Out]String^ %c); 
    } 
} 

// cpp 
namespace VHT_QMCLInterface { 

    Client::Client() 
    { 

    } 

    void Client::ReturnInteger(int a, int b, [Out]int %c) 
    { 
     c = a + b; 
    } 
    void Client::ReturnString(int a, int b, [Out]String^ %c) 
    { 
     c = String::Format("{0}", a + b); 
    } 
} 

// cs 
namespace TestQMCLInterface 
{ 
    class Program 
    { 
     VHT_QMCLInterface.Client m_Client = new VHT_QMCLInterface.Client(); 
     static void Main(string[] args) 
     { 
      Program l_Program = new Program(); 
      l_Program.DoReturnInt(); 
      l_Program.DoReturnString(); 
      Console.ReadKey(); 
     } 

     void DoReturnInt() 
     { 
      int x = 10; 
      int y = 20; 
      int z = 0; 
      m_Client.ReturnInteger(x, y, out z); 
      Console.WriteLine("\nReturnInteger: {0} + {1} = {2}", x, y, z); 
     } 

     void DoReturnString() 
     { 
      int x = 10; 
      int y = 20; 
      String z = "xxxx"; 
      m_Client.ReturnString(x, y, out z); 
      Console.WriteLine("\nReturnString: {0} + {1} = '{2}'", x, y, z); 
     } 
    } 
}