GetProcAddress로 외부 함수를 호출하면 앱이 충돌 함

GetProcAddress 함수를 사용하여 외부 함수를 호출하려고 시도했지만 함수를 호출 할 때마다 콘솔이 충돌하고 찾고 있었지만 모든 게시물에서 동일한 최종 솔루션을 얻었지만 DLL에서 시도하면 앱이 충돌합니다. .

코드는 다음과 같습니다.

#include <Windows.h>
#include <vector>
#include "SDK\plugin.h"

typedef void (*logprintf_t)(char* format, ...);
logprintf_t logprintf;
// static void* m_AMXExports[44];

typedef bool (PLUGIN_CALL *ServerPluginLoad_t)(void **data);
typedef void (PLUGIN_CALL *ServerPluginUnload_t)();
typedef unsigned int (PLUGIN_CALL *ServerPluginSupports_t)();
typedef void (PLUGIN_CALL *ServerPluginProcessTick_t)();

typedef int (PLUGIN_CALL *ServerPluginAmxLoad_t)(AMX *amx);
typedef int (PLUGIN_CALL *ServerPluginAmxUnload_t)(AMX *amx);

struct Plugins
{
    void* AppData[256];
    SUPPORTS_FLAGS FlagSupport;
    HMODULE Module;
    ServerPluginLoad_t      LOAD;
    ServerPluginUnload_t    UNLOAD;
    ServerPluginSupports_t  SUPPORTS;
    ServerPluginProcessTick_t   PROCESSTICK;

    // AMX Plugin Interface
    ServerPluginAmxLoad_t   AMXLOAD;
    ServerPluginAmxUnload_t AMXUNLOAD;
};
Plugins* ServerPlugins;

void **ppPluginData ;

extern void *pAMXFunctions;

//native LoadLibrary(libraryname[]);
static cell AMX_NATIVE_CALL my_LoadLibrary(AMX* amx, cell* params)
{
    bool validfunc = false;
    char *path;
    amx_StrParam(amx, params[1], path);
    logprintf("Loading plugin %s", path);
    ServerPlugins = new Plugins();
    ServerPlugins->Module = LoadLibraryA(path);
    if (ServerPlugins->Module == NULL)
    {
        delete ServerPlugins;
        logprintf("Failed loading plugin %s (Error: %d)", path, GetLastError());
        return 0;
    }
    logprintf("NULL");
    ServerPlugins->LOAD = (ServerPluginLoad_t)GetProcAddress(ServerPlugins->Module, "Load");
    ServerPlugins->UNLOAD = (ServerPluginUnload_t)GetProcAddress(ServerPlugins->Module, "Unload");
    ServerPlugins->SUPPORTS = (ServerPluginSupports_t)GetProcAddress(ServerPlugins->Module, "Supports");
    if (ServerPlugins->LOAD == NULL || ServerPlugins->SUPPORTS == NULL || ServerPlugins->UNLOAD == NULL)
    {
        logprintf(" Plugin doesnt conform to architecture");
        FreeLibrary(ServerPlugins->Module);
        delete ServerPlugins;
        return false;
    }
    logprintf("NULL 1");
    ServerPlugins->FlagSupport = (SUPPORTS_FLAGS)ServerPlugins->SUPPORTS();
    if ((ServerPlugins->FlagSupport & SUPPORTS_VERSION_MASK) > SUPPORTS_VERSION)
    {
        logprintf("Unsupported Version; unloading.");
        FreeLibrary(ServerPlugins->Module);
        delete ServerPlugins;
        return false;
    }
    logprintf("NULL 2");
    if ((ServerPlugins->FlagSupport & SUPPORTS_AMX_NATIVES) > SUPPORTS_VERSION)
    {
        ServerPlugins->AMXLOAD = (ServerPluginAmxLoad_t)GetProcAddress(ServerPlugins->Module, "AmxLoad");
        ServerPlugins->AMXUNLOAD = (ServerPluginAmxUnload_t)GetProcAddress(ServerPlugins->Module, "AmxUnload");
    }
    else
    {
        ServerPlugins->AMXLOAD = NULL;
        ServerPlugins->AMXUNLOAD = NULL;
        logprintf("Any Abstract Machine has been loaded");
    }
    logprintf("NULL 3");
    if ((ServerPlugins->FlagSupport & SUPPORTS_PROCESS_TICK) != 0)
    {
        ServerPlugins->PROCESSTICK = (ServerPluginProcessTick_t)GetProcAddress(ServerPlugins->Module, "ProcessTick");
    }
    else
    {
        ServerPlugins->PROCESSTICK = NULL;
    }
    logprintf("NULL 4"); //debugging
    ServerPlugins->AppData[PLUGIN_DATA_AMX_EXPORTS] = pAMXFunctions;
    ServerPlugins->AppData[PLUGIN_DATA_LOGPRINTF] = &logprintf;
    if (!(ServerPlugins->LOAD)(ServerPlugins->AppData)) //i didnt put it as &ServerPlugins->AppData because it causes an error
    {

        logprintf("Initialized failed loading plugin %s", path);
        FreeLibrary(ServerPlugins->Module);
        logprintf("NULL 5");
        delete ServerPlugins;
        return false;
    }
    logprintf("Plugin %s loaded", path);
    return true;
}
//native UnloadLibrary(libraryname[]);
static cell AMX_NATIVE_CALL my_UnloadLibrary(AMX*amx, cell*params)
{
    char *path;
    amx_StrParam(amx, params[1], path);
    ServerPlugins->Module = GetModuleHandle((LPCTSTR)path);
    if (ServerPlugins->Module != NULL)
    {
        ServerPlugins->UNLOAD = (ServerPluginUnload_t)GetProcAddress(ServerPlugins->Module, "Unload");
        if (ServerPlugins->UNLOAD != NULL)
        {
            ServerPlugins->UNLOAD();
            FreeLibrary(GetModuleHandleA(path));
            logprintf("Library %s has been unloaded correctly", path);
            return 1;
        }
        else
        {
            logprintf("Unloading library %s failed (Error: %d)", GetLastError());
            return 0;
        }
    }
    return 1;
}

PLUGIN_EXPORT bool PLUGIN_CALL Load(void **ppData)
{
    pAMXFunctions = ppData[PLUGIN_DATA_AMX_EXPORTS];
    logprintf = (logprintf_t)ppData[PLUGIN_DATA_LOGPRINTF];
    return 1;
}

PLUGIN_EXPORT void PLUGIN_CALL Unload()
{
}

PLUGIN_EXPORT unsigned int PLUGIN_CALL Supports()
{
    return SUPPORTS_VERSION | SUPPORTS_AMX_NATIVES;
}

AMX_NATIVE_INFO projectNatives[] =
{
    { "LoadLibrary", my_LoadLibrary },
    { "UnloadLibrary", my_UnloadLibrary }
};

PLUGIN_EXPORT int PLUGIN_CALL AmxLoad(AMX *amx)
{
    return amx_Register(amx, projectNatives, -1);
}

PLUGIN_EXPORT int PLUGIN_CALL AmxUnload(AMX *amx)
{
    return AMX_ERR_NONE;
}