有一个基类warrior和其五个派生类lion wolf ninja icrman dragon，每次都会产生其中的一个武士，并且每次产生的时候都会有位置和阵营，如何保存武士的位置和阵营信息并且保存这是哪种武士c++

你可以在每个派生类中添加位置和阵营属性，并在构造函数中初始化它们。你还可以使用一个`enum`类型来表示不同的阵营。然后，你可以使用动态内存分配来实例化不同类型的武士对象，并将指针存储在一个容器（如数组、向量等）中，这样就能保存每个派生类对象的位置、阵营和类型信息。当需要调用某种类型的武士时，只需要根据其类型从容器中获取相应的指针即可。下面是一些示例代码：

#include <iostream>
#include <vector>

using namespace std;

enum class Camp { RED, BLUE };

class Warrior {
public:
    Warrior(int position, Camp camp) : position(position), camp(camp) {}
    virtual void show() = 0;
protected:
    int position;
    Camp camp;
};

class Lion : public Warrior {
public:
    Lion(int position, Camp camp) : Warrior(position, camp) {}
    void show() override {
        cout << "This is a lion of camp " << static_cast<int>(camp)
             << " at position " << position << "." << endl;
    }
};

class Wolf : public Warrior {
public:
    Wolf(int position, Camp camp) : Warrior(position, camp) {}
    void show() override {
        cout << "This is a wolf of camp " << static_cast<int>(camp)
             << " at position " << position << "." << endl;
    }
};

class Ninja : public Warrior {
public:
    Ninja(int position, Camp camp) : Warrior(position, camp) {}
    void show() override {
        cout << "This is a ninja of camp " << static_cast<int>(camp)
             << " at position " << position << "." << endl;
    }
};

class Icrman : public Warrior {
public:
    Icrman(int position, Camp camp) : Warrior(position, camp) {}
    void show() override {
        cout << "This is an icrman of camp " << static_cast<int>(camp)
             << " at position " << position << "." << endl;
    }
};

class Dragon : public Warrior {
public:
    Dragon(int position, Camp camp) : Warrior(position, camp) {}
    void show() override {
        cout << "This is a dragon of camp " << static_cast<int>(camp)
             << " at position " << position << "." << endl;
    }
};

int main() {
    vector<Warrior*> warriors;

    // 创建不同类型的武士对象
    warriors.push_back(new Lion(1, Camp::RED));
    warriors.push_back(new Wolf(2, Camp::RED));
    warriors.push_back(new Ninja(3, Camp::BLUE));
    warriors.push_back(new Icrman(4, Camp::BLUE));
    warriors.push_back(new Dragon(5, Camp::RED));

    // 调用某种类型的武士对象
    for (auto warrior : warriors) {
        warrior->show();
    }

    // 释放动态分配的内存
    for (auto warrior : warriors) {
        delete warrior;
    }

    return 0;
}

在上面的示例代码中，我们定义了一个`Warrior`基类和五个派生类，分别是`Lion`、`Wolf`、`Ninja`、`Icrman`和`Dragon`。每个派生类都继承了`Warrior`基类，并在构造函数中初始化位置和阵营属性。我们创建了不同类型的武士对象，并将它们的指针存储在一个向量中。在调用某种类型的武士时，我们使用了动态绑定（即虚函数）来调用相应的`show`方法，从而输出相应的信息。在程序结束时，我们需要释放动态分配的内存。