c++ String类及深浅拷贝（传统写法与现代写法）code

#####主要内容：模拟实现String类的默认成员函数，增删查改，及各类运算符重载等。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string.h>
#include<stdlib.h>
#include<assert.h>

using namespace std;


class String
{
public:
	String(const char* str = "")//构造函数
		:_str(new char[strlen(str) + 1])//开辟一块和str等长的空间，用于存放对象的_str,需要算上'\0'
		, _size(strlen(str))//字符串长度，这里的_size和_capacity都不记'\0'
		, _capacity(_size)//开辟的最大空间，后面扩容需要判断
	{
		strcpy(_str, str);//拷贝即可
	}
	// s1.Swap(s2); 


	void show()//打印函数
	{
		cout << "_str:" << _str << endl;
		cout << "_size:" << _size << endl;
		cout << "_capcity" << _capacity << endl;

	}


	void Swap(String& s)//交换函数,另两个对象交换所有成员变量
	{
		if (s._str != _str)//如果两个字符串相同就没有拷贝必要了
		{
			//swap是库函数，可以直接用于交换
			swap(_str, s._str);
			swap(_size, s._size);
			swap(_capacity, s._capacity);
		}
	}


	//String s2(s1) 
	String(const String& s)//拷贝构造函数
		/*:_str(new char[strlen(s._str) + 1])
		,_size(s._size)
		,_capacity(s._capacity)*/
	{
		/*strcpy(_str, s._str);*/      //传统写法


		//现代写法
		String s1(s._str);   //创建一个临时对象，直接用于交换，临时对象出作用域自动析构
		Swap(s1);

	}


	// s1 = s2 
	String& operator=(const String &s)
	{

		if (_str != s._str)//避免出现自己给自己赋值的情况
		{
			//传统写法，自己释放，自己开空间
			//	delete[] _str;
			//	_str = new char[strlen(s._str) + 1];
			//	strcpy(_str, s._str);
			//	_size = s._size;
			//	_capacity = s._capacity;


			//现代写法，创建临时对象
			String tmp(s._str);
			Swap(tmp);

		}

		return *this;   //返回*this，适用于连等情况
	}


	~String()//析构函数，释放_str空间
	{
		delete[] _str;
		_str = NULL;

	}

	const char* c_str()//提取字符串，因为_str是私有成员，只能用这种方法返回
	{
		return _str;
	}


	void Expand(size_t n)//扩容，扩容到_size+n字节
	{
		_capacity += n;
		char *tmp = new char[_capacity + 1];
		strcpy(tmp, _str);
		swap(tmp, _str);
		delete[] tmp;
	}


	void PushBack(char ch)//在_str尾上插入字符ch
	{
		Insert(_size, ch);
	}


	//void PushBack(const char* str)

	void PopBack()//删除_str最后一个字符
	{
		Erase(_size - 1, 1);
	}


	void Insert(size_t pos, char ch)//在pos处插入字符ch
	{
		assert(pos <= _size);

		if (_size + 1 >= _capacity)//扩容
		{
			Expand(5);
		}



		memmove(_str + pos + 1, _str + pos, _size - pos + 1);
		_str[pos] = ch;
		_size++;
	}


	void Insert(size_t pos, const char* str)//在任意处插入一个字符串str
	{
		assert(pos <= _size);
		if (_size + strlen(str) >= _capacity)//扩容
		{
			Expand(strlen(str));
		}

		memmove(_str + pos + strlen(str), _str + pos, _size - pos + 1);
		strncpy(_str + pos, str, strlen(str));

		_size += strlen(str);

	}


	void Erase(size_t pos, size_t n = 1)//删除从pos处向后的n个字符，默认删除1个字符
	{
		assert(pos < _size);
		assert(n <= _size);
		if (_size == 0)//为空不能删除
		{
			cout << "the string is empty!!" << endl;
			return;
		}

		memmove(_str + pos, _str + pos + n, _size - n + 1);
		_size -= n;
	}


	size_t Find(char ch)//在_str中查找字符ch是否存在，若存在则返回第一次出现时的下标，不存在返回-1
	{
		char *tmp = strchr(_str, ch);//strchr:查找字符ch第一次出现的位置，存在返回指针，不存在返回NULL
		if (tmp == NULL)
		{
			printf("'ch' is not in this string!!\n");
			return -1;
		}
		return tmp - _str;
	}


	size_t Find(const char* str)//在_str中查找子串str，若存在返回第一次出现的下标，不存在则返回-1
	{
		assert(str);
		char *tmp = strstr(_str, str);

		if (tmp)
		{
			return tmp - _str;
		}
		return -1;
	}

	// s1 + 'a' 
	String operator+(char ch)
	{
		String s1(_str);
		s1.PushBack(ch);
		return s1;
	}


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


	String operator+(const char* str)
	{
		String s1(_str);
		s1.Insert(strlen(_str), str);
		return s1;
	}


	String& operator+=(const char* str)
	{
		Insert(strlen(_str), str);
		return *this;
	}

	bool operator>(const String& s)
	{
		if (strcmp(_str, s._str) > 0)
		{
			return true;
		}
		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);
	}
	
	
	bool operator==(const String& s)
	{
		if (strcmp(_str, s._str) == 0)
		{
			return true;
		}
		return false;
	}


	bool operator!=(const String& s)
	{
		return !(*this == s);
	}

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