Cómo: serializar estructuras mediante la interoperabilidad de C++

En este tema se muestra una faceta de la interoperabilidad de Visual C++. Para más información, consulte Uso de la interoperabilidad de C++ (PInvoke implícito).

En los ejemplos de código siguientes se usan las directivas de #pragma managed, unmanaged para implementar funciones administradas y no administradas en el mismo archivo, pero estas funciones interoperan de la misma forma si se definen en archivos independientes. Los archivos que contienen solo funciones no administradas no tienen que compilarse con /clr (compilación de Common Language Runtime).

Ejemplo: Pasar estructura de una función administrada a una no administrada

El siguiente ejemplo demuestra el paso de una estructura desde una función administrada a una no administrada, tanto por valor como por referencia. Dado que la estructura de este ejemplo solo contiene tipos de datos intrínsecos simples (vea Tipos que pueden o que no pueden transferirse en bloque de bits), no se requiere ninguna serialización especial. Para serializar estructuras que no pueden transferirse en bloque de bits, como las que contienen punteros, vea Cómo: Serializar punteros insertados mediante la interoperabilidad de C++.

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

Ejemplo: Pasar estructura de una función no administrada a una administrada

El siguiente ejemplo demuestra el paso de una estructura desde una función no administrada a una administrada, tanto por valor como por referencia. Dado que la estructura de este ejemplo solo contiene tipos de datos intrínsecos simples (vea Tipos que pueden o que no pueden transferirse en bloque de bits), no se requiere ninguna serialización especial. Para serializar estructuras que no pueden transferirse en bloque de bits, como las que contienen punteros, vea Cómo: Serializar punteros insertados mediante la interoperabilidad de C++.

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

Consulte también

Usar la interoperabilidad de C++ (PInvoke implícito)