C++中简单的string类的实现详解

String

在C++的学习生涯我中发现String类的功能十分强大，所以我们是很有必要模拟实现它的，况且在面试的时候模拟实现一个String类也是面试官经常会考的，但是因为外界因素的限制我们是不可能模拟的和库里的string一致的(C++库里的string功能更强大)，所以今天我们只模拟实现string的基本功能-构造函数，拷贝构造函数，析构函数，赋值运算符重载，运算符+=的重载，运算符[]的重载，c_str(得到一个C风格的字符指针，可操作字符串)，Size,Push_Back,Insert(深拷贝)，以及用写时拷贝copy_on_write的方式实现基本的String类

深拷贝的方式
      

class String 
{ 
    friend ostream &operator<<(ostream &os,String &s); 
public: 
    String(const char *str="");  //全缺省的构造函数，解决空字符串的问题 
    String(const String &ps);    //深拷贝 
    String &operator=(String s); 
    String &operator+=(const char * s); 
    const char *C_Str()const    //得到C风格的字符指针 
    { 
        return _pstr; 
    } 
    char &operator[](size_t index) 
    { 
        return _pstr[index]; 
    } 
    size_t Size()const 
    { 
        return _size; 
    } 
    void PushBack(char c); 
    String &Insert(size_t pos,const char *str); 
    //String &operator=(String &s) 
    //{ 
    //  cout<<"String &operator=(String &s)"<     //  if(this != &s) 
    //  { 
    //      delete[]_pstr; 
    //      _pstr=new char[strlen(s._pstr)+1]; 
    //      strcpy(_pstr,s._pstr); 
    //  } 
    //  return *this; 
    //} 
    ~String() 
    { 
        cout<<"~String()"<         if(_pstr != NULL) 
        { 
            delete[]_pstr; 
            _pstr=NULL; 
            _size=0; 
            _capacity=0; 
        } 
    } 
private: 
    void CheckCapacity(int count); 
private: 
    int _size; 
    int _capacity; 
    char *_pstr; 
}; 
 
ostream &operator<<(ostream &os,String &s) 
{ 
    os<     return os; 
} 
 
String::String(const char *str) 
    :_size(strlen(str)) 
    ,_capacity(strlen(str)+1) 
    ,_pstr(new char[_capacity]) 
{ 
    cout<<"String()"<     strcpy(_pstr,str); 
} 
 
String::String(const String &ps) 
    :_size(ps._size) 
    ,_capacity(strlen(ps._pstr)+1) 
    ,_pstr(new char[_capacity]) 
{ 
    cout<<"String(const String &ps)"<     strcpy(_pstr,ps._pstr); 
} 
 
String &String::operator=(String s) 
{ 
    cout<<"String &operator=(String s)"<     std::swap(_pstr,s._pstr); 
    std::swap(_size,s._size); 
    std::swap(_capacity,s._capacity); 
    return *this; 
} 
 
void String::CheckCapacity(int count) 
{ 
    if(_size+count >= _capacity) 
    { 
        int _count=(2*_capacity)>(_capacity+count)?(2*_capacity):(_capacity+count); 
        char *tmp=new char[_count]; 
        strcpy(tmp,_pstr); 
        delete[]_pstr; 
        _pstr=tmp; 
        _capacity=_count; 
    } 
} 
 
void String::PushBack(char c) 
{ 
    CheckCapacity(1); 
    _pstr[_size++]=c; 
    _pstr[_size]=''; 
} 
 
String &String::operator+=(const char * s) 
{ 
 
    CheckCapacity(strlen(s)); 
    while(*s) 
    { 
        _pstr[_size++]=*s; 
        s++; 
    } 
    _pstr[_size]=''; 
    return *this; 
} 
 
