垃圾收集器会删除导出到C＃的C ++类吗？

Question

The idea is to create and export a wrapper for the C++ class and then use it from C# like following:

First, let us create the C++ class itself:

File : MyClass.cpp

class myclass
{
public:

    int funct(int val)
    {
       return val + 1;
    }

 ~myclass(){}
};

Then, we create a wrapper:

File wrapper.cpp

extern "C" __declspec(dllexport) myclass* expConst()
{
    return new myclass();
}

extern "C" __declspec(dllexport) void expDispose(myclass * obj)
{
    delete obj;
}

extern "C" __declspec(dllexport) int expfunct(myclass* obj, int val)
{   
    return obj->funct(val);
}

Now, we come to c#:

public class CsClass : IDisposable
{
    //Import the functions from dll

    [DllImport("ExportedLib.dll")]
    public static extern IntPtr expDispose(IntPtr obj);

    [DllImport("ExportedLib.dll")]
    public static extern IntPtr expConst();

    [DllImport("ExportedLib.dll")]
    public static extern int expfunct(IntPtr obj, int val);

    IntPtr objPtr;
    public CsClass()
    {
        objPtr = expConst();
    }

    public int funct(int q)
    {
        return expfunct(objPtr, q);
    }

    public void Dispose()
    {
        expDispose(objPtr);
    }
}

Finally, we ecxecute this by File:Program.cs

class Program
{
    static void Main(string[] args)
    {
        CsClass v = new CsClass();
        Console.WriteLine(v.Func(1));
    }
}

I tested this simple things and the program printed 2 as it was expected.

The question is, whether the garbage collector of C# will move the created C++ object and, thus, making the objPtr to point to some wrong place in memory?

Are there any other principal obstacles here? I mean some unsolvable problems which make such an approach impossible.

Thanks in advance.

Answer 1

No, the garbage collector only goes to work for managed memory. Your class created in C++ is not managed memory and will not be touched, for good or for bad. You will need to manage it yourself as you already did.