自定义字符串的重载运算符 +=。如何正确实现？

Question

我的实现有程序，然后我尝试使用空初始字符串

+=

。我有空的构造函数

= default

。

在我尝试类似的事情之前：

str = "";
sz = 0;

这也是行不通的。

我的认识。请问有人可以解释一下吗？

HomyshenTH_String::HomyshenTH_String() = default;

HomyshenTH_String::HomyshenTH_String(const HomyshenTH_String& s)
{
    str = s.str;
    sz = s.sz;
}

HomyshenTH_String::HomyshenTH_String(const char* ch)
{
    int length = 0;
    while (ch[length] != '\0') length++;
    str = new char[length];
    for (int i = 0; i < length; i++) {
        str[i] = ch[i];
    }
    sz = length;
}

HomyshenTH_String& HomyshenTH_String::operator+=(const HomyshenTH_String& s)
{
    size_t old_size = this->sz;
    this->sz = old_size + s.sz;
    for (size_t i = 0; i < s.sz; i++) {
        this->str[i + old_size] = s[i];
    }
    return *this;
}

HomyshenTH_String s("wordle");
const HomyshenTH_String s1("WORD");
s += s1; // works
s += "a"; // works
HomyshenTH_String MySubstr;
MySubstr += "a"; //error

Answer 1

您的复制构造函数没有执行数据的深层复制，它只是复制指针，从而破坏了数据的所有权。 此外，在将字符复制到其中之前，您的串联运算符不会扩展分配的内存。

尝试更多类似这样的事情：

class HomyshenTH_String {
private:
    char *str = nullptr;
    size_t sz = 0;

public:
    HomyshenTH_String() = default;

    HomyshenTH_String(const char* s);
    HomyshenTH_String(const HomyshenTH_String& s);
    HomyshenTH_String(HomyshenTH_String&& s);

    ~HomyshenTH_String();

    HomyshenTH_String& operator=(HomyshenTH_String s);

    HomyshenTH_String& operator+=(const char* s);
    HomyshenTH_String& operator+=(const HomyshenTH_String& s);
};

#include <algorithm>
#include <cstring>

static char* str_dup(const char *s, size_t sz) {
    if (s == nullptr || sz == 0) return nullptr;
    char *new_str = new char[sz];
    std::copy_n(s, length, new_str);
    return new_str;
}

static void str_concat(char* &dest, size_t &dest_sz, const char* s, size_t sz) {
    if (s == nullptr || sz == 0) return;
    size_t new_size = dest_sz + sz;
    char *new_str = new char[new_size];
    std::copy_n(dest, dest_sz, new_str);
    std::copy_n(s, sz, new_str + dest_sz);
    delete[] dest;
    dest = new_str;
    dest_sz = new_size;
}

HomyshenTH_String::HomyshenTH_String(const char* s)
{
    size_t length = s ? std::strlen(s) : 0;
    str = str_dup(s, length);
    sz = length;
}

HomyshenTH_String::HomyshenTH_String(const HomyshenTH_String& s)
{
    str = str_dup(s.str, s.sz);
    sz = s.sz;
}

HomyshenTH_String::HomyshenTH_String(HomyshenTH_String&& s)
{
    std::swap(str, s.str);
    std::swap(sz, s.sz);
}

HomyshenTH_String::~HomyshenTH_String()
{
    delete[] str;
}

HomyshenTH_String& HomyshenTH_String::operator=(HomyshenTH_String s)
{
    HomyshenTH_String temp(std::move(s));
    std::swap(str, temp.str);
    std::swap(sz, temp.sz);
    return *this;
}

HomyshenTH_String& HomyshenTH_String::operator+=(const HomyshenTH_String& s)
{
    str_concat(str, sz, s.str, s.sz);
    return *this;
}

HomyshenTH_String& HomyshenTH_String::operator+=(const char* s) {
    str_concat(str, sz, s, s ? std::strlen(s) : 0);
    return *this;
}