Конвертировать шаблон C ++ в C #

Question

У меня есть шаблон в проекте c ++, и я хочу перевести код на c # сейчас, и я получаю некоторые ошибки в шаблоне c #.

В С ++

    template<typename T>
struct pares
{
    DWORD64 first;
    T* second;
};
template<typename T>
struct hash_node
{
    pares<T> mValue;
    hash_node<T>* mpNext;
};

template<typename T>
struct hashtable
{
    DWORD64 vtable;
    hash_node<T>** mpBucketArray;
    unsigned int mnBucketCount;
    unsigned int mnElementCount;
    //...
};

template<typename T>
struct hashtable_iterator
{
    hash_node<T>* mpNode;
    hash_node<T>** mpBucket;
};

In C #

    public class pair<T>
{
    public Int64 first;
    public T second;
}

public class hash_node<T> 
{
    public pair<T> mValue = new pair<T>();
    public hash_node<T> mpNext;
}


public class hashtable<T>
{
    public Int64 vtable;
    public hash_node<T>[] mpBucketArray;
    public int mnBucketCount;
    public int mnElementCount;

}
public class hashtable_iterator<T>
{
    public hash_node<T> mpNode;
    public hash_node<T> mpBucket;
}

Внутри функции в проекте C ++ у меня есть эта строка, нормально без ошибок:

hashtable<DWORD64>* table = (hashtable<DWORD64>*)(pObfuscationMgr + 8);

Но в C # получается ошибка:

Невозможно преобразовать тип 'long' в 'hashtable'

 hashtable<Int64> table =  (hashtable<Int64>)(pObfuscationMgr + 8);

Answer 1

Причина ошибки в том, что вы говорите компилятору интерпретировать позицию в памяти как объект hashtable<>.Это работает в C ++, потому что у вас есть инструмент для этого: указатели.Указатель - это просто позиция памяти со связанным типом.

У вас есть блок памяти, на который указывает pObfuscationMgr, и вы намереваетесь создать указатель на hashtable<>, и таким образом вы понимаете содержимое этой памятипозиция (плюс восемь) как hashtable<>.

Если вы выполняете дословный перевод на C #:

hashtable<Int64> table =  (hashtable<Int64>)(pObfuscationMgr + 8);

Указатели теряются в этом переводе, потому что в C # нет указателей.Итак, теперь pObfuscationMgr теперь просто long, и, следовательно, ошибка компилятора: вы не можете преобразовать long в hashtable<>.

Например, вы можете сделать это на C или C ++:

void foo()
{
    char buffer[1024];
    int * ptr1 = (int *) &buffer;
    int * ptr2 = (int *) ( &buffer + 8 );


    *ptr1 = 40;
    *ptr1 += 2;

    *ptr2 = 5;
    *ptr2 *= 2;

    printf( "%d\n", *ptr1 ); 
    printf( "%d\n", *ptr2 ); 
}

В приведенном выше коде вы создаете область буферизации в стеке в виде массива char.Затем вы создаете указатели ptr1 и ptr2 и заставляете их указывать на начало этой области и на начало этой области плюс восемь.Тогда вы можете управлять обоими указателями, как если бы они указывали на реальные переменные.Это более или менее похоже на то, что делает исходный код.

Вы не добьетесь успеха, выполнив дословный перевод кода C ++ в C #.Конечно, этот перевод выполним, но он обладает глубокими знаниями о памяти в C ++ и о том, как представить ее в C #, т. Е. О реальном переводе.

Надеюсь, это (как-то) поможет.