应该怎么改C2027

Question

#include<cstdio>
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

#define soldierTotalNum 5
#define weaponTotalNum 3

using namespace std;
string soldierType[soldierTotalNum] = { "dragon","ninja","iceman","lion","wolf" };//武士种类
int soldierOrder[2][soldierTotalNum] = { {2,3,4,1,0},{3,0,1,2,4} };//出兵顺序
int soldierTypeHP[soldierTotalNum];//武士生命值（顺序："dragon","ninja","iceman","lion","wolf"） 0--10000
int soldierTypeATK[soldierTotalNum];//武士攻击力（顺序："dragon","ninja","iceman","lion","wolf"） 0--200
string weaponType[weaponTotalNum] = { "sword","bomb","arrow" };//武器种类 , 编号为0，1，2

#include"Weapon.h"
#include"Sword.h"
#include"Bomb.h"
#include"Arrow.h"

#include"Soldier.h"
#include"Dragon.h"
#include"Ninja.h"
#include"Iceman.h"
#include"Lion.h"
#include"Wolf.h"

#include"Headquarters.h"


int main()
{
    Headquarters headquarterRed("red", soldierOrder[0]);
    Headquarters headquarterBlue ("blue", soldierOrder[1]);
    int iCase;
    cin >> iCase;
    for(int ic=1;ic<=iCase;ic++)
    {
        int m;//生命元 (0--10000)
        int time = 0;

        cin >> m;
        for (int i = 0; i < soldierTotalNum; i++)//每种武士生命值（0--10000）
            cin >> soldierTypeHP[i];

        printf("Case:%d\n", ic);

        headquarterRed.setLife(m);
        headquarterBlue.setLife(m);

        bool flagRed = 1, flagBlue = 1;
        while (flagRed || flagBlue)
        {
            if (headquarterRed.judgeIntroduce())
            {
                printf("%03d ", time);
                headquarterRed.introduceSoldier();
            }
            else
            {
                if (flagRed)
                {
                    printf("%03d ", time);
                    headquarterRed.printStopInfo();
                    flagRed = 0;
                }
            }
            if (headquarterBlue.judgeIntroduce())
            {
                printf("%03d ", time);
                headquarterBlue.introduceSoldier();
            }
            else
            {
                if (flagBlue)
                {
                    printf("%03d ", time);
                    headquarterBlue.printStopInfo();
                    flagBlue = 0;
                }
            }

            if (flagRed || flagBlue)
                time++;
        }
        headquarterRed.clearSoldier();
        headquarterBlue.clearSoldier();
    }
}

下面是一些头文件

#pragma once
class Headquarters
{
private:
    string color;
    int life;
    int _currentSoldier;//当前兵种
    int totalRef;//总编号（生产武士总数）

    int HeadquartersSoldierOrder[soldierTotalNum];//该阵营出兵顺序
    int everySoldierNum[soldierTotalNum];//每个武士的数量
    vector< Soldier* > soldiers;//武士


public:
    Headquarters(string _color,int arr[]);//构造函数：阵营颜色，出兵顺序
    Headquarters(const Headquarters& h);//拷贝构造函数
    ~Headquarters();//析构函数

    void clearSoldier();//初始化兵营
    bool judgeIntroduce();//判断是否能出兵
    void introduceSoldier();//生产武士
    int getLife();//返回生命元
    void setLife(int m);//设置生命元
    void setColor(string _color);//设置阵营颜色
    void setSoldierOrder(int arr[]);//设置出兵顺序
    void setSoldierOrder();//设置出兵顺序
    void print();//打印阵营信息
    void printStopInfo();//打印停止出兵信息
};


void Headquarters::clearSoldier()
{
    soldiers.clear();//清空武士
    totalRef = 0;//总编号（生产武士总数）清0
    _currentSoldier = 0;//当前兵种归0
    memset(everySoldierNum, 0, sizeof(everySoldierNum));//每个武士的数量清0
}

bool Headquarters::judgeIntroduce()
{
    if (life - soldierTypeHP[HeadquartersSoldierOrder[_currentSoldier]] >= 0)
        return true;
    return false;
}

