2

目前，我正在尝试在 Fighter.cpp 文件中的函数 sortFighters 中创建一个对充满战斗机的向量进行排序的函数。一切似乎都正确编译了；但是，当它运行时，我在上述 .cpp 文件的其中一行中遇到了一个致命错误。我确切地知道问题是什么，并相应地在那里发表评论。所以，我在这里要问的是，在不添加任何其他功能等的情况下，我可以做些什么来解决这个问题。

这是我的 Fighter.h 文件：

#ifndef FIGHTER_H
#define FIGHTER_H

#include <iostream>
#include <ctime>
#include <string>
#include <cstdlib>
#include <fstream>
#include <vector>

class Fighter
{   
protected:
        std::string name;
        int health, level;
        //int damage;
public: 
        int  getHealth(int);
        void getEnemies(std::vector<Fighter> &);
        void printFighter(std::vector<Fighter> &);
        void sortFighters(std::vector<Fighter> &);
        //friend std::istream & operator >> (std::istream & strm, Fighter & x);
        //friend std::ostream & operator << (std::ostream & strm, const Fighter & f);
        //void attack();
        Fighter();
        ~Fighter();
};

class Player : public Fighter 
{ 
    private:
        int experience;
    public:
        int  getHealth(int);
        void pri`enter code here`ntFighter();
        void getExperience(int);
        void playerAttack();    
        Player();
        ~Player();
};

//class FightPub
//{
//  private:
//      Player player;
//      Fighter enemy;
//  public:
//      //void fight();
//      //void getStats();
//};
#endif

我的 Fighter.cpp 文件：

//dynamically locate an array that holds the number of fighters, and for each fighter in the array, assign from the .txt 
//file the name and level from the fighter.
#include "Fighter.h"  

#pragma region getEnemies
void Fighter::getEnemies(std::vector<Fighter> &baddie)
{
    Fighter x;
    std::ifstream inputFile;
    inputFile.open("EnemyFighters.txt");
    if(!inputFile)
    {
        std::cout << "error!" << std::endl;
    }
    else
    {
        while(!inputFile.eof())
        {
            std::string line;
            inputFile >> line;
            if (line == "<fighter>")
            {
                do
                {
                    inputFile >> line;
                    x.name = line;
                    inputFile >> line;
                    x.level = atoi(line.c_str());
                    inputFile >> line;
                    x.health = getHealth(this->level);
                    baddie.push_back(x);
                    inputFile >> line;
                }while(line != "</fighter>");
            }                   
        }
        inputFile.close();
    }
}
#pragma endregion

#pragma region getHealth

int Fighter::getHealth(int lv)
{
    if(lv >= 6)
    {
        std::cout << "\nHealth Bonus!";
        this->health = lv * 2;
    }
    /*else if (lv > 1)
        for (int i = 1; i < lv; i++)
        {this->health += 2;}*/
    return health;
}

#pragma endregion

#pragma region attack
//void Fighter::attack()
//{
//  int randomAttack = rand() % 4 + 1;
//
//  switch (randomAttack)
//  case 1: 
//  {
//      std::cout << "Enemy uses critical attack!"
//  }
//}
#pragma endregion

#pragma region printFighter
void Fighter::printFighter(std::vector<Fighter> &baddie)
{
    //std::cout << this;
    for (int i=0; i<baddie.size(); i++)
    {
        std::cout << "\nName: " << baddie[i].name << std::endl
                  << "Level: " << baddie[i].level << std::endl
                  << "Health: " << baddie[i].health << std::endl;
    }
}
#pragma endregion

