实现MyString类（二）—MyString.cpp实现

 

   紧接着上章的类声明，这章实现.cpp文件：

1.构造函数和析构函数：

                  MyString::MyString() { length = 0; string = new char; char *s = "/0"; memcpy(string,s,1); ++string_number; } MyString::MyString(const char*str) { length = strlen(str); string = new char(length+1); memcpy(string,s,length); ++string_number; } MyString::MyString(MyString &str) { length = str.length; string = str.string; ++string_number; } MyString::~MyString() { delete[]string; --string_number; }

 

                  

   几个注意的问题：

  1）构造函数中必须给所有的数据成员进行初始化。

  2）注意在给指向字符串的指针赋值时，左右类型的对应。

      char *s代表一个指向字符串的指针，所有右边必须是一个字符串常量“/0”,而不能是‘/0’.

  3)一个指针只能指向一个地址，不能同时指向两个。

     在给string分配了地址之后，下一步我们肯定是确定分配的地址中存放的具体内容，那么这个时候我们都是使用strcpy()或者是

      memcpy（）把对应的字符串存入地址中。

      如果原来我们成这样实现：

     MyString::MyString()

   {

       length = 0;

       string = new char;

       string = "/0";

       ++string_number;

    }

     那么我们在编译和实现的时候都不会发现有什么错，但是析构函数使用delete【】释放内存使执行结果会出现乱码，因为string=“/0”

     让它指向了一个字符串，并没有分配内存空间，所以在释放的时候就会出现错误。

  4）析构函数中的重要语句 delete【】不要忘

      析构函数在使用的时候只会释放为对象分配的空间，但是对象的空间中只是存储了数据成员分配内存的地址，所以并没有释放数据成员

      的内存空间，必须使用delete[]来进行释放，防止内存泄露  

  2.重载运算符的成员函数：

 

                   MyString &MyString::operator+=(const MyString&str) { char *dest; dest = new char[str.length+length+1]; memcpy(dest,string,length); memcpy(dest+length,str.string,str.length+1); delete[]string; length = length+str.length; string = dest; return*this; } MyString &MyString::operator+=(const char*str) { char *dest; dest = new char[strlen(str)+length+1]; memcpy(dest,string,length); memcpy(dest+length,str,strlen(str)+1); delete[]string; string = dest; return *this; } //字符串赋值 MyString &MyString::operator=(const MyString&str) { if(&str == this) return *this; delete[]string; string = new char[str.length]; memcpy(string,str.string,str.length); length = str.length; return *this; }  

   注意的幾個問題：

     1）+=运算中，调用函数的对象最终字符串长度肯定大于其原来的长度，所以在这个函数调用过程中，我们必须给字符串重新分配一块

         两个字符串长度和大小的内存区域。但是因为函数返回值又必须是原调用对象的引用，所以我们要定义一个中间变量指针来存储2个

         字符串合并结果，最后释放string指针原来的内存区域后，再让它指向合并字符串。

     2）“=”赋值运算肯定和构造函数的初始化不一样。

          在使用这个方法以前，那么对象肯定至少已经通过调用构造函数数据成员有了一定的值。所以这个时候我们首先判断两个对象是否

          相等。相等的话返回原对象，如果不等：

          那么两个对象的字符串长度肯定不同。所以我们先释放原字符串内存空间，然后根据赋值对象的字符串长度分配内存空间并把字符

          串内存拷贝过去。

    3.字符串处理的几个函数：

                    size_t MyString::getsize(MyString &str) { return strlen(str.string); } void MyString::clear() { length = 0; while(string!='/0') *string ='/0'; } bool MyString::empty() { return strlen(string)==0; } int MyString ::compare(const MyString &str) { return compare(string,str.string); } void MyString::swap(MyString &str) { char *temp; temp = string; string = str.string; str = temp; } Mystring MyString::substr(sizez_t pos=0,size_t n )const { MyString string; delete[]string.string; if(n>length) { string.length = length; string.string = new char[length+1]; memcpy(string.string,string,length+1); return string; } length = n; string.string = new char[length+1]; memcpy(string.string,string,length+1); return string; }

       注意的几个问题：

       1）在这几个函数的实现中，我们可以直接调用c语言中几个对字符串处理的<string.h>函数进行实现

       2）clear（）函数中注意，只是把每个内存区域的字符置为0，并不能通过delete[]来释放内存空间，这样很容易和析构函数一起造成

           两次释放内存空间引起错误。

       3）swap()实现交换的这个函数中，我们可以直接定义中间变量指针实现，不用重新分配内存空间全部进行转存，这个对于析构函数

           的析构没有影响。

     4.友元函数：

                    friend bool operator==(const MyString &str1,const MyString &str2) { return strcmp(str1.string,str2.string)==0; } friend MyString operator+(const MyString &str1,const MyString &str2) { MyString mystring; char *dest; dest = new char[str1.length+str2.length+1]; memcpy(dest,str1.string,str1.length); memcpy(dest+str1.length,str2.string,str2.length+1); delete[]mystring.string; mystring.string = dest; mystring.length = str1.length+str2.length; return mystring; } friend ostream &operator<<(ostream &os,const MyString &str) { os<<str.string; return os; }

           注意的问题和上面差不多，这里就不重复了~~~

           其他几个函数实现都基本雷同~

          

           终于贴完了，准备总结~~~~