C++-字符串类的实现

您正试图为content[length]分配一个值，但尚未为访问content[length]分配足够的内存。如果是length == 10，则可以访问content[0]到content[9]，但不能访问content[10]。

当然，这可以通过从两个构造函数中删除行content[length] = 来解决，或者如果要追加，则应将length的值增加1。

您是否考虑过只在内部使用std::string？

编辑：@Thane Plummer是第一个在评论中指出这一点的！

其他一些注意事项和建议，因为至少还有两个gotcha在等待跳出并罢工。

#include <iostream>
#include <cstring>
// using namespace std; DANGER! namespace std is huge. Including all of it can
// have tragic, unforeseen consequences. Just use what you need.
using std::cout;
using std::endl;

class MyString
{
private:
    char * content;
    int length;
// will use clone to reduce duplication in the copy constructor and operator =
    void copy(const MyString & source);
public:
    MyString();
// it is nice to name the variables in the definition. The header may be the
// only documentation the user gets.
    MyString(const char * source);
    ~MyString();
    MyString(const MyString &source);
    void print(void);
// changed prototype to match the expected format operator= format
    MyString & operator =(const MyString &source);
//OP asked about this in a previous question.
    friend std::ostream & operator<<(std::ostream & out,
                                     const MyString& towrite);
};
MyString::MyString()
{
//    content = 0; 
//destructor needs something to delete[]. If content isn't set to something,
//you'll get a big ka-BOOM! when the MyString is destroyed
    content = new char[1];
    content[0] = ''; //this has the advantage of printing an empty MyString 
                       // without crashing
    length = 0;
}

MyString::MyString(const char *source) // Variable names should describe their purpose
{
    //DANGER: strlen will fail horribly if passed an unterminated string. At a
    // loss at the moment for a good, safe solution. Look into strnlen, but
    // even it can't help you here.
    length = strlen(source);
    content = new char[length + 1]; //Needed one extra character to fit the NULL
/* If we got this far without dying, strcpy is no threat which makes this redundant:
    for (int i = 0; i < length; i++)
    {
        content[i] = n[i];
    }
    content[length] = '';
*/
    strcpy(content, source);
}
MyString::~MyString()
{
    delete[] content;
//    content = 0; string is gone. No need to clear this
}
void MyString::copy(const MyString & source)
{
    length = source.length;
    content = new char[length + 1];
// assuming that the source MyString is correctly formatted this is once again safe.
    strcpy(content, source.content);
}
MyString::MyString(const MyString & source)
{
    copy(source); // use the copy method
}
void MyString::print(void)
{
    cout << "" << content << endl;
}
MyString &MyString::operator =(const MyString &source)
{
    copy(source); // use the copy method again.
    return *this; // allows chaining operations
}
std::ostream & operator<<(std::ostream & out,
                          const MyString& towrite)
{
    out << towrite.content;
    return out;
}
int main()
{
    MyString word0;
    MyString word1("stackoverflow");
    MyString word2;
    word2 = word1;
    MyString word3(word2); //testing copy constructor
    word1.print();
    word2.print();
    cout << word3 << endl; //testing outstream overload
    // test output of empty string
    word0.print(); 
    cout << word0 << endl; 
}

编辑：

发布后意识到，由于我们知道字符串的长度，使用memcpy(content, source.content, length+1);代替strcpy可以显著提高性能。

有两个错误。Thane Plummer在评论中和Tas在回答中已经指出了一点：

MyString :: MyString(const char *n) {
  length = strlen(n);
  content = new char [length];
  for( int i = 0 ; i < length ; i++ ){
    content [i] = x.content [i];
  }
  content [length] = '';
}

如果您的字符串是以null结尾的"abc\0"，strlen将返回3而不是4，因此您将只分配3个字符而不是4(编辑：为了完整，如前所述，您确实从0而不是1开始索引，因此content[length]将始终溢出，即使您增加长度(

另一个错误不那么严重(实际上是合法的，但很奇怪(：

void operator = ( const MyString );

复制赋值运算符应该采用const引用而不是const值(否则您可能会无用地调用复制构造函数(，并返回引用而不是void(这样您就可以链接一些调用(。正确的声明是：

MyString& operator=(const MyString&);

正确的实现是：

MyString& MyString::operator=(const MyString& x) {
  length = x.length;
  delete[] content;
  content = new char [length];
  for( int i = 0 ; i < length ; i++ ){
    content [i] = x.content [i];
  }
  // actually not needed since x.content should already be null-terminated
  // content[length - 1] = '';
  return *this;
}