c++ - 阿格!反差挫败回调阴谋!想要更改虚拟返回类型

Question

我正在研究一个 AI 动态链接库。它将被显式链接，所有这些都由一个简单的头文件包含处理。

我目前正在尝试为 DLL 创建代码，以便能够调用主 EXE 中的函数来操纵世界，并且能够查询函数以了解世界的状态。我现在可以在没有参数的情况下调用 void 返回函数(无论是全局函数还是成员函数)。

我现在正在尝试实现在 EXE 中调用函数并从中获取返回值的能力。 (非空函数)事情进展不顺利..我已经尝试了一段时间，现在试图找到实现它的最佳方法。我可以在 DLL 中使用 boost 库，但不能在 EXE 中使用。

我将在这里转储相关代码。我知道很多，但我希望有人能够指出我如何改进。

即使您不阅读代码(非常容易理解)，了解您将如何从一般角度解决这个问题也会非常有帮助。

这里是(我已尝试尽可能多地删除不相关的代码部分):

------------------------------------EXE 侧头---- ----------------------------------

typedef void (*Command)();
typedef void (*CommandMF)(int, std::string);

typedef void (*AddEntityFunction)(int&);
typedef void (*AddActionToEntityFunction)(int, Command);
typedef void (*AddActionToEntityFunctionMF)(int, CommandMF, std::string);
typedef void (*UpdateDoubleThinkFunction)();


class MemberFunctionStorageExecute
{
    public:
        virtual void Execute() const =0;
    };


template <class T>
struct MemberFunctionStorage : MemberFunctionStorageExecute
{
    typedef void (T::*MemberFunctionWorker)();

        MemberFunctionWorker mbw;
    T *obj;

    virtual void Execute() const
{
    (obj->*mbw)();
}
};

typedef std::map<std::string, MemberFunctionStorageExecute*> MemberFunctionsList;
typedef std::map<int, MemberFunctionsList*> ListofLists;


//Template hack to allow static properties inside header
template <class T>
class DoubleThinkInterfaceImpl
{
protected: 
    static HINSTANCE hinstDLL;
    static AddEntityFunction DLLAddEntity;
    static AddActionToEntityFunction DLLAddActionToEntity;
    static AddActionToEntityFunctionMF DLLAddActionToEntityMF;
    static UpdateDoubleThinkFunction DLLUpdateDoubleThink;

    static ListofLists m_plistlist;
};
template <class T>
HINSTANCE DoubleThinkInterfaceImpl<T>::hinstDLL;
template <class T>
AddEntityFunction DoubleThinkInterfaceImpl<T>::DLLAddEntity;
template <class T>
UpdateDoubleThinkFunction DoubleThinkInterfaceImpl<T>::DLLUpdateDoubleThink;
template <class T>
AddActionToEntityFunction DoubleThinkInterfaceImpl<T>::DLLAddActionToEntity;
template <class T>
AddActionToEntityFunctionMF DoubleThinkInterfaceImpl<T>::DLLAddActionToEntityMF;
template <class T>
ListofLists DoubleThinkInterfaceImpl<T>::m_plistlist;



class DoubleThinkInterface : protected DoubleThinkInterfaceImpl<int>
{
private:
    int m_pid;
    MemberFunctionsList m_pmemfunlist;


public:
    int ID()
    {
        return m_pid;
    }

    DoubleThinkInterface()
    {
        if(!hinstDLL)
        {
            hinstDLL = LoadLibrary("DoubleThink.dll");
            DLLAddEntity = (AddEntityFunction)GetProcAddress(hinstDLL, "AddEntity");
            DLLUpdateDoubleThink = (UpdateDoubleThinkFunction)GetProcAddress(hinstDLL, "Update");
            DLLAddActionToEntity = (AddActionToEntityFunction)GetProcAddress(hinstDLL, "AddActionToEntity");
            DLLAddActionToEntityMF = (AddActionToEntityFunctionMF)GetProcAddress(hinstDLL, "AddActionToEntityMF");
        }
        DLLAddEntity(m_pid);
        DoubleThinkInterface::m_plistlist.insert(std::pair<int, MemberFunctionsList*>(m_pid, &m_pmemfunlist));
    }

    ~DoubleThinkInterface()
    {
        //if(hinstDLL != 0)
        //  FreeLibrary(hinstDLL);
    }

    void AddAction(Command action)
    {
        DLLAddActionToEntity(m_pid, action);
    }

    void Update()
    {
        DLLUpdateDoubleThink();
    }

    template <class T>
    void AddActionMF(T *object, void (T::*memberfunc)(), std::string actionName)
    {
        MemberFunctionStorage<T> *store = new MemberFunctionStorage<T>;
        store->mbw = memberfunc;
        store->obj = object;
        m_pmemfunlist.insert(std::pair<std::string, MemberFunctionStorageExecute*>(actionName, store));
        DLLAddActionToEntityMF(m_pid, &DoubleThinkInterface::ResolveMF, actionName);
    }

