C++/CLI剪辑

1.本地类中包含托管类成员变量的情况

 #include<vcclr.h>     // 必须包含vcclr.h头文件

 //传入

 A^ a = gcnew A();

 gcroot<A^> *pA = new gcroot<A^>();

 *pA = a;

 void *ptr = pA;

 B *b = new B(pA);  //c++类

 //还原

 gcroot<A^> *  m_pA = (gcroot<A^> *)pA；

 (*m_pA)->FuncA(); //可调用A类接口；

2.pin_ptr是防止您的对象移动将在垃圾回收堆的内部指针. 也就是说钉住指针的值不是由公共语言运行时更改. 当向非托管函数传递托管类的地址时，这很有用，因为在解析非托管函数调用的过程中，该地址不会意外更改.

pin_ptr无法使用情况(在pin_ptr的生命周期内有效)：

• • 函数参数

  • 作为函数的返回类型。

  • 类成员的声明

  • 目标的类型约束。

pin_ptr 数组的第一个元素的位置

 // pin_ptr_1.cpp
 // compile with: /clr
 using namespace System;
 #define SIZE 10  

 #pragma unmanaged
 // native function that initializes an array
 void native_function(int* p) {
    for(int i =  ; i <  ; i++)
     p[i] = i;
 }
 #pragma managed  

 public ref class A {
 private:
    array<int>^ arr;   // CLR integer array  

 public:
    A() {
       arr = gcnew array<int>(SIZE);
    }  

    void load() {
    pin_ptr<int> p = &arr[];   // pin pointer to first element in arr
    int* np = p;   // pointer to the first element in arr
    native_function(np);   // pass pointer to native function
    }  

    int sum() {
       int total = ;
       for (int i =  ; i < SIZE ; i++)
          total += arr[i];
       return total;
    }
 };  

 int main() {
    A^ a = gcnew A;
    a->load();   // initialize managed array using the native function
    Console::WriteLine(a->sum());
 }  

内部指针转换为钉住的指针，并且，类型为返回 address-of 运算符 (&) 是内部指针，当操作数在托管堆时

 // pin_ptr_2.cpp
 // compile with: /clr
 using namespace System;  

 ref struct G {
    G() : i() {}
    int i;
 };  

 ref struct H {
    H() : j() {}
    int j;
 };  

 int main() {
    G ^ g = gcnew G;   // g is a whole reference object pointer
    H ^ h = gcnew H;  

    interior_ptr<int> l = &(g->i);   // l is interior pointer  

    pin_ptr<int> k = &(h->j);   // k is a pinning interior pointer  

    k = l;   // ok
    Console::WriteLine(*k);
 };  

钉住的指针转换为另一种类型

 // pin_ptr_3.cpp
 // compile with: /clr
 using namespace System;  

 ref class ManagedType {
 public:
    int i;
 };  

 int main() {
    ManagedType ^mt = gcnew ManagedType;
    pin_ptr< int > pt = &mt->i;
    *pt = ;
    Console::WriteLine(mt->i);  

    char *pc = ( char* ) pt;
    *pc = ;
    Console::WriteLine(mt->i);
 }  

3.char * to array<unsigned char^>

 #pragma unmanaged

 void work_with_native_buffer(char* pBuffer, size_t size) {
     // Do your unmanaged stuff here
 }

 #pragma managed

 ref class Test {
 public:
     void DoNativeStuff() {
         if (_buffer == nullptr)
             _buffer = gcnew array<unsigned char>();

         pin_ptr<int> pinnedBuffer = &_buffer[];
         char* pBuffer = pinnedBuffer;
         work_with_native_buffer(pBuffer, _buffer->Length);
     }

     void SendData(Stream^ stream) {
         Debug.Assert(_buffer != nullptr);

         stream->Write(_buffer, , _buffer->Length);
     }

 private:
     array<unsigned char>^ _buffer;
 };

---

使用 C++/CLI (Visual C++) 进行 .NET 编程