将对象声明为数组，然后将同一数组中的某个值的类型声明为子类

Question

[已解决] 这是我的全部代码都完成了一个工作：

#include <ncurses.h>
#include <random>
#include <ctime>
using namespace std;

//VARIABLES
///////////
    int tick_count = 0;
    char key;
    int width = 10, height = 10;

    class Entity {
    public:
        class Common {
        public:
            char icon;
            int x, y;
            char collide;
            int power = 0, speed = 0, defense = 0, health = 0;
            int hp;

            virtual void move(int dir) {
                switch (dir) {
                    case 1:
                        y--;
                        break;
                    case 2:
                        y++;
                        break;
                    case 3:
                        x--;
                        break;
                    case 4:
                        x++;
                        break;
                }
            }
            virtual ~Common() {}
        };

        class Player: public Common {
            public:
                int target, room;
                Player() {
                    icon = '@';
                    x = 1, y = 1;
                    collide = 'n';
                    power = 1, speed = 1, defense = 1, health = 10;
                    hp = health;
                }
        };
        class Kobold: public Common {
            public:
                Kobold() {
                    icon = 'K';
                    collide = 'n';
                    power = 1, speed = 0, defense = 1, health = 2;
                    hp = health;
                }
        };
        class Spider: public Common {
            public:
                Spider() {
                    icon = 'S';
                    collide = 'n';
                    power = 4, speed = 2, defense = 0, health = 3;
                    hp = health;
                }
        };
    };

    class Room {
    public:
        int width, height, difficulty, enemies;
    };

    Room room[1];
    Entity::Player player;
    Entity::Common * enemy[2];
    int enemy_ID, enemy_count = 2;
///////////

void INIT() {
    room[0].width = 10, room[0].height = 10, room[0].enemies = 0;
    player.x = player.y = 1, player.collide = 'n', player.room = 0;
    enemy[0] = new Entity::Kobold();
    enemy[1] = new Entity::Spider();
    enemy[0]->x = enemy[0]->y = 5;
    enemy[1]->x = enemy[1]->y = 8;
}

void DRAW() {
    clear();
    printw("ATK: %d, DEF: %d, HP: %d \n", player.power, player.defense, player.hp);
    printw("#");
    for (int i = 0; i < room[player.room].width - 1; i++) {
        printw("--");
    }
    printw("-#\n");
    for (int j = 0; j < room[player.room].height; j++) {
        printw("|");
        for (int i = 0; i < room[player.room].width; i++) {
            if (i == room[player.room].width - 1) {
                if (i == player.x and j == player.y) {
                    printw("%c", player.icon);
                }
                else if (i == enemy[enemy_ID]->x and j == enemy[enemy_ID]->y) {
                    printw("%c", enemy[enemy_ID]->icon);
                }
                else {
                    printw(" ");
                }

            }
            else {
                if (i == player.x and j == player.y) {
                    printw("%c ", player.icon);
                }
                else if (i == enemy[enemy_ID]->x and j == enemy[enemy_ID]->y) {
                    printw("%c ", enemy[enemy_ID]->icon);
                }
                else {
                    printw("  ");
                }
            }
        }
        printw("|\n");
    }
    printw("#");
    for (int i = 0; i < width - 1; i++) {
        printw("--");
    }
    printw("-#\n");

    //Debug
    mvprintw(1, 30, "%d %s %c %c", tick_count, typeid(enemy[0]).name(), player.collide, enemy[0]->collide);
}