    static void ResolveMF(int idnum,std::string mfName)
    {
        ListofLists::iterator lit;
        lit = m_plistlist.find(idnum);
        MemberFunctionsList::iterator it;
        it = lit->second->find(mfName);
        it->second->Execute();
    }
};

----------------------------EXE端示例------------ --------------------------

class BaseEntity
{
public:
    DoubleThinkInterface dtInterface;
    BaseEntity(){}
    virtual ~BaseEntity(){}
};

class Humanoid : public BaseEntity
{
public:
    Humanoid(){}
    ~Humanoid(){}

    std::string name;

    void Move();

    int GetAge(){return 10;}
};

void Humanoid::Move()
{
    std::cout << name << ": I'm moving around and such \n";
}

void EndLifeAsWeKnowIt()
{
    cout << "Suddenly everything changed... \n";
}

int _tmain(int argc, _TCHAR* argv[])
{
    Humanoid *entity = new Humanoid();
    entity->name = "Bobby";
    entity->dtInterface.AddAction(&EndLifeAsWeKnowIt);
    entity->dtInterface.AddActionMF<Humanoid>(entity, &Humanoid::Move, "Move");

    entity->dtInterface.Update();

    int x; cin >> x;

    return 0;
}

------------------------DLL端代码---------------- ------------------

DTEntityManager* DTEntityManager::Instance()
{
    static DTEntityManager instance;

    return &instance;
}

template<class T>
void AddAction(int id, void (*comm)(int, std::string), std::string mfid)
{
    DTEntity *ent = DTEntityManager::Instance()->GetEntityFromID(id);

    CommandMemberFunction<T> *newcomm = new CommandMemberFunction<T>();
    newcomm->comm = comm;
    newcomm->entityid = id;
    newcomm->mfid = mfid;

    ent->SetCommandMF(newcomm);
}

extern "C"
{
    DLL_EXPORT void AddEntity(int &idnumber)
    {
        DTEntity *entity = new DTEntity();
        idnumber = entity->ID();
        DTEntityManager::Instance()->RegisterEntity(entity);
    }

    DLL_EXPORT void AddActionToEntity(int id, void (*comm)())
    {
        DTEntity *ent = DTEntityManager::Instance()->GetEntityFromID(id);

        CommandGlobal<void> *newcomm = new CommandGlobal<void>();
        newcomm->comm = comm;

        ent->SetCommand(newcomm);
    }

    DLL_EXPORT void AddActionToEntityMF(int id, void (*comm)(int, std::string), std::string mfid)
    {
        AddAction<void>(id, comm, mfid);
    }

    DLL_EXPORT void AddActionToEntityMF_int(int id, void (*comm)(int, std::string), std::string mfid)
    {
        AddAction<int>(id, comm, mfid);
    }
}

------------------------DLL 端用于保持回调的结构------------ --------------

class CommandBase
{
public:
    virtual void Execute() const =0;
};

template<class T>
struct CommandGlobal : CommandBase
{
    typedef boost::function<T ()> Command;
    Command comm;

    virtual T Execute() const
    {
        return comm();
    }
};

template<class T>
struct CommandMemberFunction : CommandBase
{
    typedef boost::function<T (int, std::string)> Command;
    Command comm;
    int entityid;
    std::string mfid;

    virtual T Execute() const
    {
        return comm(entityid, mfid);
    }
}; 

由于这一行，目前 DLL 无法编译:

AddAction<int>(id, comm, mfid);

因为它试图覆盖

virtual void Execute() const =0;

带有返回 int 的函数。给出非协方差错误。我知道我找错了树，但目前我也看不到任何其他解决方案。

有没有人对如何做得更好有任何建议？即使它只是一个模糊的方向，我也应该将注意力集中在我会很感激。如果您愿意阅读所有这些内容，非常感谢!

Answer 1

我觉得你太复杂了。看这个:

/*************** both ***************/
typedef void (*Prototype1)();
typedef void (*Prototype2)(int);
typedef int (*Prototype3)();

struct FuncList {
    Prototype3 func1;
    Prototype1 func2;
    Prototype1 func3;
    Prototype2 func4;
    Prototype1 func5;
    // ...
};

/*************** dll ***************/

FuncList func_list;

Prototype3 &func1 = func_list.func1;
Prototype1 &func2 = func_list.func2;
Prototype1 &func3 = func_list.func3;
Prototype2 &func4 = func_list.func4;
Prototype1 &func5 = func_list.func5;

/* DLLEXPORT */ void SetFuncList(const FuncList &list) { func_list = list; }

void UsageExample()
{
    /* Just call the function */
    func2();
}

/*************** exe ***************/

/* declarations (functions must be defined somewhere) */
int func1();
void func2();
void func3();
void func4(int);
void func5();

const FuncList func_list = {
    func1,
    func2,
    func3,
    func4,
    func5
};

typedef void (*SetFuncListProc)(const FuncList &list);
SetFuncListProc SetFuncList;

void Init()
{
    /* ... load the DLL, load "SetFuncList" ... */

    SetFuncList(func_list);
}