string类（c++）

       string类是c++默认提供的，但是了解string类的写法也是非常重要的，面试中有许多关于string类的题目，string类能够考察c++类和对象的掌握程度，一定程度上也考察了面试者的编程能力。

  

      下面是string类的一些基本功能，由于面试的时间很短，在这极短的时间内全部实现string类的功能是不可能的，我们可以实现最基本的功能，类中的构造函数、析构函数、赋值，复制的功能。

class String
{
public:
    String()     //无参构造函数
       :_str(new char[1])    
   {
        _str[0] = '\0';
    }
    
    String(const char * str)     //构造函数
        :_str(new char[strlen(str)+1])  
    //多开辟一个字符的空间，因为strcpy函数会将'\0'也进行拷贝，而strlen不计算'\0';
    {
        strcpy(_str, str);
    }
    
    //String(const String & s)    //拷贝构造函数
    // :_str(new char[strlen(s._str)+1])
    //{
    // strcpy(_str, s._str);
    //}
    
    //现代写法
    String(const String & s)
        :_str(NULL)
    {
        String tmp(s._str);
        swap(_str, tmp._str);
    }
    
    ~String()    //析构函数
    {
        if (_str != NULL)
        {
            delete[] _str;
            _str = NULL;
            _size = 0;
            _capaciy = 0;
        }
    }
    
 //String operator==(const String & s)   //字符串相等(先开辟空间，然后释放，防止内存泄漏)
 //{
 // if (this != &s)
 // {
 //  char * tmp = new char[strlen(s._str) + 1];
 //  strcpy(_str, s._str);
 //  delete[] _str;
 // }
 //}
 
 //现代写法
    String operator==(String s)
    {
        swap(_str, s._str);
        return *this;
    }
    
    String operator<(const String & s)   //字符串小于
    {
        char *tmp = s._str;
        while (_str != '\0' && tmp != '\0')
        {       
            if (_str == tmp)
            {
                _str++;
                tmp++;
             }
            else if (_str < tmp)
            {
                return *this;
             }
            else
            {
                return s._str;
             }
        }
     }
     
     String operator<=(const String & s)    //字符串小于等于
     {
         char *tmp = s._str;
         if (_str <= tmp)
         {
             return *this;
          }
         else
        {
            return s._str;
         }
     }
     
     String operator>(const String & s)    //字符串大于
     {
         char *tmp = s._str;
         while (_str != '\0' && tmp != '\0')
        {
            if (_str == tmp)
            {
                _str++;
                tmp++;
            }
            else if (_str > tmp)
           {
               return *this;
            }
            else
           {
               return s._str;
           }
       }
    }
    
     String operator>=(const String & s)    //字符串大于等于
    {
        char *tmp = s._str;
        if (_str >= tmp)
        { 
            return *this;
        }
        else
        {
            return s._str;
        }
    }
    
    char operator[](size_t index)
    {
        return _str[index];
     }
     
    void pushBack(char ch)    //压入栈中
    {
        _checkCapacity(_size + 2);
        _str[_size] = ch;
        _str[_size + 1] = '\0';
    }
    
    void popBack()     //出栈
    {
        assert(_str);
        _size--;
        _str[_size] = '\0';
     }
     
    void Insert(size_t pos, char ch)    //插入字符
    {
        assert(pos <= _size);
        //_checkCapacity(_size);
        size_t tmp = _size;
        while (tmp >= pos)
       {
           _str[tmp + 1] = _str[tmp];  //从后往前移动
           tmp--;
        }
        _str[pos] = ch;
        _size++;
     }
     
     void Insert(size_t pos, const char *str)   //插入字符串
     {
         assert(pos <= _size);
         size_t size = strlen(str);      //增容
         _checkCapacity(size + 1 + _size);
         size_t tmp = _size;          //移位
         while (tmp >= pos)
        {
            _str[tmp + size] = _str[tmp];
            tmp--;
         }
         for (size_t i = 0; i < size; i++)    //插入
        {
             _str[pos] = str[i];
             pos++;
         }
         _size += size;
     }
     
     int Find(char ch)    //查找字符
     {
         int pos = 1;
         while (_str != '\0')
        {
            if (*_str == ch)
            {
                return pos;
             }
            else
            {
                _str++;
            }
            pos++;
        }
        return 0;
     }
     
     size_t Find(const char *sub)   //查找子串
     {
         size_t srcIndex = 0;
         size_t subSize = strlen(sub);
         while (srcIndex <= _size - subSize)
         {
             size_t subIndex = 0;
             size_t begin = srcIndex;
             while (_str[begin] == sub[subIndex] && begin < _size && subIndex < subSize)
             {
                 begin++;
                 subIndex++;
             }
             if (subIndex == subSize)
             {
                 return srcIndex;
             }
             srcIndex++;
         }
     }
     
     String & operator+=(const String & s)   //+=
     {
         Insert(_size, s._str);
         return *this;
      }
      
     void Display()
     {
         while (_str != '\0')
        {
            cout << *_str;
            _str++;
        } 
     }
     
private:
    char *_str;
    size_t _size;
    size_t _capaciy;
    
private:
    void _checkCapacity(size_t needsize)
    {
        if (needsize + 1 >= _capaciy)
        {
            _capaciy = needsize > 2 * _capaciy ? needsize : 2 * _capaciy;
            _str = (char *)realloc(_str, _capaciy);
        }
    }
};

本文出自 “无心的执着” 博客，谢绝转载！