C++ - 字符串类的实现

Question

我正在尝试实现字符串类。这是我所做的：

#include <iostream>
#include <cstring>

using namespace std;

class MyString{
    private:
    char * content;
    int length;
    public:
    MyString ();
    MyString ( const char * );
    ~MyString ();
    MyString ( const MyString & );
    void print ( void );
    void operator = ( const MyString );
};

MyString :: MyString () {
    content = 0;
    length = 0;    
}

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


MyString :: ~ MyString () {
    delete [] content;
    content = 0;
}


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

void MyString :: print( void ) {
    cout <<""<< content << endl;
}

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

int main() {
    MyString word1 ("stackoverflow");
    MyString word2;
    word2 = word1;
    word1.print();
    word2.print();
}

我编译了它，这是我得到的：

堆栈溢出

堆栈溢出

进程返回 0 (0x0) 执行时间：0.050 s 按任意键继续。

虽然根据上面的结果看起来是正确的，但我想知道它真的正确吗？我对 C 风格的字符串不太熟悉，所以我很担心 例如关于行：

content [length] = '\0';

由于 C 风格的字符串末尾有空终止符，我想终止我的数组，但这是正确的方法吗？ 我使用了动态内存分配，我也想知道我是否正确释放了资源？ 是否有一些内存泄漏？ 提前致谢。

编辑1： 我还重载了operator +（我想加入“MyStrings”），这里是代码：

MyString MyString :: operator + ( const MyString & x ){
    MyString temp;
    temp.length = x.length + length;
    temp.content = new char [ temp.length +  1 ];
    int i = 0, j = 0;
    while ( i < temp.length ) {
    if (i < length ) {
    temp.content [i] = content [i];
    }
    else {
    temp.content [i] = x.content [j];
    j ++;
    }
    i ++;
    }
    temp.content [ temp.length ] = '\0';
    return temp;
    }

这里是主程序：

int main()
   {
   MyString word1 ( "stack" );
   MyString word2 ( "overflow" );
   MyString word3 = word1 + word2;
   word3.print();
   word3 = word2 + word1;
   word3.print();
   }

结果如下：

堆栈溢出

溢出堆栈

进程返回 0 (0x0) 执行时间：0.040 s 按任意键继续。

我希望这段代码没有问题:)

编辑2： 这是使用 for 循环而不是 while 的 + 运算符的实现：

MyString MyString :: operator + (const MyString & x){
    MyString temp;
    temp.length = x.length + length;
    temp.content = new char [temp.length+1];
    for( int i = 0 ; i < length ; i++ ){
    temp.content[i] = content[i];
    }
    for( int i = length , j = 0 ; i <temp.length ; i++, j++){
    temp.content[i] = x.content[j];
    }
    content[temp.length] = '\0';
    return temp;
}

现在可能更好，因为没有 if :)

Answer 1

您正在尝试为content[length] 分配一个值，但您没有为content[length] 分配足够的内存以供访问。如果length == 10，那么您可以通过content[9] 访问content[0]，但不能访问content[10]。

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

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

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

Answer 2

还有一些其他的注意事项和建议，因为至少还有两个陷阱等着跳出来攻击。

#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] = '\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] = '\0';
*/
    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 可以获得显着的性能提升。

Answer 3

有两个错误。 Thane Plummer 在 cmets 和 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] = '\0';
}

如果您的字符串是以空结尾的“abc\0”，strlen 将返回 3 而不是 4，因此您将只分配 3 个字符而不是 4（编辑：并且要完整，如前所述，您确实开始从 0 而不是 1 开始索引，所以 content[length] 总是会溢出，即使你增加了长度）

另一个错误不那么严重（实际上是合法的但奇怪的 c++）：

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] = '\0';
  return *this;
}