String &String::Insert(size_t pos,const char *str) 
{ 
    char *tmp=new char[strlen(_pstr+pos)]; 
    strcpy(tmp,_pstr+pos); 
    CheckCapacity(strlen(str)); 
    while(*str) 
    { 
        _pstr[pos++]=*str; 
        str++; 
    } 
    strcpy(_pstr+pos,tmp); 
    return *this; 
} 

     通过测试上述代码可正常运行，特别是在实现赋值运算符重载的时候我们使用了两种方式，值得一提的是应用swap函数来实现赋值运算符的重载(在传参时不可以传引用)，因为应用swap函数实现是根据临时变量的创建并且该临时变量出作用域就会自动调用析构函数销毁(现代的方法)
     测试深拷贝的方法
    

void text1() 
{ 
    String str1("hello"); 
    String str2(str1); 
    String str3; 
    str3=str1; 
    cout<     cout<     cout<  
    cout<  
    str1[4]='w'; 
    cout< } 
 
void text2() 
{ 
    String str1("abcd"); 
    cout<     str1.PushBack('e'); 
    str1.PushBack('f'); 
    str1.PushBack('g'); 
    str1.PushBack('h'); 
    str1.PushBack('i'); 
    cout<  
    cout< } 
 
void text3() 
{ 
    String str1("hello"); 
    String str2("hello world"); 
    String str3(str2); 
    str1+=" "; 
    str1+="world"; 
    cout<  
    str2.Insert(6," abc "); 
    cout< } 

       实现了深拷贝的方法那仫有没有更加高效的方法呢？当然，那就是写时拷贝，我们发现在上述深拷贝的版本里实现的拷贝构造函数又为新的对象重新开辟空间(防止浅拷贝的后遗症：浅拷贝是值拷贝使得两个指针指向同一块空间，在析构该空间时对同一块空间释放多次就会出现问题)，那仫如果我们继承了浅拷贝的后遗症-就让多个指针指向同一块空间，此时我们只需要设置一个指针变量让它记录指向这块空间的指针个数，在析构时只要该指针变量的内容为1我们就释放这块空间否则就让计数器减1，这就是写时拷贝的主要思想，下面就让我们用写时拷贝的方法实现一个简单的String类吧
       写时拷贝的方法
      

//写时拷贝的方式 
class String 
{ 
    friend ostream& operator<<(ostream & os,String &s); 
public: 
    String(const char *str="") 
        :_str(new char[strlen(str)+1+4]) 
    { 
        cout<<"构造"<         _str+=4; 
        *((int *)(_str-4))=1; 
        strcpy(_str,str); 
    } 
    String(String &s) 
    { 
        cout<<"拷贝构造"<         ++*((int *)(s._str-4)); 
        _str=s._str; 
    } 
    String &operator=(const String &s) 
    { 
        cout<<"赋值语句"<         if(--*(int *)(_str-4) == 0) 
        { 
            delete[](_str-4); 
        } 
        ++(*(int *)(s._str-4)); 
        _str=s._str; 
        return *this; 
    } 
    char &operator[](int index)  //写时拷贝 
    { 
        assert(index >= 0 && index < (int)strlen(_str)); 
        if(*(int *)(_str-4) > 1) 
        { 
            --*(int *)(_str-4); 
            char *tmp=new char[strlen(_str)+5]; 
            strcpy(tmp+4,_str); 
            delete[](_str-4); 
            _str=tmp+4; 
            *(int *)(_str-4)=1; 
        } 
        return _str[index]; 
    } 
    ~String() 
    { 
        cout<<"析构"<         if(--*(int *)(_str-4) == 0)  
        { 
            cout<<"释放"<             delete[](_str-4); 
        } 
    } 
private: 
    char *_str; 
}; 
ostream& operator<<(ostream &os,String &s) 
{ 
    os<     return os; 
} 

      在这里我们将指针指向的计数器的位置放置在数据空间的前四个字节处
      测试用例：
     

void test1() 
{ 
    String str1("abcd"); 
    cout<     String str2(str1); 
    cout<     String str3; 
    str3=str1; 
    cout< } 
 
void test2() 
{ 
    String str1("abcd"); 
    cout<     String str2; 
    str2=str1; 
    cout<     str2[2]='w'; 
    cout< } 

