Каковы текущие наилучшие варианты для параллелизации интенсивного ЦП приложения.NET? [закрытый]

Насколько я вижу, нет способа привести статическую функцию-член к указателю на функцию-член, чтобы разрешить перегрузку универсальным способом или любым другим прямым подходом.
Получение подсказки от Jarod42 дает следующее решение с косвенным обращением через некоторый прокси-класс, функцию или в данном случае лямбду (если оно не захватывает):

#include 


using namespace std;


struct A {
    int mem(int a) {
        return a * 2;
    };
    int mem(int a, int b) {
        return a + b;
    }
    static int stat(int a) {
        return a * 2;
    }
    static int stat(int a, int b) {
        return a + b;
    }
};


static A a;


int main() {
    typedef int(*type1)(int);
    typedef int(*type2)(int, int);

    cout << "a.mem(1) -> " << a.mem(1) << endl;
    cout << "a.mem(1, 2) -> " << a.mem(1, 2) << endl;
    cout << "A::stat(1) -> " << A::stat(1) << endl;
    cout << "A::stat(1, 2) -> " << A::stat(1, 2) << endl;
    cout << "a.stat(1) -> " << a.stat(1) << endl;
    cout << "a.stat(1, 2) -> " << a.stat(1, 2) << endl;

    cout << "----------------------------------" << endl;

    type1 aMem1 = [] (int a0) -> int { return a.mem(a0); };
    cout << "aMem1(1) -> " << aMem1(1) << endl;
    type2 aMem2 = [] (int a0, int a1) -> int { return a.mem(a0, a1); };
    cout << "aMem2(1, 2) -> " << aMem2(1, 2) << endl;
    type1 stat1 = [] (int a0) -> int { return A::stat(a0); };
    cout << "stat1(1) -> " << stat1(1) << endl;
    type2 stat2 = [] (int a0, int a1) -> int { return A::stat(a0, a1); };
    cout << "stat2(1, 2) -> " << stat2(1, 2) << endl;
    type1 aStat1 = [] (int a0) -> int { return a.stat(a0); };
    cout << "aStat1(1) -> " << aStat1(1) << endl;
    type2 aStat2 = [] (int a0, int a1) -> int { return a.stat(a0, a1); };
    cout << "aStat2(1, 2) -> " << aStat2(1, 2) << endl;

    return 0;
}

См. live [111 ] пример.

Это позволяет использовать исходную проблему, используя то же соглашение о вызовах, что и для пользователя. Это означает, что если пользователь может вызывать функцию-член (статическую или нет) таким образом, мы также используем то же соглашение о вызовах. Можно использовать указатели на функции-члены, используя вместо этого прокси-класс. Для меня лямбда-подход работал лучше.