C++_String类

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

class String{
public: 
	//构造函数
	String(char* str = "")
		//:_str(new char[strlen(str) + 1])
	{   
		_size = strlen(str);
		_capacity = _size;
		_str = new char[_capacity + 1];
         strcpy(_str, str);
	}
	//析构函数
	~String()
	{
		if (_str)
		{
			delete[] _str;
		}
	}
	//拷贝构造(深拷贝普通写法)
	String(const String& s)  
	{
		//开辟空间
		_str = new char[strlen(s._str) + 1];
		strcpy(_str, s._str);
	}
	//拷贝构造(深拷贝现代写法)
	String(const String& s)
	{
		String tmp(s._str);
		swap(_str, tmp._str);
	}

	//赋值运算符的重载
	//s2=s1->s1.operator=(&s1,s2)
	String& operator=(const String& s)//普通写法
	{
		if (this != &s)
		{
			delete[] _str;
			_str = new char[strlen(s._str) + 1];
			strcpy(_str, s._str);
		}
		return *this;
	}

	//String& operator=(const String& s)//现代写法
	//{
	//	if (this != &s)
	//	{
	//		String tmp(s._str);//调用构造函数初始化对象tmp
	//		swap(_str, tmp._str);
	//	}
	//	return *this;
	//}

	void Swap(String& s)
	{
		swap(_str, s._str);
		swap(_size, s._size);
		swap(_capacity, s._capacity);
	}
	char* Getstr()
	{
		return _str;
	}
	size_t Getsize()
	{
		return _size;
	}
	size_t Getcapacity()
	{
		return _capacity;
	}

	void Expand(size_t n)
	{
		if (n > _capacity)
		{
			_str = (char*)realloc(_str, n + 1);
			assert(_str);
			_capacity = n;
		}
	}
	//尾部插入一个字符
	void PushBack(char ch)
	{
		if (_size == _capacity)
		{
			Expand(_capacity * 2);
		}
		_str[_size] = ch;
		++_size;
		_str[_size] = '\0';
	}
	//尾部插入一个字符串
	void PushBack(const char* str)
	{
		size_t len = strlen(str);
		if ((_size + len) > _capacity)
		{
			Expand(_size + len);
		}
		strcpy(_str+_size, str);
	}
	//从中间插入一个字符
	void Insert(size_t pos, char ch)
	{
		if (_size == _capacity)
		{
			Expand(_capacity * 2);
		}
		int end = _size - 1;
		if (end >=(int) pos)
		{
			_str[end + 1] = _str[end];
			--end;
		}
		_str[pos] = ch;
		_str[_size] = '\0';
	}
	//从中间插入一个字符串
	void Insert(size_t pos, char* str)
	{
		size_t len = strlen(str);

		if (_size+len > _capacity)
		{
			Expand(_size+len);
		}
		int end = _size;
		while(end >=(int) pos)
		{
			_str[end + len] = _str[end];
			--len;
		}
		while (*str)
		{
			_str[pos++] = *str++;
		}
		_size += len;
	}
	//删除从pos这个位置开始之后的count个字符
	void Erase(size_t pos, size_t count)
	{
		if (pos + count >= _size - 1)
		{
			_str[pos] = '\0';
			_size = pos;
		}
		else
		{
			strcpy(_str + pos, _str + pos + count);
			_size = _size - count;
		}
	}
	//查找一个字符
	int Find(char ch)const
	{
		size_t i = 0;
		for (size_t i = 0; i < _size; i++)
		{
			if (_str[i] == ch)
				return i;
		}
		if (i == _size)
			return -1;
	}
	//查找一个字符串
	int Find(const char* str) const
	{
		char* srcstr = _str;
		const char* substr = str;
		size_t srcIndex = 0;
		size_t subIndex = 0;
		size_t sublen = strlen(substr);
		while (srcIndex < _size)
		{
			size_t matchIndex = srcIndex;
			while (srcstr[matchIndex] == substr[subIndex])
			{
				++matchIndex;
				++subIndex;		
				if (subIndex == sublen)	//子串走到结尾
                 return srcIndex;						
		}
			subIndex = 0;
			srcIndex++;
		}
		return -1;
	}

	char& operator[](size_t pos)
	{
		assert(pos < _size);
		return _str[pos];
	}