void Headquarters::introduceSoldier()
{

    if (judgeIntroduce())
    {
        totalRef++;
        life -= soldierTypeHP[HeadquartersSoldierOrder[_currentSoldier]];
        Soldier* ss;
        if (HeadquartersSoldierOrder[_currentSoldier] == 0)
            ss = new Dragon(HeadquartersSoldierOrder[_currentSoldier], ++everySoldierNum[_currentSoldier], totalRef, this);
        if (HeadquartersSoldierOrder[_currentSoldier] == 1)
            ss = new Ninja(HeadquartersSoldierOrder[_currentSoldier], ++everySoldierNum[_currentSoldier], totalRef, this);
        if (HeadquartersSoldierOrder[_currentSoldier] == 2)
            ss = new Iceman(HeadquartersSoldierOrder[_currentSoldier], ++everySoldierNum[_currentSoldier], totalRef, this);
        if (HeadquartersSoldierOrder[_currentSoldier] == 3)
            ss = new Lion(HeadquartersSoldierOrder[_currentSoldier], ++everySoldierNum[_currentSoldier], totalRef, this);
        if (HeadquartersSoldierOrder[_currentSoldier] == 4)
            ss = new Wolf(HeadquartersSoldierOrder[_currentSoldier], ++everySoldierNum[_currentSoldier], totalRef, this);

        soldiers.push_back(ss);

        cout << color << ' ' << soldiers[totalRef-1]->getName() << ' ' << totalRef;
        cout << " born with strength " << soldiers[totalRef-1]->getSoldierHP() << ',';
        cout << everySoldierNum[_currentSoldier] << ' ' << soldiers[totalRef-1]->getName() << " in " << color << " headquarter";
        printf("\n");


        _currentSoldier = (_currentSoldier + 1) % 5;
    }

}

Headquarters::Headquarters(string _color, int arr[])
    :color(_color),life(100), _currentSoldier(0), totalRef(0)
{
    memset(everySoldierNum, 0, sizeof(everySoldierNum));
    for (int i = 0; i < soldierTotalNum; i++)
        HeadquartersSoldierOrder[i] = arr[i];
}

Headquarters::Headquarters(const Headquarters& h)
{
    color = h.color;
    _currentSoldier = h._currentSoldier;
    totalRef = h.totalRef;

    for (int i = 0; i < soldierTotalNum; i++)
    {
        HeadquartersSoldierOrder[i] = h.HeadquartersSoldierOrder[i];
        everySoldierNum[i] = h.everySoldierNum[i];
    }
}
Headquarters::~Headquarters() 
{
    for (int i = 0; i < totalRef; i++)
        if (soldiers[i])
            delete soldiers[i];
    soldiers.clear();
};
void Headquarters::setColor(string _color)
{
    color = _color;
}
void Headquarters::setSoldierOrder(int arr[])
{
    for (int i = 0; i < soldierTotalNum; i++)
        HeadquartersSoldierOrder[i] = arr[i];
}
void Headquarters::setSoldierOrder()
{
    for (int i = 0; i < soldierTotalNum; i++)
        cin >> HeadquartersSoldierOrder[i];
}
void Headquarters::print()
{
    cout << color << ' ';
    for (int i = 0; i < soldierTotalNum; i++)
        cout << soldierType[HeadquartersSoldierOrder[i]] << ' ';
    cout << endl;
}

void Headquarters::printStopInfo()
{
    // red headquarter stops making warriors
    cout << color << " headquarter stops making warriors" << endl;
}

void Headquarters::setLife(int m)
{
    life = m;
}
int Headquarters::getLife()
{
    return life;
}

#pragma once
class Headquarters;
class Soldier
{
protected:
    string name;
    int ref;//该兵种编号，从1开始计算:龙1，龙2......
    int totRef;//总编号，从1开始计算:1龙，2忍者，3冰人......
    double soldierHP;//初始生命值
    double soldierATK;//初始攻击力
    Headquarters* group;//所属阵营
public:
    Soldier(int xOrder,int n,int totn, Headquarters* g);//构造 （种类，编号，总编号,所属阵营）
    string getName();//返回该兵名字
    virtual ~Soldier();//析构函数  虚函数
    int getRef();//返回该兵种编号
    double getSoldierHP();//返回该兵总生命值
    double getSoldierATK();//返回该兵总攻击力
    void print();
};

Soldier::Soldier(int xOrder,int n,int totn, Headquarters* g)
    :name(soldierType[xOrder]), soldierHP(soldierTypeHP[xOrder]), soldierATK(soldierTypeATK[xOrder]),ref(n),totRef(totn)
{
    group = g;
}

Soldier::~Soldier() {};

string Soldier::getName()
{
    return name;
}

int Soldier::getRef()
{
    return ref;
}
double Soldier::getSoldierHP()
{
    return soldierHP;
}
double Soldier::getSoldierATK()
{
    return soldierATK;
}

void Soldier::print()
{
    cout << name << ' ' << ref << ' ' << soldierHP << ' ' << soldierATK << endl;
}

#pragma once
class Headquarters;
class Dragon:public Soldier
{
private:
    Weapon* p;
    double morale;//士气
public:
    Dragon(int xOrder, int n, int totn, Headquarters* g);
    ~Dragon();
};

