不能伪造来自 c++ 的托管回调（不能通过 static_cast 从 'void (GenFlowcacheTests::*)(int)' 转换为 'void(*)(int)'）

Question

I define a pointer to a managed function with:

typedef void(__stdcall* CounterCallback)(int count);

then I'll define a c++ method:

void CBSpline::GenFlowcache(/*few irrelevant parameters*/, CounterCallback func)
{/*instructions*/}

And in a unit test, I want to test GenFlowcache with a native function.

int _flowCount{};
auto Increment(int value) -> void { _flowCount = value; }

TEST_METHOD(Gen_CallbackTest)
{
    // ...
    sut.GenFlowcache(/**/, static_cast<CounterCallback>(GenFlowcacheTests::Increment));
}

But I cannot find a way to cast the method:

cannot cast from 'void (GenFlowcacheTests::*)(int)' to 'void(*)(int)' via static_cast

( Compiler Error C2440 )

How can I pass a native function (method, lambda etc) as CounterCallback ?

It is not useful for the problem, but the managed part is as such:

public delegate void CounterCallback(int value);

public static class CBSplines
{
    [DllImport("CubicBSplines.dll", CallingConvention = CallingConvention.StdCall)]
    internal static extern unsafe void GenFlowcache(IntPtr p, BroxParam* broxParam, IntPtr sourceDir, IntPtr targetDir, CounterCallback counter);
}

Then in a managed class:

private CounterCallback _counter;

public unsafe void GenerateFlowcache(BroxParam parameters, string sourceDir, string targetLocalDir)
{
    if (_counter is null)
        _counter = CounterUpdated;
    if (!Directory.Exists(targetLocalDir))
        Directory.CreateDirectory(targetLocalDir);
    var strSrcDir = Marshal.StringToHGlobalAuto(sourceDir);
    var strTgtDir = Marshal.StringToHGlobalAuto(targetLocalDir);
    CBSplines.GenFlowcache(_ptr, &parameters, strSrcDir, strTgtDir, _counter);
    Marshal.FreeHGlobal(strSrcDir);
    Marshal.FreeHGlobal(strTgtDir);
}

protected void CounterUpdated(int value) => FlowcacheCounter = value;

And back in native:

#ifndef Pinvoke
#define Pinvoke extern "C" __declspec(dllexport)
#endif

Pinvoke auto GenFlowcache(CBSpline* p, BroxParam* param, const wchar_t* sourceDir, const wchar_t* targetDir, CounterCallback func)
-> void { p->GenFlowcache(param, sourceDir, targetDir, func); }

Answer 1

As pointed by john:

You can pass a function or static method typed void(int) you can also pass a non-capturing lambda with the same signature, and that's it.You can't pass a class method however it is typed

I can pass a global function:

int _flowCount{};
auto Increment(int value) -> void { _flowCount = value; }

that will be passed in the test method:

sut.GenFlowcache(/**/, (CounterCallback)Increment);