面试中string类的一种正确写法

能像 int 类型那样定义变量，并且支持赋值、复制。
能用作函数的参数类型及返回类型。
能用作标准库容器的元素类型，即 vector/list/deque 的 value_type。（用作 std::map 的 key_type 是更进一步的要求，本文从略）。
换言之，你的 String 能让以下代码编译运行通过，并且没有内存方面的错误。

void foo(String x)
{
}

void bar(const String& x)
{
}

String baz()
{
  String ret("world");
  return ret;
}

int main()
{
  String s0;
  String s1("hello");
  String s2(s0);
  String s3 = s1;
  s2 = s1;

  foo(s1);
  bar(s1);
  foo("temporary");
  bar("temporary");
  String s4 = baz();

  std::vector svec;
  svec.push_back(s0);
  svec.push_back(s1);
  svec.push_back(baz());
  svec.push_back("good job");
}
本文给出我认为适合面试的答案，强调正确性及易实现（白板上写也不会错），不强调效率。某种意义上可以说是以时间（运行快慢）换空间（代码简洁）。

首先选择数据成员，最简单的 String 只有一个 char* 成员变量。好处是容易实现，坏处是某些操作的复杂度较高（例如 size() 会是线性时间）。为了面试时写代码不出错，本文设计的 String 只有一个 char* data_成员。而且规定 invariant 如下：一个 valid 的 string 对象的 data_ 保证不为 NULL，data_ 以 '' 结尾，以方便配合 C 语言的 str*() 系列函数。

其次决定支持哪些操作，构造、析构、拷贝构造、赋值这几样是肯定要有的（以前合称 big three，现在叫 copy control）。如果钻得深一点，C++11的移动构造和移动赋值也可以有。为了突出重点，本文就不考虑 operator[] 之类的重载了。

这样代码基本上就定型了：

#include
#include

class String
{
 public:
  String()
    : data_(new char[1])
  {
    *data_ = '';
  }

  String(const char* str)
    : data_(new char[strlen(str) + 1])
  {
    strcpy(data_, str);
  }

  String(const String& rhs)
    : data_(new char[rhs.size() + 1])
  {
    strcpy(data_, rhs.c_str());
  }
  /* Delegate constructor in C++11
  String(const String& rhs)
    : String(rhs.data_)
  {
  }
  */

  ~String()
  {
    delete[] data_;
  }

  /* Traditional:
  String& operator=(const String& rhs)
  {
    String tmp(rhs);
    swap(tmp);
    return *this;
  }
  */
  String& operator=(String rhs) // yes, pass-by-value
  {
    swap(rhs);
    return *this;
  }

  // C++ 11
  String(String&& rhs)
    : data_(rhs.data_)
  {
    rhs.data_ = nullptr;
  }

  String& operator=(String&& rhs)
  {
    swap(rhs);
    return *this;
  }

  // Accessors

  size_t size() const
  {
    return strlen(data_);
  }

  const char* c_str() const
  {
    return data_;
  }

  void swap(String& rhs)
  {
    std::swap(data_, rhs.data_);
  }

 private:
  char* data_;
};
注意代码的几个要点：

只在构造函数里调用 new char[]，只在析构函数里调用 delete[]。
赋值操作符采用了《C++编程规范》推荐的现代写法。
每个函数都只有一两行代码，没有条件判断。
析构函数不必检查 data_ 是否为 NULL。
构造函数 String(const char* str) 没有检查 str 的合法性，这是一个永无止境的争论话题。这里在初始化列表里就用到了 str，因此在函数体内用 assert() 是无意义的。
这恐怕是最简洁的 String 实现了。

练习1：增加 operator==、operator<、operator[] 等操作符重载。

练习2：实现一个带 int size_; 成员的版本，以空间换时间。

练习3：受益于右值引用及移动语意，在 C++11 中对 String 实施直接插入排序的性能比C++98/03要高，试编程验证之。（g++的标准库也用到了此技术。）