void LOGIC() {
    //GAME LOGIC
    ////////////
        tick_count += 1;
        srand(time(NULL));
    ////////////

    //BATTLE LOGIC
    //////////////
        if (player.collide == 'e' or enemy[enemy_ID]->collide == 'p') {
            for (int i; i < enemy_count; i++) {
                if (enemy[enemy_ID]->collide == 'p')
                    player.target = i;
            }

            if (player.speed > enemy[player.target]->speed) {

            }
            else if (player.speed < enemy[player.target]->speed) {

            }
            else if (player.speed == enemy[player.target]->speed) {
                if (player.collide = 'e') {
                    if (rand() % 2) {
                        enemy[player.target]->hp -= player.power - enemy[player.target]->defense;
                        mvprintw(14, 0, "You hit %s with %d damage", enemy[player.target], player.power - enemy[player.target]->defense);
                        clrtoeol();
                    }
                    else {

                    }
                }
                else if (player.collide = 'n') {
                    player.hp -= enemy[player.target]->power - player.defense;
                    mvprintw(14, 0, "%s hit you with %d damage", enemy[player.target], enemy[player.target]->power - player.defense);
                    getch();
                    clrtoeol();
                }
            }
        }
    //////////////

    //PLAYER LOGIC
    //////////////
        if (player.x - 1 == enemy[enemy_ID]->x and player.y == enemy[enemy_ID]->y and key == 'a'
        or player.x + 1 == enemy[enemy_ID]->x and player.y == enemy[enemy_ID]->y and key == 'd'
        or player.y - 1 == enemy[enemy_ID]->y and player.x == enemy[enemy_ID]->x and key == 'w'
        or player.y + 1 == enemy[enemy_ID]->y and player.x == enemy[enemy_ID]->x and key == 's'
        )
            player.collide = 'e';
        else
            player.collide = 'n';

        if (player.x < 0)
            player.x = 0;
        else if (player.x == width)
            player.x = width - 1;
        else if (player.y < 0)
            player.y = 0;
        else if (player.y == height)
            player.y = height - 1;
    //////////////

    //ENEMY LOGIC
    /////////////
        for (enemy_ID = 0; enemy_ID < enemy_count - 1; enemy_ID++)
            enemy_ID++;

        if (enemy[enemy_ID]->x == player.x and enemy[enemy_ID]->y > player.y and enemy[enemy_ID]->y - 1 != player.y)
            enemy[enemy_ID]->move(1);
        else if (enemy[enemy_ID]->x == player.x and enemy[enemy_ID]->y < player.y and enemy[enemy_ID]->y + 1 != player.y)
            enemy[enemy_ID]->move(2);
        else if (enemy[enemy_ID]->y == player.y and enemy[enemy_ID]->x > player.x and enemy[enemy_ID]->x - 1 != player.x)
            enemy[enemy_ID]->move(3);
        else if (enemy[enemy_ID]->y == player.y and enemy[enemy_ID]->x < player.x and enemy[enemy_ID]->x + 1 != player.x)
            enemy[enemy_ID]->move(4);

        if (enemy[enemy_ID]->x - 1 == player.x and player.y == enemy[enemy_ID]->y
        or enemy[enemy_ID]->x + 1 == player.x and player.y == enemy[enemy_ID]->y
        or enemy[enemy_ID]->y - 1 == player.y and player.x == enemy[enemy_ID]->x
        or enemy[enemy_ID]->y + 1 == player.y and player.x == enemy[enemy_ID]->x
        )
            enemy[enemy_ID]->collide = 'p';
        else
            enemy[enemy_ID]->collide = 'n';
    /////////////
}

void INPUT() {
    key = getch();
    switch (key) {
        case 'w':
            player.move(1);
            break;
        case 's':
            player.move(2);
            break;
        case 'a':
            player.move(3);
            break;
        case 'd':
            player.move(4);
            break;
    }
}

int main() {
    initscr();
    cbreak();
    noecho();
    INIT();
    DRAW();
    while (key != '\n') {
        //Main Loop
        ///////////////////////
            INPUT();
            LOGIC();
            DRAW();
        ///////////////////////
        refresh();
    }
    endwin();
    return 0;
}

