En C ++ / CLI, comment déclarer et appeler une fonction avec un paramètre 'out'?

Question

J'ai une fonction qui analyse une chaîne en deux chaînes. En C #, je le déclarerais comme ceci:

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

et je l'appellerais comme ça:

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

Le projet actuel doit être réalisé en C ++ / CLI. J'ai essayé

using System::Runtime::InteropServices;

...

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

mais si j'appelle ça comme ça:

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

Je reçois une erreur du compilateur, et si je l'appelle comme ceci:

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

alors je reçois une erreur au moment de l'exécution. Comment dois-je déclarer et appeler ma fonction?

Answer 1

C ++ / CLI lui-même ne prend pas en charge un véritable argument 'out', mais vous pouvez marquer une référence en tant qu'argument out pour que les autres langues le voient comme un argument out réel.

Vous pouvez le faire pour les types de référence en tant que:

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

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

Et pour les types de valeur tels que:

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

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

Le% en fait un paramètre 'ref' et le OutAttribute indique qu'il n'est utilisé que pour les valeurs de sortie.

Answer 2

Grâce à Visual Studio 2008, cela fonctionne et résout un problème majeur dans mon travail. Merci!

// 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);
        }
     }
}

Answer 3

Ce n'est pas pris en charge. Le plus proche que vous pouvez obtenir est ref

Certes, vous pouvez le simuler, mais vous perdez une vérification du temps de compilation.