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 = 0 ; i < 10 ; 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[0];   // 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 = 0;  
      for (int i = 0 ; 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(1) {}  
   int i;  
};  
  
ref struct H {  
   H() : j(2) {}  
   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 = 8;  
   Console::WriteLine(mt->i);  
  
   char *pc = ( char* ) pt;  
   *pc = 255;  
   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>(256);

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

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

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

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

---

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