Procedure: Structuren marshallen met behulp van C++ Interop

In dit onderwerp ziet u één facet van visual C++-interoperabiliteit. Zie C++ Interop (impliciete PInvoke) gebruiken voor meer informatie.

In de volgende codevoorbeelden worden de beheerde, onbeheerde #pragma instructies gebruikt om beheerde en onbeheerde functies in hetzelfde bestand te implementeren, maar deze functies werken op dezelfde manier als deze zijn gedefinieerd in afzonderlijke bestanden. Bestanden met alleen niet-beheerde functies hoeven niet te worden gecompileerd met /clr (Common Language Runtime Compilation).

Voorbeeld: Structuur doorgeven van beheerde naar onbeheerde functie

In het volgende voorbeeld ziet u hoe u een structuur doorgeeft van een beheerde functie naar een onbeheerde functie, zowel op waarde als op verwijzing. Omdat de structuur in dit voorbeeld alleen eenvoudige, intrinsieke gegevenstypen bevat (zie Blittable en Non-Blittable Types), is er geen speciale marshaling vereist. Zie Instructies voor het marshallen van ingesloten pointers met C++ Interop voor het marshallen van niet-blittable structuren, zoals structuren die pointers bevatten.

// PassStruct1.cpp
// compile with: /clr

#include <stdio.h>
#include <math.h>

using namespace System;
using namespace System::Runtime::InteropServices;

#pragma unmanaged

struct Location {
   int x;
   int y;
};

double GetDistance(Location loc1, Location loc2) {
   printf_s("[unmanaged] loc1(%d,%d)", loc1.x, loc1.y);
   printf_s(" loc2(%d,%d)\n", loc2.x, loc2.y);

   double h = loc1.x - loc2.x;
   double v = loc1.y - loc2.y;
   double dist = sqrt( pow(h,2) + pow(v,2) );

   return dist;
}

void InitLocation(Location* lp) {
   printf_s("[unmanaged] Initializing location...\n");
   lp->x = 50;
   lp->y = 50;
}

#pragma managed

int main() {
   Location loc1;
   loc1.x = 0;
   loc1.y = 0;

   Location loc2;
   loc2.x = 100;
   loc2.y = 100;

   double dist = GetDistance(loc1, loc2);
   Console::WriteLine("[managed] distance = {0}", dist);

   Location loc3;
   InitLocation(&loc3);
   Console::WriteLine("[managed] x={0} y={1}", loc3.x, loc3.y);
}

Voorbeeld: Structuur doorgeven van niet-beheerde naar beheerde functie

In het volgende voorbeeld ziet u hoe u een structuur doorgeeft van een onbeheerde naar een beheerde functie, zowel op waarde als op verwijzing. Omdat de structuur in dit voorbeeld alleen eenvoudige, intrinsieke gegevenstypen bevat (zie Blittable- en Niet-Blittable-typen), is er geen speciale marshalling vereist. Zie Instructies voor het marshallen van ingesloten pointers met C++ Interop voor het marshallen van niet-blittable structuren, zoals structuren die pointers bevatten.

// PassStruct2.cpp
// compile with: /clr
#include <stdio.h>
#include <math.h>
using namespace System;

// native structure definition
struct Location {
   int x;
   int y;
};

#pragma managed

double GetDistance(Location loc1, Location loc2) {
   Console::Write("[managed] got loc1({0},{1})", loc1.x, loc1.y);
   Console::WriteLine(" loc2({0},{1})", loc2.x, loc2.y);

   double h = loc1.x - loc2.x;
   double v = loc1.y = loc2.y;
   double dist = sqrt( pow(h,2) + pow(v,2) );

   return dist;
}

void InitLocation(Location* lp) {
   Console::WriteLine("[managed] Initializing location...");
   lp->x = 50;
   lp->y = 50;
}

#pragma unmanaged

int UnmanagedFunc() {
   Location loc1;
   loc1.x = 0;
   loc1.y = 0;

   Location loc2;
   loc2.x = 100;
   loc2.y = 100;

   printf_s("(unmanaged) loc1=(%d,%d)", loc1.x, loc1.y);
   printf_s(" loc2=(%d,%d)\n", loc2.x, loc2.y);

   double dist = GetDistance(loc1, loc2);
   printf_s("[unmanaged] distance = %f\n", dist);

   Location loc3;
   InitLocation(&loc3);
   printf_s("[unmanaged] got x=%d y=%d\n", loc3.x, loc3.y);

    return 0;
}

#pragma managed

int main() {
   UnmanagedFunc();
}

Zie ook

C++ Interop gebruiken (impliciete PInvoke)