STL-string类模拟实现

先来看一道利用string接口实现的oj题目：反转字符串

class Solution {
public:
    string reverseString(string s) {
        if (s.empty())
            return s;
        
        size_t begin = 0;
        size_t end = s.size() - 1;
        
        while (begin < end){
            swap(s[begin], s[end]);
            ++begin;
            --end;
        }
        
        return s;
    }
};

由上述题目可以看出string容器的强大之处，那么即然他这么强大，我们就来看看string接口的底层实现

模拟实现string类，最主要是实现String类的构造、拷贝构造、赋值运算符重载以及析构函数

实现之前我们先来看看何为深浅拷贝问题：

class String
{
public:
	String(const char *str = "")
		:_str(new char[strlen(str) + 1])
	{
		strcpy(_str, str);
	}

	~String()
	{
		if (_str){
			delete[] _str;
			_str = nullptr;
		}
	}
private:
	char *_str;
};

int main()
{
	String s1("hello world!");
	String s2(s1);
        String s3;
	s3 = s1;
	return 0;
}

结果：

 

 

画图了解一下：

 

 

现在明白了：

上述String类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认的，当用s1构
造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块
空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。

浅拷贝：也称值拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以 当继续对资源进项操作时，就会发生发生了访问违规。

 

为了解决浅拷贝问题：引入了深拷贝方式

如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。

 

码代码：https://github.com/xiaobaiyuan-bit/c--stl-string1/blob/master/rocket_c%2B%2B_1.6/rocket_c%2B%2B_1.6/test.cpp

//传统版本String类实现
class String
{
public:
	String(const char *str = "")
	{
		if (nullptr == str){
			assert(str);
			return;
		}
		_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& operator=(const String& s)
	{
		if (this != &s){
			char *pstr = new char[strlen(s._str) + 1];
			strcpy(pstr, s._str);
			delete[] _str;
			_str = pstr;
		}
		return *this;
	}

	~String()
	{
		if (_str){
			delete[] _str;
			_str = nullptr;
		}
	}
private:
	char *_str;
};

 

//现代版本的实现
class String
{
public:
	String(const char *str = "")
	{
		if (nullptr == str)
			str = "";//新写法

		_str = new char[strlen(str) + 1];
		strcpy(_str, str);
	}

	String(const String& s)
		:_str(nullptr)
	{
		String StrTmp(s._str);
		swap(_str, StrTmp._str);//新写法
	}

	/*String& operator=(const String& s)
	{
		if (this != &s){
			String StrTmp(s);
			swap(_str, StrTmp._str);//新写法
		}
		return *this;
	}*/
	String& operator=(String s)//新写法(参数是创建一个临时对象[调用了拷贝构造函数])
	{
		swap(_str, s._str);//新写法
		return *this;
	}

	~String()
	{
		if (_str){
			delete[] _str;
			_str = nullptr;
		}
	}
private:
	char *_str;
};

写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的

引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给
计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该
对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。

参考相关详细解说：

https://coolshell.cn/articles/12199.html【写时拷贝】

https://coolshell.cn/articles/1443.html【写时拷贝在读取是的缺陷】

 

 string类的模拟实现代码：https://coolshell.cn/articles/10478.html【扩展阅读】

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <assert.h>
using namespace std;

class String
{
public:
	typedef char*  iterator;

public:
	String(const char *str = "")
	{
		if (nullptr == str)
			str = "";

		_size = strlen(str);
		_capacity = _size;//库里放的是15个字节
		_str = new char[_capacity + 1];//注意这里开辟的是容量大小空间，不是有效字符空间
		strcpy(_str, str);
	}

	String(const String& s)
		:_str(nullptr)
	{
		String StrTmp(s._str);
		Swap(StrTmp);
	}

	String& operator=(const String& s)
	{
            if (this != &s){
                String StrTmp(s._str);
                Swap(StrTmp);
            }
            return *this;
	}

	~String()
	{
		if (_str){
	            delete[] _str;
		    _str = nullptr;
                    _size = 0;
                    _capacity = 0;
		}
	}


        void Swap(String& s)
        {
             swap(_str, s._str);
             swap(_size, s._size);
             swap(_capacity, s._capacity);
        }

	///
	// iterator 迭代器
	iterator Begin()//返回字符串指针
	{
		return _str;
	}

	iterator End()//返回字符串指针
	{
		return _str + _size;
	}

	///
	// modify 修改

	void PushBack(char c)
	{
		//是否增容
		if (_size == _capacity)
			Reserve(_capacity * 2);//

		_str[_size++] = c;
		_str[_size] = '\0';//
	}

	String& operator+=(char c)
	{
		PushBack(c);
		return *this;
	}

	String& Append(size_t n, char c)
	{
		for (size_t i = 0; i < n; ++i)
			PushBack(c);

		return *this;
	}


	///
	// capacity 容量
	void Reserve(size_t newCapacity)//增容需要在空间开辟新空间
	{
		//新空间大于旧空间才需要增容
		if (newCapacity > _capacity){
			char *str = new char[newCapacity + 1];
			strcpy(str, _str);

			delete[] _str;//释放旧空间
			_str = str;
			_capacity = newCapacity;//新空间的容量[不能+1]
		}
	}

	void Resize(size_t newsize, char c = '\0')
	{
		if (newsize > _size){
			//newsize大于原空间容量则需要开辟新空间
			if (newsize > _capacity)
				Reserve(newsize);

			memset(_str + _size, c, newsize - _size);
		}

		_size = newsize;
		_str[_size] = '\0';
	}

	size_t Capacity()const
	{
		return _capacity;
	}

	size_t Size()const
	{
		return _size;
	}

	size_t Length()const
	{
		return _size;
	}

	bool Empty()const
	{
		if (0 == _size)
			return 1;
		else
			return 0;
	}

	void Clear()
	{
		_size = 0;
	}


	///
	//访问
	char& operator[](size_t pos)
	{
		assert(pos < _size);//小心越界访问
		return _str[pos];
	}

private:
	char *_str;
	size_t _size;
	size_t _capacity;
};

void TestString1()
{
	String s1("hello");
	s1.Append(100, '!');
}

int main()
{
	TestString1();
	return 0;
}