3

我开始用 C++ 编写一个非常简单的字符串类实现，代码如下：

class String
{
public:
    String()
    {
        this->_length = 0;
        this->_size = 0;
        this->_string = NULL;
    }
    String(const char* str)
    {
        this->_length = strlen(str);
        this->_size = this->_length + 1;
        this->_string = new char[this->_size];

        strcpy_s(this->_string, this->_size, str);
    }
    ~String()
    {
        if (this->_string != NULL)
        {
            delete[] this->_string;
            this->_string = NULL;
        }
    }

    String& operator+(const char* str)
    {
        String* temp = new String();

        temp->_length = strlen(str) + strlen(this->_string);
        temp->_size = temp->_length + 1;
        temp->_string = new char[temp->_size];

        strcpy_s(temp->_string, temp->_size, this->_string);
        strcat_s(temp->_string, temp->_size, str);

        return (String&)*temp;
    }

    int Length()
    {
        return this->_length;
    }

private:
    int _size;
    int _length;
    char* _string;
};

可以看到我对operator+的实现是绝对错误的，实际上存在内存泄漏。编写 operator+= 更简单，因为我可以简单地将 char* 与 this->_string 连接并返回 *this。我需要有关 operator+ 实施的帮助。

注意：这是家庭作业，所以我不想要复制粘贴的解决方案，但如果有人能指出我正确的方向，那就太棒了......

谢谢

编辑：我添加了复制构造函数：

String(const String& str)
{
    this->_length = str._length;
    this->_size = str._size;
    this->_string = new char[this->_size];
    strcpy_s(this->_string, this->_size, str._string);
}

运算符= 和运算符+=：

String& operator=(const String& str)
{
    if (this != &str)
    {
        this->_length = str._length;
        this->_size = str._size;
        this->_string = new char[this->_size];

        strcpy_s(this->_string, this->_size, str._string);
    }

    return *this;
}
String& operator+=(const String& str)
{
    this->_length = this->_length + str._length;
    this->_size = this->_length + 1;

    char* buffer = new char[this->_size];
    strcpy_s(buffer, this->_size, this->_string);
    strcat_s(buffer, this->_size, str._string);

    delete[] this->_string;
    this->_string = buffer;

    return *this;
}

但是仍然有问题，因为如果我像这样运行 while(true) 循环：

while (true)
{
    String a = String("string a");
    String b = a;
    b = "string b";
    b += " string c";
}

进程使用的内存会不断增加

4

2 回答 2

6

operator+=您可以在中重用operator+：

（下面的代码假设您有一个operator+=、 一个复制构造函数和一个赋值运算符，而您粘贴的代码中并非如此）。

编辑：正如 Jerry Coffin 所建议的，以下操作员不应该是类成员，而是自由操作员：

EDIT2：为了让编译器进行更多优化，第一个参数不再是 const-reference：

String operator+(String a, String const &b) {
  a += b;
  return a;
}

通过这种方式，您可以拥有一个更简单的operator+=复制构造函数，并在简单的构造函数上构建复杂的东西。

不要忘记：

您必须实现复制构造函数和赋值运算符。否则编译器会以错误的方式为您生成它：编译器生成的代码只是复制内容。所以它也会复制指针，但不会为复制分配新的内存。然后你有两个实例引用相同的内存，并且都试图在析构函数中释放它，这是未定义的行为。

于 2013-05-12T20:34:00.590 回答
3

实现您的一种简单方法operator+是根据+=. 创建左操作数的副本，然后使用+=将右操作数添加到其中，最后返回结果。

另请注意，operator+它通常不应该是成员函数——它通常应该是自由函数。基本区别在于，作为成员函数，左操作数必须已经是字符串才能工作。作为一个自由函数，您的字符串构造函数可用于转换（例如）字符串文字。例如，string+"something";将使用成员函数，但"something" + string;不会。将+重载作为自由函数，它们都可以工作。

于 2013-05-12T20:34:23.330 回答