Dragon::Dragon(int xOrder, int n, int totn,Headquarters* g) :Soldier(xOrder, n, totn, g)
{
    int x = totRef % 3;
    if (x == 0)
        p = new Sword(soldierATK);
    if (x == 1)
        p = new Bomb(soldierATK);
    if (x == 2)
        p = new Arrow(soldierATK);
    morale = 1.0 * (group->getLife()) / soldierHP;
}
Dragon::~Dragon() 
{
    if (p)
        delete p;
};

#pragma once
class Ninja :public Soldier
{
private:
    Weapon* p1;
    Weapon* p2;
public:
    Ninja(int xOrder, int n, int totn, Headquarters* g);
    ~Ninja();
};
Ninja::Ninja(int xOrder, int n, int totn, Headquarters* g) 
    :Soldier(xOrder, n, totn, g) 
{
    int x1 = totRef % 3, x2 = (totRef + 1) % 3;
    if (x1 == 0)
        p1 = new Sword(soldierATK);
    if (x1 == 1)
        p1 = new Bomb(soldierATK);
    if (x1 == 2)
        p1 = new Arrow(soldierATK);

    if (x2 == 0)
        p2 = new Sword(soldierATK);
    if (x2 == 1)
        p2 = new Bomb(soldierATK);
    if (x2 == 2)
        p2 = new Arrow(soldierATK);
}
Ninja::~Ninja()
{
    if (p1)
        delete p1;
    if (p2)
        delete p2;
}

#pragma once
class Iceman :public Soldier
{
private:
    Weapon* p;
public:
    Iceman(int xOrder, int n, int totn, Headquarters* g);
    ~Iceman();
};
Iceman::Iceman(int xOrder, int n, int totn, Headquarters* g) :Soldier(xOrder, n, totn, g)
{
    int x = totRef % 3;
    if (x == 0)
        p = new Sword(soldierATK);
    if (x == 1)
        p = new Bomb(soldierATK);
    if (x == 2)
        p = new Arrow(soldierATK);
}
Iceman::~Iceman()
{
    if (p)
        delete p;
}

#pragma once
class Lion :public Soldier
{
private:
    double loyalty;//忠诚度
public:
    Lion(int xOrder, int n, int totn, Headquarters* g);
    ~Lion();
};
Lion::Lion(int xOrder, int n, int totn, Headquarters* g) 
    :Soldier(xOrder, n, totn, g)
{
    loyalty = group->getLife();
}
Lion::~Lion(){}

#pragma once
class Wolf :public Soldier
{
private:

public:
    Wolf(int xOrder, int n, int totn, Headquarters* g);
    ~Wolf();
};
Wolf::Wolf(int xOrder, int n, int totn, Headquarters* g)
    :Soldier(xOrder, n, totn, g)
{}
Wolf::~Wolf()
{}

#pragma once
class Weapon
{
public:
    virtual ~Weapon() = 0;
};

#pragma once
class Sword :public Weapon
{
private:
    string weaponName;//武器名字
    int ref;//武器编号
    int atk;//sword 的攻击力是使用者当前攻击力的 20%(去尾取整)
public:
    Sword(double x);
    ~Sword();
};
Sword::Sword(double x) :weaponName("sword"), ref(0)
{
    atk = (int)(x * 0.2);
}
Sword::~Sword(){}

#pragma once
class Bomb :public Weapon
{
private:
    string weaponName;//武器名字
    int ref;//武器编号

/*bomb 的攻击力是使用者当前攻击力的 40%(去尾取整)，但是也会导致使用者受到攻击，对
使用者的攻击力是对敌人取整后的攻击力的 1/2(去尾取整)。Bomb 一旦使用就没了。*/

    double atk;
public:
    Bomb(double x);
    ~Bomb();
};
Bomb::Bomb(double x):weaponName("bomb"),ref(1)
{
    atk = (int)(x * 0.4);
}
Bomb::~Bomb(){}

#pragma once
class Arrow :public Weapon
{
private:
    string weaponName;//武器名字
    int ref;//武器编号
/*arrow 的攻击力是使用者当前攻击力的 30%(去尾取整)。一个 arrow 用两次就没了。*/
    double atk;
public:
    Arrow(double x);
    ~Arrow();
};
Arrow::Arrow(double x) :weaponName("arrow"), ref(2)
{
    atk = (int)(x * 0.3);
}
Arrow::~Arrow(){}

下面是出现问题的地方，代码还没写完，但是这里出现C2027的问题，应该怎么改

Answer 1

class Soldier
这个的头文件包含下Headquarters