c++ - 将 native 缓冲区包装器转换为 C++/CLI

Question

我正在尝试将 native C++ 库移植到 C++/CLI，以便我可以在 C# 中使用它。我想弄清楚如何转换一些基本上轻轻包装缓冲区以提取字段的类。我编写了一个小样本来更好地描述 API 中发生的事情。

所以，我有一个 Packet从文件中读取数据包的类:

#include <fstream>
#include <cassert>
#include "OptionalA.h"

class Packet
{
public:
    Packet(void)
    {
        buffer = new char[PACKET_SIZE];
    }
    ~Packet(void)
    {
        delete [] buffer;
    }

    void ReadNextPacket(std::ifstream& fileStream)
    {
        fileStream.read(buffer, PACKET_SIZE);
    }

    bool HasOptionalA()
    {
        return (buffer[0] & 0x1) == 1;
    }

    OptionalA GetOptionalA()
    {
        assert(HasOptionalA());
        return OptionalA(&buffer[1], &buffer[1] + OptionalA::OPTIONAL_A_SIZE);
    }

private:
    const static int PACKET_SIZE = 3;
    char* buffer;
};

Packet我创建的格式非常简单:

[Packet: <Header Byte> [OptionalA: <Field1><Field2>]]

OptionalA类定义如下:

#pragma once
#include <cassert>

class OptionalA
{
public:
    static const int OPTIONAL_A_SIZE = 2;

    OptionalA(const char* begin = 0, const char* end = 0) :
    begin(begin), end(end)
    {
        assert((end - begin) == OPTIONAL_A_SIZE);
    }

    char GetField1()
    {
        return begin[0];
    }

    char GetField2()
    {
        return begin[1];
    }

private:
    const char* begin;
    const char* end;
};

包装这种类型的类架构的正确方法是什么，以便我在 C++/CLI 中复制最少的内存？

Answer 1

一种简单的方法，但根据您必须转换的类的数量，有些耗时，是创建 CLI 包装器，其中包含指向它们包装的类型的 native 指针:

ref class FileStream
{
public:
  FileStream( String^ file ) :
    p( new std::ifstream() )
  {
    //open the stream here, if it fails throw a managed exception that makes sense
  }

    //bonus: CLI classes automatically implement IDisposable so 
    //this gets called at the end of scope with 'using( var x = new FileStream(){}'
  ~FileStream()
  {
    delete p;
  }

    //make sure to implement a finalizer to make the GC work with this class
  !FileStream()
  {
    this->~FileStream();
  }

  //not repeating all functions here, we just use this as a placeholder
  std::ifstream& Stream()
  {
    return *p;
  }

private: 
  std::ifstream* p;
}

ref class Packet
{
public:
  Packet() :
    p( new native::Packet() )
  {
  }

  //again destructor/finalizer pair

  void ReadNextPacket( FileStream^ fileStream )
  {                   
    if( fileStream == nullptr )
      throw gcnew System::ArgumentNullException( "fileStream" );
    p->ReadNextPacket( fileStream->Stream() );
  }                   

  bool HasOptionalA()
  {
    return p->HasOptionalA();
  }

  OptionalA^ GetOptionalA()
  {
    retrun gcnew OptionalA( p->GetOptionalA() );
  }

private:
  native::Packet* p;
};

ref class OptionalA
{
public:
  OptionalA( const native::OptionalA& optionalA ) :
    p( new native::OptionalA( optionalA ) )
  {
  }

  //again destructor/finalizer pair

  char GetField1()    
  {    
    return p=>GetField1();   
  }    

private:
  native::OptionalA* p;
}

为了使事情变得有趣并编写更好的代码，请考虑使用一些东西 like this而不是原始的本地指针并免费获得清理。也可以考虑使用 std::string 并传递迭代器而不是原始字符指针，毕竟它是 C++。