[问题] （抱歉标题可能令人困惑）我正在制作一个老式的基于 ascii 的流氓类。这是一些代码：

    class Entity {
    public:
        class Player {
        public:
            int x, y, target;
            char collide;
            int power = 1, speed = 1, defense = 1, health = 10;
            int hp = health;
            
            void move(int dir);
        };
        class Kobold {
        public:
            int x, y;
            char collide;
            const int power = 2, speed = 1, defense = 1, health = 3;
            int hp = health;

            void move(int dir);
        };

我的目标是创建一个名为 enemy 的数组，并让每个数组值（或任何它的名称）具有不同的类作为其类型。例如：enemy[0] 可以是Kobold 的对象，它是Entity 的成员，并且enemy[5] 是Spider 的对象，它是Entity 的成员等等。这样更容易在for 循环中拥有更容易声明和引用的敌人。我要问的是如何以这种方式声明数组enemy。拥有并回答我的问题会很好，但我不确定这是否可能以简单的方式实现，所以如果有人有更简单或更简单的方法来实现我的目标，我也希望看到它。提前致谢。

编辑：示例代码（忽略它不是真实的）：

//Declaring an array with 8 values with no type
void enemy[8];

//Assigning the Kobold class to the first enemy as it's type
enemy[0] = Entity::Kobold;

//Assigning the Spider class to the 3rd enemy as it's type
enemy[2] = Entity::Spider;

//Player attacks 3rd enemy (spider) and inflicts damage
enemy[2].hp -= player.power;

//Checks if any enemy is dead, and if so then delete it
for (int i = 0; i < 8; i++) {
    if (enemy[i].hp <= 0) {
        //Removing enemy from it's class, therefore deleting it
        void enemy[i];
    }
}

//First enemy (Kobold) attacks player, inflicting damage
player.hp -= enemy[0].power;

//Player isn't dead, and attacks first enemy (Kobold) and kills it
enemy[0].hp -= player.power;

//Checks if any enemy is dead, and if so then delete it (again)
for (int i = 0; i < 8; i++) {
    if (enemy[i].hp <= 0) {
        //Removing enemy from it's class, therefore deleting it
        void enemy[i];
    }
}

printw("You Win!");

我知道它没有效果并且可能有一些错误，但它只是用来帮助可视化我正在尝试做的事情。

编辑：

这与我要问的类似： Is it possible to have an array of different objects that come from the same base class?

我正在尝试将数组作为Entity 的对象，但我想让任何数组值成为Entity 的任何子类的对象。所以是这样的：

Entity enemy[5];
enemy[0] = new Kobold;
enemy[4] = new Spider;

然后我可以像这样引用更简单的：

for (int i = 0; i < 5; i++) {
    if (array[i].x == player.x and array[i].y == player.y) {
        printw("player and an enemy are in the same spot");
    }
}

所以重点是一次（虚拟地）轻松访问每个敌人的变量。

另一个例子（检查任何敌人是否有 0 hp）：

for (int i = 0; i < amount_of_enemies; i++) {
    if (enemy[i].hp <= 0) {
        //some code to delete the enemy and give player XP etc.
    }
}

Answer 1

第 1 部分

这里有两种流行的方式可以使用，一种是使用C++17的std::any。另一种方法是使用virtual 方法和接口。

std::any 方法允许在同一数组std::vector<std::any> 中存储任何不相关的类。 std::any 允许在单个容器中存储不同的类型，只支持单一类型。

稍后当访问该数组中的实体时，您必须检查它们的类型并将其转换为特定类型，并在if 子句中处理每种类型。每个if 都会有专门针对这种类型的处理代码。

对于任何处理的类，您都可以拥有完全不同的方法和字段，例如下面代码中的方法.player_shout()（用于Player）和.kobold_defense()（用于Kobold）。

数组也可能有一些你无法处理或不知道的类型，你可以跳过它们或用其他方式处理，见下面的代码：

Try it online!

#include <iostream>
#include <vector>
#include <any>

class Entity {
public:        
    class Player {
    public:
        int x, y, target;
        char collide;
        int power = 1, speed = 1, defense = 1, health = 10;
        int hp = health;
        
        void move(int dir) { std::cout << "Moved Player to dir " << dir << std::endl; }
        void player_shout() { std::cout << "Player shouted!" << std::endl; }
    };
    class Kobold {
    public:
        int x, y;
        char collide;
        const int power = 2, speed = 1, defense = 1, health = 3;
        int hp = health;

        void move(int dir) { std::cout << "Moved Kobold to dir " << dir << std::endl; }
        void kobold_defense() { std::cout << "Kobold defensed!" << std::endl; }
    };
};

void ProcessEntities(std::vector<std::any> & entities) {
    for (std::size_t i = 0; i < entities.size(); ++i) {
        auto & e = entities[i];
        if (e.type() == typeid(Entity::Player)) {
            Entity::Player & player = *std::any_cast<Entity::Player>(&e);
            player.move(2);
            player.player_shout();
        } else if (e.type() == typeid(Entity::Kobold)) {
            Entity::Kobold & kobold = *std::any_cast<Entity::Kobold>(&e);
            kobold.move(1);
            kobold.kobold_defense();
        } else
            std::cout << "Unknown entity " << i << " of type "
                << e.type().name() << std::endl;
    }
}

struct BadType {};

int main() {
    std::vector<std::any> entities = {
        Entity::Player(), Entity::Kobold(), Entity::Player(),
        Entity::Player(), BadType(), Entity::Kobold(), BadType()};
    ProcessEntities(entities);
}

输出：

oved Player to dir 2
Player shouted!
Moved Kobold to dir 1
Kobold defensed!
Moved Player to dir 2
Player shouted!
Moved Player to dir 2
Player shouted!
Unknown entity 4 of type 7BadType
Moved Kobold to dir 1
Kobold defensed!
Unknown entity 6 of type 7BadType

---

第 2 部分

您还可以使用virtual 方法来表示具有某些属性（字段）和所有实体共有的方法的公共类。这称为虚拟接口方法。

所有实体都应该从这个通用接口继承并实现所有继承的方法。通用类本身不实现接口方法，但如果需要可以实现。

您可以拥有任意深度的虚拟类层次结构，一切皆有可能。以下示例展示了简单的Common 类的实现以及所有实体对它的继承。

您还可以将虚拟类继承与类型转换方法混合使用（在我的答案的第 1 部分中为 std::any 完成）。下面的例子调用了公共虚方法move()，也展示了公共属性speed。其余逻辑通过type() 方法的类型检查和dynamic_cast 的类型转换完成，转换后您可以使用每个实体的特定（非继承）属性。

因此，您可以以任意方式将虚拟继承与动态类型转换混合。

Try it online!

#include <iostream>
#include <vector>
#include <memory>

class Entity {
public:
    class Common {
    public:
        int x, y;
        char collide;
        int power = 1, speed = 1, defense = 1, health = 10;
        int hp = health;

        virtual void move(int dir) = 0;
        virtual std::type_info const & type() const = 0;
        virtual ~Common() {}
    };

    class Player : public Common {
    public:
        int player_attr = 123;

        std::type_info const & type() const { return typeid(*this); }
        void move(int dir) { std::cout << "Moved Player to dir "
            << dir << " with health " << health << std::endl; }
        void player_shout() { std::cout << "Player shouted with attr "
            << player_attr << "!" << std::endl; }
    };
    class Kobold : public Common {
    public:
        int kobold_attr = 456;

        std::type_info const & type() const { return typeid(*this); }
        void move(int dir) { std::cout << "Moved Kobold to dir "
            << dir << " with health " << health << std::endl; }
        void kobold_defense() { std::cout << "Kobold defensed with attr "
            << kobold_attr << " !" << std::endl; }
    };
};

void ProcessEntities(std::vector<std::shared_ptr<Entity::Common>> & entities) {
    for (std::size_t i = 0; i < entities.size(); ++i) {
        auto & e = entities[i];
        std::cout << "Entity " << i << ": Speed " << e->speed << ". ";
        e->move(i % 3); // Common method
        if (e->type() == typeid(Entity::Player)) {
            Entity::Player & player = dynamic_cast<Entity::Player &>(*e);
            player.player_shout();
            std::cout << "Player attr " << player.player_attr << std::endl;
        } else if (e->type() == typeid(Entity::Kobold)) {
            Entity::Kobold & kobold = dynamic_cast<Entity::Kobold &>(*e);
            kobold.kobold_defense();
            std::cout << "Kobold attr " << kobold.kobold_attr << std::endl;
        } else
            std::cout << "Unknown entity " << i << std::endl;
    }
}

int main() {
    std::vector<std::shared_ptr<Entity::Common>> entities = {
        std::make_shared<Entity::Player>(), std::make_shared<Entity::Kobold>(),
        std::make_shared<Entity::Player>(), std::make_shared<Entity::Player>(),
        std::make_shared<Entity::Kobold>()};
    ProcessEntities(entities);
}

输出：

Entity 0: Speed 1. Moved Player to dir 0 with health 10
Player shouted with attr 123!
Player attr 123
Entity 1: Speed 1. Moved Kobold to dir 1 with health 10
Kobold defensed with attr 456 !
Kobold attr 456
Entity 2: Speed 1. Moved Player to dir 2 with health 10
Player shouted with attr 123!
Player attr 123
Entity 3: Speed 1. Moved Player to dir 0 with health 10
Player shouted with attr 123!
Player attr 123
Entity 4: Speed 1. Moved Kobold to dir 1 with health 10
Kobold defensed with attr 456 !
Kobold attr 456

如果您需要更简单的虚拟继承版本，为了让您更容易理解，我创建了这个更简单的代码：

Try it online!

class Entity {
public:
    class Common {
    public:
        int x, y;
        char collide;
        int power = 0, speed = 0, defense = 0, health = 0;
        int hp = health;
        
        virtual void move(int dir) = 0;
        virtual ~Common() {}
    };
    class Player : public Common {
    public:
        Player() { power = 1; speed = 1; defense = 1; health = 10; hp = health; }
        void move(int dir) {}
    };
    class Kobold : public Common {
    public:
        Kobold() { power = 2; speed = 1; defense = 1; health = 3; hp = health; }
        void move(int dir) {}
    };
    class Spider : public Common {
    public:
        Spider() { power = 3; speed = 2; defense = 2; health = 5; hp = health; }
        void move(int dir) {}
    };
};

int main() {
    Entity::Common * enemies[3] = {
        new Entity::Kobold(), new Entity::Spider()};
    enemies[0]->move(3);
    enemies[0]->hp -= enemies[1]->power;
}

---

第 3 部分

如果两个第一个解决方案（来自我的答案的第 1 部分和第 2 部分）不适合您，那么我可以根据 std::variant 和 std::visit 建议第三个解决方案。

我从你的问题中提取了你如何处理敌人和玩家的例子。并对其进行了一些修改，以使用我使用 std::variant 的第三个想法。请参阅下面的代码。

对你的敌人类进行了一些微小的修改，例如添加复制构造函数（参见 CONSTR(Kobold);）和实现 Empty 类型的实体来存储空值。

您可以在以下代码中看到我创建了两个宏 EN 和 EN2。基本上，如果您将敌人存储为 std::variant ，那么您必须使用这两个宏之一才能访问和/或修改敌人或与玩家互动。因为您不能直接使用 std::variant 类型。这些宏使用std::visit 来访问底层的特定类型。

为了开始使用像下面这样的 std::variant 解决方案，您只需定义一次特殊类型 Enemy，只需枚举所有可能的敌人类 using Enemy = std::variant<Entity::Kobold, Entity::Spider, Entity::Dragon, Entity::Empty>;，请参阅代码。

我创建了Empty 类来将空值存储在数组中。您可以通过特殊宏EMPTY(enemy)检查元素是否为空。

Try it online!

#include <variant>
#include <vector>
#include <iostream>

class Entity {
public:
    #define COPY(self, o) { self.x = o.x; self.y = o.y; self.collide = o.collide; self.power = o.power; self.speed = o.speed; self.defense = o.defense; self.health = o.health; self.hp = o.hp; }
    #define CONSTR(T) \
        T() {} \
        T(T const & o) { COPY((*this), o); } \
        T & operator =(T const & o) { COPY((*this), o); return *this; }

    class Player {
    public:
        int x, y, target;
        char collide;
        int power = 1, speed = 1, defense = 1, health = 10;
        int hp = health;
        
        void show_hp() const { std::cout << "Player health " << hp << std::endl; }
        void move(int dir) { std::cout << "Moved Player to dir " << dir << std::endl; }
    };
    class Kobold {
    public:
        int x, y;
        char collide;
        int power = 2, speed = 1, defense = 1, health = 1;
        int hp = health;

        CONSTR(Kobold);

        void show_hp() const { std::cout << "Kobold health " << hp << (hp <= 0 ? ", Dead!!!" : "") << std::endl; }
        void move(int dir) { std::cout << "Moved Kobold to dir " << dir << std::endl; }
    };
    class Spider {
    public:
        int x, y;
        char collide;
        int power = 3, speed = 1, defense = 1, health = 5;
        int hp = health;

        CONSTR(Spider);

        void show_hp() const { std::cout << "Spider health " << hp << (hp <= 0 ? ", Dead!!!" : "") << std::endl; }
        void move(int dir) { std::cout << "Moved Spider to dir " << dir << std::endl; }
    };
    class Dragon {
    public:
        int x, y;
        char collide;
        int power = 7, speed = 1, defense = 1, health = 20;
        int hp = health;

        CONSTR(Dragon);

        void show_hp() const { std::cout << "Dragon health " << hp << (hp <= 0 ? ", Dead!!!" : "") << std::endl; }
        void move(int dir) { std::cout << "Moved Dragon to dir " << dir << std::endl; }
    };
    class Empty {
    public:
        int x, y;
        char collide;
        int power = 0, speed = 0, defense = 0, health = 1;
        int hp = health;

        CONSTR(Empty);

        void show_hp() const { std::cout << "Empty!!!" << std::endl; }
        void move(int dir) { std::cout << "Empty!!!" << std::endl; }
    };
    #define EMPTY(x) (typeid(x) == typeid(Entity::Empty))
};

using Enemy = std::variant<
    Entity::Kobold, Entity::Spider, Entity::Dragon, Entity::Empty>;

#define EN(_pos, code) \
    std::visit([&](auto & enemy) code, enemies[_pos]);

#define EN2(_pos0, _pos1, code) \
    std::visit([&](auto & enemyA) { \
        std::visit([&](auto & enemyB) code, enemies[_pos1]); \
    }, enemies[_pos0]);

void Process(std::vector<Enemy> & enemies) {
    Entity::Player player;

    EN(2, {
        // Player attacks 3rd enemy (spider) and inflicts damage
        enemy.show_hp();
        enemy.hp -= player.power;
        enemy.show_hp();
    });

    //Checks if any enemy is dead, and if so then delete it
    for (int i = 0; i < enemies.size(); ++i) {
        EN(i, {
            if (!EMPTY(enemy) && enemy.hp <= 0) {
                //Removing enemy from it's class, therefore deleting it
                enemies[i] = Entity::Empty();
                std::cout << "Enemy " << i << " is dead and removed." << std::endl;
            }
        });
    }

    EN(0, {
        player.show_hp();
        //First enemy (Kobold) attacks player, inflicting damage
        player.hp -= enemy.power;
        player.show_hp();

        enemy.show_hp();
        //Player isn't dead, and attacks first enemy (Kobold) and kills it
        enemy.hp -= player.power;
        enemy.show_hp();
    });

    //Checks if any enemy is dead, and if so then delete it
    for (int i = 0; i < enemies.size(); ++i) {
        EN(i, {
            if (!EMPTY(enemy) && enemy.hp <= 0) {
                //Removing enemy from it's class, therefore deleting it
                enemies[i] = Entity::Empty();
                std::cout << "Enemy " << i << " is dead and removed." << std::endl;
            }
        });
    }

    EN2(3, 4, {
        enemyA.show_hp();
        enemyA.hp -= enemyB.power;
        enemyA.show_hp();

        enemyB.show_hp();
        enemyB.hp -= enemyA.power;
        enemyB.show_hp();
    });

    //Checks if any enemy is dead, and if so then delete it
    for (int i = 0; i < enemies.size(); ++i) {
        EN(i, {
            if (!EMPTY(enemy) && enemy.hp <= 0) {
                //Removing enemy from it's class, therefore deleting it
                enemies[i] = Entity::Empty();
                std::cout << "Enemy " << i << " is dead and removed." << std::endl;
            }
        });
    }

    std::cout << "You win!" << std::endl;
}

int main() {
    std::vector<Enemy> enemies = {
        Entity::Kobold(), Entity::Dragon(), Entity::Spider(),
        Entity::Spider(), Entity::Dragon(), Entity::Kobold()};
    Process(enemies);
}

输出：

Spider health 5
Spider health 4
Player health 10
Player health 8
Kobold health 1
Kobold health 0, Dead!!!
Enemy 0 is dead and removed.
Spider health 5
Spider health -2, Dead!!!
Dragon health 20
Dragon health 17
Enemy 3 is dead and removed.
You win!