面试题：简易版string(深拷贝与浅拷贝的问题)

如果要实现简易版的string 无需涉及增容问题，成员变量可以不用存储容量和元素个数

构造函数

错误示范

class string
{string(): _str(nullptr){}string(const char* str): _str(str){}char& operator[](size_t i){return _str[i];}size_t size(){return strlen(_str);}private:char* _str;
}
void test
{string s1;string s2("world");for(size_t i = 0; i < s2.size();++i){s2[i]+=1;cout << s2[i] << endl;//这个循环中会报内存错误，为什么呢？}
}

以上的代码会报错，我们具体来分析一下

首先在构造s2的时候我们传过去了一个常量字符串，而常量位于操作系统的代码段中，无法被修改，当传过去以后指针str接收，于是str就指向了代码段中的’w‘这个字符，但无法修改，以至于造成内存错误

图1

以上还带来的其他问题：假如待会要插入字符串，空间不够无法实现怎么办？(如果不是简易版的话怎么办？)

正确示范

思路：通过图1我们可知常量字符串是在代码段的，所以才无法修改，那我们把它放在其他可以修改的地方不就可以了吗？那具体放在哪呢？既然要支持动态增容，那么放在堆上(既可以扩容，又可以修改)是最好的！而s1的构造函数也不能直接把成员变量置为空，因为如果置为空了，那么就无法进行扩容及遍历：string对象创建出来即使没有有效字符也要有一个空间来存放'\0'

class string//正确示范
{string(const char* str = ''): _str(new char[strlen(str)+1])//多出来一个空间是为了存储'\0的'{strcpy(_str,str);}char& operator[](size_t i){return _str[i];}size_t size(){return strlen(_str);}private:char* _str;
}
void test
{string s1;string s2("world");for(size_t i = 0; i < s2.size();++i){s2[i]+=1;cout << s2[i] << endl;}
}

图2

析构函数

class string
{//....~string()//这里是析构函数{delete [] _str;_str = nullptr;}//....private:char* _str;
}

拷贝构造

如果我们不写拷贝构造，那么编译器会自动运行默认的拷贝构造，那么这个拷贝构造有什么问题吗？

class string
{
//...省略这个string类，假如这个类里没有拷贝构造
}
void test
{string s1("world");string s2(s1);
}

假如是以上代码，编译器会怎么执行呢？

编译器会把s1中的成员指针变量指向的地址给s2，并让他们两个指向同一块地址。这也就是所谓的浅拷贝/值拷贝。在执行前期不会出现什么内存问题，但是当执行到s1的析构函数时会造成同一块空间被释放了两次。

图3

解决办法就是：在构造s2时，重新在堆上开一块空间，再把s1的内容拷贝至s2即可

图4

class string
{
//....string(const string& s: _str(new char[strlen(s._str)+1]){strcpy(_str,s._str);}
//....private:char* _str;
}

第二种写法：深拷贝

这种写法就是通过swap函数把要拷贝的string对象的值和当前string对象的值进行交换

string(const string& s):_str(nullptr)//如果不置为空tmp交换完以后就是随机值，析构会报错
{string tmp(s._str);swap(_str,tmp._str);
}

赋值函数（operator=）

思路：这里的思路是先创建一个空间存放右操作数并拷贝，再把成员变量指向那个空间所指向的地方，并记得释放原来的空间

class string
{public://...string& operator=(const string& s){char* tmp = new char[strlen(s._str)+1];strcpy(tmp,s._str)delete [] _str;_str = tmp;}//这里的返回值是为了支持连等，例如s1 = s2 = s3,就是s3先赋给s2，s2再赋给s1private:char* _str;
}

到这里，这个简易版的string就已经实现了，下面让我们看看支持增删查改的string是如何实现的吧

代码区

class string{public:string(const char* str ="")//构造函数:_str(new char[strlen(str)+1]){strcpy(_str, str);}string(const string& s)//拷贝构造: _str(new char[strlen(s._str)+1]){strcpy(_str, s._str);}~string()//析构函数{delete [] _str;_str = nullptr;}string& operator=(const string& s){char* tmp = new char[strlen(s._str) + 1];strcpy(tmp, _str);delete[]_str;_str = tmp;return *this;}size_t size(){return strlen(_str);}char& operator[](size_t i){return _str[i];}private:char* _str;};

完整版string实现

成员变量的变化以及原因

当涉及到增的问题时，就需要有两个变量，一个控制能存多少有效字符，一个控制当前有效字符个数。以及对简易版进行优化

class string
{public:private:char* _str;size_t _capacity;size_t _size;
}

string的构造函数、析构函数、拷贝构造、赋值

这里直接放代码了，不懂看前面

class string{public:string(const char* str = "")//构造函数{_size = strlen(str);_capacity = _size;_str = new char[_capacity+1];strcpy(_str, str);}~string()//析构函数{delete [] _str;_str = nullptr;_size = _capacity = 0;}string(const string& s)//拷贝构造:_str(new char[s._capacity+1]){strcpy(_str, s._str);}string& operator=(const string& s)//赋值{char* tmp = new char[s._capacity + 1];strcpy(tmp, s._str);delete[]_str;_str = tmp;return *this;}size_t size(){return _size;}size_t capacity(){return _capacity;}char& operator[](size_t i){assert (i >= 0);return _str[i];}const char* c_str(){return _str;}private:char* _str;size_t _capacity;size_t _size;};

operator<<

ostream& operator<<(ostream& out, const string& s)//opeartor<<{for (size_t i = 0; i < s.size(); ++i){cout << s[i];}return out;}

operator+=

这里分为三种：①+=常量字符

②+=常量字符串

③+=对象

思想就是：在_size位置直接插入字符，因为把原来的'\0'覆盖了，而c++中字符串的结束标准就是'\0'所以最后在尾上补上'\0'即可，插入字符都要考虑空间，于是封装一个increase用来扩容

class string
{public://....char*& increase(size_t n)//传参数时直接传插入后有效字符的个数{//扩容size_t newcapacity = n;char* tmp = new char[n + 1];_capacity = newcapacity;//拷贝原数组strcpy(tmp, _str);return tmp;}string& operator+=(const char* str)//+=字符串{size_t len = strlen(str);//扩容及直接插入while (*str != '\0'){//判断是否扩容if (_capacity == _size){char* tmp = increase(_capacity+len);delete[] _str;_str = tmp;}//插入_str[_size] = *str;++_size;++str;}//补上'\0';_str[_size] = '\0';    return *this;}string& operator+=(const char ch)//+=字符{//判断是否扩容if (_size == _capacity){char* tmp = increase();delete[] _str;_str = tmp}//插入字符_str[_size] = ch;_size++;//补上'\0'_str[_size] = '\0';return *this;}string& operator+=(const string& s)//+=对象{size_t len = s._size;//扩容if (_size + len > _capacity){char* tmp = increase(_capacity+len);delete[] _str;_str = tmp;}//赋值，转化为operator(const char* ch)*this += (s._str);return *this;}//....}private:char* _str;size_t _capacity;size_t _size;
}

operator>>

    istream& operator>>(istream& in, string& s) {char ch = in.get();//先获取一个字符while (ch == '\n'|| ch ==' ')//如果获取的字符是空格或换行则跳出循环 {s += ch;ch = in.get();//这里继续获取，反复进入while循环的判断}return in;}

任意位置的插入与删除(insert)

这里实现两个：

①字符串在pos位置的插入

②字符在pos位置的插入

这里用两种思想，一种是先插入后挪动(字符常量用的是这种)，一种是先挪动再插入(字符串用的是这种)

        string& insert(size_t pos, char ch){assert(pos<size)//插入*this += ch;int end = _size - 1;//挪动数据while (end >= pos){_str[end + 1] = _str[end];--end;}//插入及补上'\0'_str[end+1] = _str[_size];_str[_size] = '\0';return *this;}string& insert(size_t pos, const char* str){assert(pos <= _size);//判断扩容size_t len = strlen(str);if (_size + pos > _capacity){_str = increase(_size + pos);}//挪动数据int end = _size;while (end >= (int)pos){_str[end + len] = _str[end];--end;}//插入数据for (size_t i = 0; i < len; ++i){_str[pos++] = str[i];}_size += len;return *this;}

迭代器(iterator)

string的迭代器比较简单，本质就是一个指针

class string
{public:typedef char* iterator//定义迭代器 iterator begin(){return _str;}iterator end(){return _str + _size;}//....private:char* _str;
}
//测试迭代器void test(){string s1("hello");string::iterator it = s1.begin();while (it != s1.end()){cout << *it << ' ';++it;}}

查找(find)

查找字符

        size_t find(char ch, size_t pos = 0)//从pos位置开始往后找，找到返回下标{assert(pos >= 0);size_t i = pos;//找到返回下标while (i < _size){if (_str[i] == ch){return i;}++i;}//没找到返回npos，npos是静态成员变量默认值为-1return npos;}return npos;}size_t find(const char* str, size_t pos = 0){assert (pos >= 0);char* tmp = strstr(_str + pos, str);if (tmp == NULL)return npos;elsereturn tmp - _str; }

operator<,==,<=,>,>=,!=

bool operator<(const string& s){int i = strcmp(_str, s._str);if (i >= 0)return false;elsereturn true;}bool operator==(const string& s){int i = strcmp(_str, s._str);if (i == 0)return true;elsereturn false;}bool operator<=(const string& s){return *this < s || *this == s;}bool operator>(const string& s){return !(* this <= s);}bool operator>=(const string& s){return !(* this < s);}bool operator!=(const string& s){return !(*this == s);}

删除(erase)

        void erase(size_t pos, size_t len = npos)//从pos位置开始删，删除len个字符{//第二种情况if (len >= _size - pos)//如果{_str[pos] = '\0';_size = pos;}//第一种情况else{for (size_t i = pos + len; i <= _size; ++i){_str[i - len] = _str[i];}_size -= len;}}