Question

我正在编写一个程序，我必须编写自己的字符串类和药水类。我知道这个运行时错误通常是在程序删除未分配的内容时引起的，但它发生在main中的'return 0'之后。我逐行调试它并尝试了一些事情来尝试消除运行时错误，但没有什么真正起作用。有没有人可以帮我解决这个问题？

这是我的代码：

//Main
#include "Potion.h"
#include <iostream>
using std::cout;
using std::endl;

void TotalCost( Potion ArrayofPotions[5] )
{
    String Currency[4] = {"Platinum", "Gold", "Silver" ,"Copper"};
    int TotalCost[4] = {0, 0, 0, 0};
    int Cost[4] = {0, 0, 0, 0};

    for (short i = 0; i < 5; i++)
    {
        for (short k = 0; k < 4; k++)
        {
            Cost[k] = ArrayofPotions[i].ConvertCost(k);
            TotalCost[k] += Cost[k];

            if ( i != 0 )
                TotalCost[k] = ArrayofPotions[k].CalculateCost(TotalCost[k - 1], TotalCost[k]);
        }
    }
    cout << "\nTotal cost for all potions: ";

    for (short i = 0; i < 4; i++)
    {
        cout << TotalCost[i] << ' ';
        Currency[i].Display();
    }
}

int main()
{
    Potion Haggling("Potion of Haggling", "You haggle for 10% better prices for 30 seconds",
                "Weak", "0.80.0.4.");

    Potion Strength("Draught of Strength", "You can carry 20% more for 300 seconds", 
                "Low", "2.60.5.1.");

    Potion Health("Solution of Health", "You are 30% tougher for 60 seconds",
              "Mild", "2.20.5.1.");

    Potion Stealth("Philter of Stealth", "You are 40% harder to detect for 60 seconds",
               "Moderate", "0.90.5.1.");

    Potion Waterbreathing("Elixir of Waterbreathing", "You can breathe underwater for 60 seconds",
                      "Strong", "2.10.5.0.");

    Potion ArrayOfPotions[5] = {Haggling, Strength, Health, Stealth, Waterbreathing};

    for (short i = 0; i < 5; i++)
        ArrayOfPotions[i].DisplayPotions();

    TotalCost(ArrayOfPotions);

    system("pause");
    return 0;
}

//String class
class String
{
public:
    String() : m_str(nullptr)
    { }
    String(char chr) : m_str(nullptr)
    {
        m_str = new char;
        *m_str = ch;
    }
    String(char * str)
    {
        if (str != nullptr)
        {
            m_str = new char[strlen(str) + 1];
            strcpy(m_str, str);
        }
    }
    String(const String & copy) : m_str(copy.m_str)
    { }
    String& operator=(const String & rhs)
    {
        if ( this != &rhs )
        {
            delete [] m_str;
            m_str = new char[strlen(rhs.m_str) + 1];
            strcpy(m_str, rhs.m_str);
        }

        return *this;
    }
    ~String()
    {
        delete [] m_str;
    }
    void Display() const
    {
        cout << m_str;
    }
    char * GetStr() const
    {
        return m_str;
    }
    String Upper()
    {
        char * check = this->m_str;

        for (unsigned short i = 0; i < strlen( this->m_str ); i++, check++)
        {
            if ( *check > 96 && *check < 123 )
            {
                *check -= 32;
            }
            else
                m_str = this->m_str;
        }
        return m_str;
    }
private:
    char * m_str;
};

//Potion class

#include "String.h"

class Potion
{
public:    
    Potion() : m_name(nullptr), m_description(nullptr), m_potency(nullptr),
               m_cost(nullptr)
    { }
    Potion(String name, String description, String potency, String cost)
    {
        m_name = name;
        m_description = description;
        m_potency = potency.Upper();
        m_cost = cost;
    }
    Potion(const Potion & copy) : m_name(copy.m_name), m_description(copy.m_description),
                                  m_potency(copy.m_potency), m_cost(copy.m_cost)
    { }
    int ConvertCost(int index)
    {
        int cost = 0;
        char * new_cost = m_cost.GetStr();
        char * temp_string = new char[strlen( new_cost ) + 1];

        strcpy(temp_string, new_cost);

        char * temp = strtok( temp_string, "." );

        for (short k = 0; k != index; k++)
            temp = strtok( NULL, "." );

        cost = atoi( temp );

        delete [] temp_string;

        return cost;
    }
    int CalculateCost(int & cost1, int cost2)
    {
        if (cost > 99)
        {
            cost1++;
            cost2 -= 100;
        }
        return cost2;
    }
    void DisplayPotions()
    {
        String Currency[4] = {"Platinum", "Gold", "Silver" ,"Copper"};
        int cost = 0;

        m_name.Display();
        m_description.Display();
        m_potency.Display();

        for (short i = 0; i < 4; i++)
        {
            cost = ConvertCost(i);

            if (cost != 0)
            {
                cout << ConvertCost(i) << ' ';
                Currency[i].Display();
            }
        }
    }
private:
    String m_name;
    String m_description;
    String m_potency;
    String m_cost;
};

我很抱歉这很长，我遗漏了一些输出格式，但我真的需要一些帮助。

P.S。我的教授希望我们将成本从字符串转换为int，并且必须将其设置为“0.0.0.0”格式。这就是为什么它是这样写的。

Answer 1

您的赋值运算符已损坏，因为它从右侧复制指针您需要遵循与复制构造函数中相同的过程。

顺便说一下，复制构造函数也会被破坏，因为如果rhs为空，它将会失败。

（在您的空字符串表示中使用空字符串更安全（即使用""代替nullptr）。）它可以避免大量的空检查。）

这个构造函数也被破坏了：

String(char * str)
{
    if (str != nullptr)
    {
        m_str = new char[strlen(str) + 1];
        strcpy(m_str, str);
    }
}

因为如果你传递m_str nullptr，它会保持未初始化状态 - 而且你做了很多。

这个构造函数也被破坏了：

String(char chr) : m_str(nullptr)
{
    m_str = new char;
    *m_str = ch;
}

因为它没有构造一个以零结尾的字符串。

你需要

m_str = new char[2];
m_str[0] = ch;
m_str[1] = 0;

Answer 2

正如其他人所说，你的构造者被打破了。除此之外，赋值运算符也以微妙的方式被破坏。

解决此问题的最简单方法是将大多数的赋值运算符代码移动到复制构造函数。

String(const String & copy) : m_str(new char[strlen(copy.m_str)+1])
{ 
   strcpy(m_str, copy.m_str);
}

对于赋值运算符，缺陷是在调用new[]之前删除内存。如果new[]抛出异常会怎样？您已销毁旧数据，但无法恢复数据。

而不是如何编写赋值运算符，更好的方法是：

   #include <algorithm>
   //...
   String& operator=(String rhs)
   {
     std::swap(rhs.m_str, m_str);
     return *this;
   }

这很简单，而且很有效。它需要一个工作的复制构造函数和String的工作析构函数。由于您提供了这两个函数，因此编写赋值运算符变得微不足道。

请参阅copy/swap idiom：What is the copy-and-swap idiom?

这也确保了如果new[]抛出异常，则不会破坏原始字符串。 std::swap只是交换这两个项目 - 如果你不能使用std::swap，那么编写你自己的函数来交换指针，因为它应该很容易实现。

_BOCK_TYPE_IS_VALID（pHead-> nBlockUse）＆＃34;返回0＆＃34;

2 个答案: