Question

我定义了自己的字符串类MyString。一切正常，直到我通过重载operator =将一个对象分配给另一个对象。我知道问题在哪里，但我不知道如何解决它。有帮助吗？

class MyString{
public:
    MyString( const MyString *strIni );
    MyString( const char *str);
    ~MyString();
    MyString& operator=( const MyString &str );
private:
    char *str;
}


MyString::MyString( const MyString *strIni ){
    this->str = new char[strlen(strIni->str)+1];
    strcpy(this->str,strIni->str) ;
};


MyString::MyString( const char *str){
    this->str = new char[ strlen(str) + 1 ];
    strcpy(this->str , str);
};

MyString::~MyString(){
    delete [] this->str ;
    cout << "successfully deleted..." << endl;
};


MyString& MyString::operator=( const MyString &str ){
    // temp obj holding the rhs
    MyString strTmp(str);
    // temp char pointer holding the rhs
    char *cTmp = strTmp.str;
    // temp obj holding this, later release this memory 
    strTmp.str = this->str ;
    // this holding rhs; assignment done.
    this->str = cTmp;
    return *this ;
};


int main(){
    {                                  // line 1
        MyString mystr1("string #1");  // line 2
        MyString mystr2("string #2");  // line 3
        mystr1 = mystr2;               // line 4
    }                                  // line 5
    return 0;
}

代码的问题是：在第4行，在赋值后，两个对象mystr1和mystr2中的指针都指向相同的字符串“string＃2”。当程序跳出第5行的括号时，析构函数会自动按顺序调用：mystr2然后是mystr1。在mystr2被破坏后，“string＃2”的内存已被释放。当mystr1的析构函数试图释放不存在的内存时，程序崩溃了。

任何人都可以帮我修复重载成员函数。当我指定mystr1 = mystr2时，我可以创建一个新的字符串，而不是让两个指针指向同一个字符串。

非常感谢!!

更新进一步的问题...... 谢谢吨!!

实际上，我在重载功能中使用了copy-and-swap。根据@MateuszKołodziejski的建议，我修改了它：

MyString& MyString::operator=( const MyString &rhs ){
    if( this != &rhs ){
        // copy using constructor
        MyString strTmp(rhs) ;
        // swap        
        char *cTmp = strTmp.str;
        // strTmp will be destructed, thus the memory in this will be released
        strTmp.str = this->str ;
        // size of rhs
        const int str_size = strlen(rhs.str);
        this->str = new char[str_size+1];
        copy(rhs.str,rhs.str+str_size,this->str);
    }
    return *this ;
};

当调用析构函数时，不会崩溃。但是如果添加了打印输出成员函数，则会出现另一个问题：

void MyString::printout(){
    int str_size = strlen(this->str);
    cout << "string size: " << str_size << endl ;
    for( int i=0;i<str_size;i++ ){
        cout << *(this->str + i);
    }
}

主要功能

：

int main(){
    {                                  
        MyString mystr1("string #1");  
        MyString mystr2("string #2");  
        mystr1.printout();
        mystr2.printout();
        mystr1 = mystr2;  
        cout << "after assignment: " << endl;
        mystr1.printout();
        mystr2.printout();             
    }                                  
return 0;
}

结果是：

string #1
string #2
after assignment...
string #2═²²²²
string #2

似乎mystr1不正常......

任何人都能为我解释一下吗？

感谢吨!!

Answer 1

你显然必须修复你的operator =（）实现。

#include <algorithm>

MyString& MyString::operator=( const MyString &rhs ) // (1)
{
    if (this != &rhs) // (2)
    {
        delete[] this->str; // (3)
        this->str = NULL;

        const int str_length = strlen(rhs.str);

        this->str = new char[str_length + 1];
        this->str[str_length] = '\0';
        std::copy(rhs.str, rhs.str + str_length, this->str); // (4)
    }

    return *this;
}

1）使用“rhs”（右侧）而不是“str”作为变量名，以避免歧义。

2）始终检查您的对象是否未被分配给自己。

3）在分配新内存之前释放旧分配的内存。

4）将rhs的内容复制到this-＆gt; str，而不是仅仅重定向指针。

编辑：

添加了这个 - ＆gt; str = NULL;避免双重删除新的和后来的对象解构可能的异常。

这是一个天真的实现 - 您必须知道new可以抛出异常。根据@nyarlathotep的建议，复制交换习语在这里会更好，并在此处描述：Copy-and-swap。

Answer 2

这里的问题是声明

MyString strTmp(str);

在赋值运算符中，调用默认隐式生成的复制构造函数。而那个构造函数只是简单地复制指针，而不是创建一个新指针并复制字符串的内容。

您使用MyString指针的构造函数是而不是复制构造函数，复制构造函数将采用常量引用。如果您更改构造函数，并使用指向MyString的指针来取代引用，那么它将更好地工作。

c ++中的字符串类赋值运算符重载

2 个答案: