C++ 类Thunk技术示例代码使用VirtualAlloc静态函数使用类里面成员，函数指针不可以有参数，多次调用不指向同一内存

如果您希望实现一个静态函数，可以在其中使用类的成员，但函数指针不带参数，并且每次调用都指向不同的内块，可以使用lambda表达式和std::function来实现。以下是一个示例代码：

#include <iostream>
#include <Windows.h>
#include <functional>

class CallbackClass {
public:
    int memberVariable;

    static void StaticCallback() {
        // 获取类的实例指针
        CallbackClass* instance = reinterpret_cast<CallbackClass*>(GetCallbackInstance());

        // 使用类的成员
        std::cout << "Member variable: " << instance->memberVariable << std::endl;
    }

    static void* GetCallbackInstance() {
        // 通过VirtualAlloc分配新的内存块来存储类的实例指针
        LPVOID executableMemory = VirtualAlloc(NULL, sizeof(CallbackClass), MEM_COMMIT, PAGE_READWRITE);
        if (executableMemory == NULL) {
            std::cerr << "Failed to allocate executable memory!" << std::endl;
            return nullptr;
        }
        return executableMemory;
    }
};

int main() {
    // 创建一个类对象并设置成员变量
    CallbackClass instance1;
    instance1.memberVariable = 42;

    // 将类对象的指针保存在可执行的内存块中
    void* callbackInstance1 = CallbackClass::GetCallbackInstance();
    memcpy(callbackInstance1, &instance1, sizeof(CallbackClass));

    // 创建一个函数对象（lambda表达式）并绑定静态回调函数
    auto callback1 = []() {
        CallbackClass::StaticCallback();
    };

    // 调用静态回调函数
    callback1();

    // 创建另一个类对象并设置成员变量
    CallbackClass instance2;
    instance2.memberVariable = 99;

    // 将新类对象的指针保存在可执行的内存块中
    void* callbackInstance2 = CallbackClass::GetCallbackInstance();
    memcpy(callbackInstance2, &instance2, sizeof(CallbackClass));

    // 创建另一个函数对象（lambda表达式）并绑定静态回调函数
    auto callback2 = []() {
        CallbackClass::StaticCallback();
    };

    // 调用另一个静态回调函数
    callback2();

    // 释放内存
    VirtualFree(callbackInstance1, 0, MEM_RELEASE);
    VirtualFree(callbackInstance2, 0, MEM_RELEASE);

    return 0;
}

在这个示例中，我们定义了一个包含静态回调函数 `StaticCallback` 和成员变量 `memberVariable` 的 `CallbackClass` 类。静态回调函数通过获取类的实例指针来访问成员变量。

我们使用 `GetCallbackInstance` 函数通过 `VirtualAlloc` 分配一块可执行的内存，并将类的实例指针存储在其中。

然后，我们创建了两个函数对象（lambda表达式），分别绑定到不同的静态回调函数。每个函数对象都对应一个独立的内存块，其中存储了不同的类实例。

最后，我们调用这两个函数对象，分别执行不同的静态回调函数，并访问对应类的成员变量。

请注意，这个示例代码使用了lambda表达式和std::function，使得函数对象能够绑定到静态回调函数，并在调用时访问类的成员变量。在实际应用中，您可能需要考虑更多的安全性和错误处理机制。