我正在编写一个模拟，其中各种代理相互作用和相互影响，代码目前的结构是这样的，所有具体的类继承自一个或多个类，定义什么行为可用于每个代理示例（如“交易者”或“谈话者”类），这些行为类也几乎继承自一个代理基类，定义行为和数据共同的所有代理。这是最终系统的简单模型

class agent {
    protected:
        int health;
        int mood;
        string name;
        vector<string> memories;
    public:
        agent(string name) {
            this->name = name;
            health = 20;
            mood = 0;
        }

        string getName() {
            return name;
        }

        void makeMemory(string memory) {
            memories.push_back(memory);
        }

        void takeDamage(int damage) {
            health -= damage;
        }

        void affectMood(int effect) {
            mood += effect;
        }
        
};

class fighter : public virtual agent {
    protected:
        int damage;
    public:
        virtual void attack(fighter* other) = 0;
};

class talker : public virtual agent {
    public:
        virtual void talk(talker* other) = 0;
};

struct item {
    string name;
    int value;
};

class trader : public virtual agent {  
    protected: 
        int money;
        map<string, item> inventory;
    public:
        bool spendMoney(int spend) {
            if(money - spend > 0) {
                money -= spend;
                return true;
            } else {
                return false;
            }
        }

        void reciveMoney(int income) {
            money += income;
        }

        void reciveItem(item item) {
            inventory[item.name] = item;
        }

        void dropItem(string itemName) {
            inventory.erase(itemName);
        }

        const map<string, item>& viewInventory() {
            return inventory;
        }

        virtual void trade(trader* other) = 0;
};

class FightAgent: public fighter {
    public:
        FightAgent(int damage, string name) : agent(name) {
            this->damage = damage;
        }

        void attack(fighter* other) {
            cout << name + " is fighting " + other->getName() << endl;
            other->takeDamage(damage);
        }
};

class TalkAgent: public talker {
    public:
        TalkAgent(string name) : agent(name) {};

        void talk(talker* other) {
            string memory =  this->name + " talked with " + other->getName();
            cout << memory << endl;
            this->makeMemory(memory);
            other->makeMemory(memory);
        }

};

class TalkTradeAgent: public talker, public trader {
    public:
        TalkTradeAgent(string name) : agent(name) {
            money = 100;
        }

        void trade(trader* other) {
            cout << name + " is trading with " + other->getName();
            for(pair<string, item> x : other->viewInventory()) {
                if(this->spendMoney(x.second.value)) {
                    other->reciveMoney(x.second.value);
                    other->dropItem(x.second.name);
                    this->reciveItem(x.second);
                    cout << " trade succesful";
                    break;
                }
            }
            cout << endl;
        }

        void talk(talker* other) {
            string memory =  this->name + " talked with " + other->getName();
            cout << memory << endl;
            this->makeMemory(memory);
            other->makeMemory(memory);
        } 
};

我正在努力构建一个数据结构，它可以让我以一种允许我访问它们实现的所有行为的方式存储所有最终代理示例
我最初的解决方案是使用一个vector<agent*>，并使用一个定义了它们实现的行为的结构体来组成基本代理类，并且在两个代理之间的交互中使用dynamic_cast向下转换到相关的直接代理子类。然而，这意味着每次添加新的代理行为子类时，我都需要更新行为结构体，并且需要动态转换，这很慢。我还试图实现一个结构，它可以接受代理子类的任何示例，并将其分解为指向其行为父类的指针，将它们存储在每个行为类的向量中，但是我在实现模板时遇到了困难。