void Fighter::sortFighters(std::vector<Fighter> &x)
{
    Fighter * temp = new Fighter;
    bool swap;

    do
    {
        swap = false;
        std::cout << x.size() << std::endl;
        for (int i=0; i<=(x.size()); i++)
        {
            //if the level in the first is greater than the level in the next
            if(x[i].level > x[i+1].level)//I get a fatal error here when it tries to compare 
                                         //the iterator with 1 that's outside its range
            {
                //assign the stats from the first to temp
                temp->name = x[i].name;
                temp->health = x[i].health;
                temp->level = x[i].level;
                //assign the stats from the next to the first
                x[i].name = x[i+1].name;
                x[i].health = x[i+1].health;
                x[i].level = x[i+1].level;
                //assign the ones in temp(the first) to the next
                x[i+1].name = temp->name;
                x[i+1].health = temp->health;
                x[i+1].level = temp->level;
                swap = true;
            }

            else if(x[i].level >= x[i+1].level)
            {
                temp->name = x[i].name;
                temp->health = x[i].health;
                temp->level = x[i].level;

                x[i].name = x[i+1].name;
                x[i].health = x[i+1].health;
                x[i].level = x[i+1].level;

                x[i+1].name = temp->name;
                x[i+1].health = temp->health;
                x[i+1].level = temp->level;
                swap = true;
            }

            else if (x[i].level < x[i+1].level)
            {
                //temp->name = x[i].name;
                //temp->health = x[i].health;
                //temp->level = x[i].level;

                //x[i].name = x[i+1].name;
                //x[i].health = x[i+1].health;
                //x[i].level = x[i+1].level;

                //x[i+1].name = temp->name;
                //x[i+1].health = temp->health;
                //x[i+1].level = temp->level;
                swap = false;
            }

            else if(x[i].level <= x[i+1].level)
            {
                /*temp->name = x[i].name;
                temp->health = x[i].health;
                temp->level = x[i].level;

                x[i].name = x[i+1].name;
                x[i].health = x[i+1].health;
                x[i].level = x[i+1].level;

                x[i+1].name = temp->name;
                x[i+1].health = temp->health;
                x[i+1].level = temp->level;*/
                swap = false;
            }
        }
    }while (swap);

    delete temp;
}
//std::istream & operator >>(std::istream & strm, Fighter x)
//{
//  //x.name += strm.c_str();
//  //x.level += atoi(strm.c_str());
//  strm >> x.name;
//  strm >> x.level;
//  return strm;
//}

//std::ostream & operator << (std::ostream & strm, const Fighter f)
//{
//  strm << "Name: " << f.name << std::endl;
//  strm << "Level: " << f.level << std::endl;
//  strm << "Health: " << f.health << std::endl;
//  return strm;
//}
#pragma region Fighter C&D
Fighter::Fighter()
{
    level = 1;
    health = 10;
}
Fighter::~Fighter()
{
}
#pragma endregion
//void operator <()
//{
//}
//
//void operator >()
//{
//}
//
//void operator <=()
//{
//}
//
//void operator >=()
//{
//}
//
//
//
int Player::getHealth(int lv)
{
    if(lv >= 6)
    {
        std::cout << "\nHealth Bonus!";
        this->health = lv * 2;
    }
    /*else if (lv > 1)
        for (int i = 1; i < lv; i++)
        {this->health += 2;}*/
    return health;
}

void Player::printFighter()
{
//std::cout << this;
      std::cout << "\nPlayer's stats: \n"
      << "Level: " << this->level << std::endl
      << "Health: " << this->health << std::endl
      << "Experience: " << this->experience <<std::endl;
}

void Player::getExperience(int dmg)
{
    experience += dmg;
    if (experience >= (level * 10))
    {
        std::cout << "Congratulations, Player! You're up a level!\n";
        level ++;
    }
}

#pragma region Player C&D
Player::Player()
{
    level = 1;
    health  = getHealth(level);
    experience = 0;
}
Player::~Player()
{
}
#pragma endregion 


//Player::printFighter()
//{
//  
//}

这是 main.cpp：

#include "Fighter.h"

int main()
{   
    unsigned seed = time(0);
    srand(seed);

    std::vector<Fighter> baddie;

    Fighter * enemy = new Fighter;
    Player * me = new Player;
    enemy->getEnemies(baddie);
    enemy->sortFighters(baddie);
    enemy->printFighter(baddie);
    me->printFighter();
    delete enemy;
    delete me;
    return 0;
}
4

5 回答 5