	const char& operator[](size_t pos) const//返回一个常量引用，不能修改，this指针指向const
	{
		assert(pos < _size);
		return  _str[pos];
	}
	//s1<s2
	bool operator<(const String& s)const
	{
		size_t i = 0;
		for (; i < _size&&i < s._size; ++i)
		{
			if (_str[i] < s._str[i])
				return true;
			else if (_str[i] > s._str[i])
				return false;
		}
			if (i == _size&&i<s._size)   //s1=hell  s2=hello
				return true;
			else                         //s1=hello  s2=hell      s1=hello s2=hello
				return false;
	}
	//s1==s2
	bool operator==(const String& s)const
	{
		size_t i = 0;
		for (size_t i = 0; i < _size&&i < s._size; ++i)
		{
			if (_str[i] != s._str[i])
				return false;

		}
			if (i == _size&&i == s._size)
				return true;
			else
				return 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);
	}
	const char* C_str() const //返回C风格的字符串
	{
		if (_str!=NULL)
		return _str;
	}
private:
	char* _str;
	size_t _size;
	size_t _capacity;
};

int main()
{
	String s1("hello bit");
	String s2(s1);
	cout << s1.Getstr() << endl;
	cout << s2.Getstr() << endl;

	String s3("abbbefd");
	int pos = s3.Find('e');
	cout << pos << endl;

	String s4("abcdaaabbd");
	pos = s4.Find("aabb");
	cout << pos << endl;
	system("pause");
	return 0;
}

深浅拷贝&写时拷贝

 浅拷贝：在拷贝构造的时候直接将原内容的地址交给要拷贝的对象，两个对象指向同一块地址空间。这存在很大的缺陷：（1）一旦对s2进行操作，s1的内容也会改变，但这并不是我们所期望的（2）析构时先析构s2，再析构s1，对同一块地址空间析构两次导致出错。

深拷贝：通过开辟和原空间大小相同的空间并将内容拷贝下来在进行操作，无论是否对s2进行操作都会拷贝一块大小相同的空间及内容下来。

图示：

写时拷贝

写时拷贝：引用一个计数器，每块不同内容的空间上定义一个计数器，在构造第一个对象指向时，计数器初始化为1，之后每次有新的对象指向同一块空间时，计数器+1；在析构时判断该块地址空间的的引用计数是否为1，为1则执行清理工作，大于1则计数器-1。如果要进行增删查改等操作时，在拷贝空间完成，有助于提高效率。

写法一

每构造一个新对象，就会多开4个字节，导致空间中有许多内存碎片

namespace COW
{
	class String
	{
	public:
		String(const char* str)//构造函数
			:_str(new char[strlen(str) + 1])
		    ,refcountptr(new int(1))
		{
			strcpy(_str, str);
		}
		~String()  //析构函数
		{
			if (--(*refcountptr) == 0)
			{
				delete[] _str;
				delete refcountptr;
			}
		}
		String(String& s) //拷贝构造
			:_str(s._str)
			, refcountptr(s.refcountptr)
		{
			(*refcountptr)++;
		}
		//赋值运算符的重载
		//s1=s2
		String& operator=(const String& s)
		{
			if (_str != s._str)
			{
				if (--(*refcountptr) == 0)
				{
					delete[] _str;
					delete refcountptr;
				}
				_str = s._str;
				refcountptr = s.refcountptr;
				(*refcountptr)++;
			}
			return *this;
		}
	private:
		char* _str;
		int* refcountptr;//引用计数
	};
}

写法二

 由于计数器存放在了_str首地址-4的地址上，所以在析构时一定要注意全部释放，避免内存泄漏。

namespace COW2
{
	class String
	{
	public:
		String(const char* str = "") //构造函数
		{
			_str = new char[strlen(str) + 5];
			strcpy(_str + 4, str);
			*((int*)_str) = 1;
			_str += 4;
		}
		int& GetRefcount()
		{
			return *((int*)(_str - 4));
		}
		String(const String& s)
			:_str(s._str)
		{
			GetRefcount()++;
		}
		~String()
		{
			if (--GetRefcount() == 0)
			{
				delete[](_str - 4);
			}
		}
		//赋值运算符重载
		String& operator=(const String& s)
		{
			if (_str != s._str)
			{
				if (--GetRefcount() == 0)
				{
					delete[](_str - 4);
				}
				_str = s._str;
				GetRefcount()++;
			}

		}
	private:
		char* _str;
	};
}