Read Write C++ Dynamic Arrays in C# (InteropServices)

Question

I have a C++ class which has a header(matrixheader.h) such that :

#pragma once

class M
{
    public:
        M(int m,int n);
        void MSet(int m,int n,double d);
        double MGet(int m,int n);
        ~M();
    private:
        double** mat;
};

Class is defined as follows in (matrixbody.cpp):It is built in Win32 Platform.

#pragma once
#include "matrixhead.h"

M::M(int m,int n)
{
  mat = new double*[m];
  for (int i = 0; i < m; i++)
  {
    mat[i] = new double[n];
  }
}

void M::MSet(int m,int n,double d)
{
    mat[m][n] = d;
}

double M::MGet(int m,int n)
{
    double d = mat[m][n];
    return d;
}

M::~M()
{
    delete[] mat;
}

I have made a wrapper for the Class like so(matrixwrapper.cpp):The wrapper is also built in Win32 platform.

#include "matrixhead.h"
#include "matrixbody.cpp"

extern "C" __declspec(dllexport) void* Make(int m,int n)
{
    M o(m,n);
    return &o;
}

extern "C" __declspec(dllexport) void setData(void* mp,int m,int n,double d)
{
    M* ap = (M*)mp;
    M a = *ap;
    a.MSet(m,n,d);
}

extern "C" __declspec(dllexport) double getData(void* mp,int m,int n)
{
    M* bp = (M*)mp;
    M b = *bp;
    double d = b.MGet(m,n);
    return d;
}

I import the class to C# and try to call the C++ dl methods from C#:

using System;
using System.Runtime.InteropServices;


namespace wrappertest
{
 class Program
   {
    [DllImport("matrixwrapper.dll")]
    unsafe public static extern void* Make(int m,int n);

    [DllImport("matrixwrapper.dll")]
    unsafe public static extern void setData(void* mp,int m, int n,double d);

    [DllImport("matrixwrapper.dll")]
    unsafe public static extern double getData(void* mp,int m, int n);

    static unsafe void Main(string[] args)
    {
        void* p = Make(10, 10);
        setData(p,10,1,10);
        Console.WriteLine(getData(p,10,1));
    }
  }
}

But when i try to run the C++ dll methods from C# i get the following error

1//Attempted to read or write protected memory.This is often an indication that other memory is corrupt when running C# code in x64.

2//An attempt was made to load a program with incorrect format when runnning in x86 Active/x86 or in AnyCPU platform.

Questions:

1//What is wrong in the above code ?

2//Considering that my final objective is to make a 2d dynamic array in C++ and read/write data in the array such as the one double**mat in the matrixheader.h file above from C#?is there any other way to implement it ?

Answer 1

Let's get the easy thing first:

An attempt was made to load a program with incorrect format when runnning in x86 Active/x86 or in AnyCPU platform.

This simply means you have a platform mismatch. You're either trying to load an x86 C++ dll in an x64 .NET runtime, or the reverse.

The following error is the real problem:

Attempted to read or write protected memory.This is often an indication that other memory is corrupt when running C# code in x64.

That's to be expected, because your Make function creates an object on the stack, then returns a pointer to it. By the time you read back this object, the contents on the stack has changed (the stack is being reused), and the mat pointer points somewhere else, most probably into unallocated memory.

Please see this answer where I go into deeper detail about this issue (it's C# but it's the same issue).

You have to allocate some dynamic memory to solve your problem. You may try:

extern "C" __declspec(dllexport) void* Make(int m,int n)
{
    M* o = new M(m,n);
    return o;
}

And of course, you'll have to create one more method to perform the matching delete if you don't want to leak memory.

Also, like Mgetz points out in the comments, you have a memory leak in the M class itself. The delete[] mat; call in the destructor won't free every allocated chunk of memory. You're calling new in the constructor m + 1 times, this means you have to call delete[] m + 1 times also in the destructor, once for each new. You probably should keep m and n as fields in your class (at least m is mandatory to know how many calls to delete[] you have to do).

A much better solution would be to use a single array instead of jagged arrays. You calculate the index i, j in that array as i * m + j. You may also use a std::vector or just do it in C# altogether:

public class M
{
    private double[] _items;
    private int _m;
    private int _n;

    public M(int m, int n)
    {
        _items = new double[m * n];
        _m = m;
        _n = n;
    }

    public this[int i, int j]
    {
        // Here, you should perform a bounds check on i and j against _m and _n
        get { return _items[i * _m + j]; }
        set { _items[i * _m + j] = value; }
    }
}