3 
    for (int i=0; i<=(x.size()); i++) 
    { 
        if(x[i].level > x[i+1].level)
        {

嗯.. Size() 从 1 开始计数。索引从 0 开始计数。所以你要做到这一点i < x.size()，而不是<=。 但是，在下一行，你说x[i+1]，所以i甚至无法到达最后一项，它必须在此之前停止一个：

    for (int i=0; i < x.size()-1; i++)
于 2010-08-16T14:45:25.347 回答
2

您已经获得了一些关于如何修复该循环的建议。我的建议是消除它并改用它std::sort。

然而，虽然我们正在处理未正确终止的循环，但可能还值得一提（在 中getEnemies()）：

    while(!inputFile.eof())
    {
        std::string line;
        inputFile >> line;
        if (line == "<fighter>")
        {
    // ...

这也坏了。为了使循环正确终止，您需要读取数据，然后检查读取是否成功：

std::string line;

while (inputFile >> line) {
    if (line == "<fighter>") {
         // ...

可能还值得注意的是，这段代码非常脆弱——仅举一个例子，例如：<fighter>fighter1</fighter>将无法正确读取（它需要在前后至少有一个空格才能<fighter>将其作为单个字符串读取）。

于 2010-08-16T15:00:42.250 回答
0

尝试将您的 for 循环更改为此

for (int i=0; i < x.size() - 1; i++) {
  ... your original content...
}

这种方式x[i+1]永远不会越界
您试图访问尚未分配的内存。

于 2010-08-16T14:46:54.877 回答
0

你的问题是这个循环：

for (int i=0; i<=(x.size()); i++){ 
    if(x[i].level > x[i+1].level){  //Fatal Error Here 
        // Do some stuff
    }
    // Do some more stuff
}

您终止外循环的条件是，i<=(x.size())这意味着当您执行x[i+1].level中断程序的比较 ( ) 时，您是在 x 的范围之外进行比较。因为如果i == x.size()那时x[i+1] > x.size()

我建议将您的循环更改为终止于i<(x.size())-1;而不是i<=(x.size());

于 2010-08-16T14:47:47.307 回答
0

正如其他人所说，问题在于这段代码：

    for (int i=0; i<=(x.size()); i++)
    {
        //if the level in the first is greater than the level in the next
        if(x[i].level > x[i+1].level)//I get a fatal error here when it tries to compare 
                                     //the iterator with 1 that's outside its range

Astd::vector可以由 0 到size() - 1（含）值索引。因此，对于基本vector循环，您应该改为

for (int i = 0; i < x.size(); i++) {

但是，在下一行代码中，您检查元素 i + 1，因此您应该改为

for (int i = 0; i < x.size() - 1; i++) {

但是，因为 x.size() 是无符号的，如果 x 为空，那么x.size() - 1将是一个非常大的数字（在 32 位机器上为 2^32 - 1）。所以你应该为此调整逻辑。此外，比较有符号值（如int i与无符号值（如x.size() - 1）比较可能会生成编译器警告（如果您尚未打开所有此类编译器警告，则应打开），因此更改i为unsignedor size_t：

for (size_t i = 0; i + 1 < x.size(); i++) {

最后，与其编写自己的冒泡排序，不如使用std::sort. std::sort其他 C++ 开发人员更快更熟悉。这是一个（未经测试的）使用示例std::sort：

bool CompareByLevel(const Fighter& a, const Fighter& b) {
    return a.level < b.level;
}

sort(x.begin(), x.end(), CompareByLevel);

其他评论： 如果您有兴趣了解有关 C++ 的更多信息，这里有一些其他评论可能会有所帮助。

inputFile >> line;

该语句实际上将单个空格或换行符分隔的单词读入line. 如果这就是您想要做的，那么您选择的变量名 ( line) 不会传达这一点。您可能希望能够在战士的名字中使用空格。要阅读整行，请使用：（请参阅此处以供参考。）

getline(inputFile, line);

getEnemies, printFighter, andsortFighters应该是static方法，因为它们不需要 a 的特定实例Fighter来操作。（现在，因为它们不是静态方法，所以您必须创建enemyFighter 的实例才能调用这些方法，即使这些方法都没有使用enemy.）

C++ 允许您在堆栈上创建变量，而不是动态分配它们。换句话说，而不是说

Fighter * temp = new Fighter;

说啊

Fighter temp;

如果您不需要动态分配，这会更快更简单。

最后，C++ 将为您创建复制类的所有成员的赋值运算符。所以你可以简单地写

temp = x[i];

而不是手动将 x 的每个成员分配给 temp。使用赋值运算符更加健壮，因为如果您以后将成员添加到Fighter.

希望这可以帮助。

于 2010-08-16T14:59:33.717 回答