C++----string使用以及String的模拟实现

string

string是表示字符串的字符串类。
不能操作多字节或者边长的字符序列。

标准库中的string类

string类对象的常见构造

void  teststring()
{
	string s;//构造空的string类对象s
	string s1("good!!");//用c格式的字符串构造string类对象s1
	string s2(10, 'c');//用10个'c'构造string类对象s3
	string s4(s);//拷贝构造s4
	string s5(s1, 2);//用s1的前两个字符构造string对象s5
}

string对象的容量操作

1. size()与length()的底层原理完全相同。
2. clear()只是将string中的有效字符清空不改变底层空间大小。
3. resize()在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果将元素减少底层空间的总大小不变。resize(sizr_t n,char c)和resize(size_t n)，都是讲字符串的有效字符改变到n个不同的是前者用字符’c’来填充多余的元素空间，后者用0来填充多余的元素空间。
4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间大小时，reserve不会改变容量大小。

string类对象的访问操作

函数名称	功能说明
char& operator[] ( size_t pos )	返回pos位置的字符，const string类对象调用
const char& operator[] ( size_t pos ) const	返回pos位置的字符，非const string类对象调用

void TestString()
{
	string s1("hello!");
	const string s2("Hello！");
	cout << s1 << " " << s2 << endl;
	cout << s1[0] << " " << s2[0] << endl;
	s1[0] = 'H';
	//s2[2]='f';编译失败，const对象不能修改
	cout << s1 << endl;

}

string类对象的修改操作

函数名称	功能说明
void push_back(char c)	在字符串后尾插字符c
string& append (const char* s)	在字符串后追加一个字符串
string& operator+=(const string& str)	在字符串后追加字符串str
string& operator+=(const char* s)	在字符串后追加s字符串
string& operator+=(char c)	在字符串后追加字符c
const char* c_str( ) const	返回C格式字符串
size_t find (char c, size_t pos = 0) const	从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置
size_t rfind(char c, size_t pos = npos)	从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置
string substr(size_t pos = 0, size_t n = npos) const	在str中从pos位置开始，截取n个字符，然后将其返回

1. 在string后面追加字符时，s.push_back©/s.append(1,c)和s+='c’三种的实现方式都差不多，一般用+=的比较多，因为+=操作不仅可以连接单个字符，还可以连接字符串。
2. 对string操作的时候，如果能大概预估多少字符串的时候，用reserve把空间预留好。

模拟实现string

#include<assert.h>
#include<iostream>
#include<stdlib.h>
using namespace std;
//模拟实现string
class String
{

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

	typedef char* Iterator;


	String(const char* str = "")
	{
		// 构造string类对象时，如果传递nullptr指针，认为程序非法，此处断言下
		if (nullptr == str)
		{
			assert(false);
			return;
		}
		_size = strlen(str);
		_capacity = _size;
		_str = new char[_capacity + 1];
		strcpy(_str, str);
	}
	String(const String& s)
		:_str(new char[s._capacity+1])
		, _size(s._size)
		, _capacity(s._capacity)
	{
		strcpy(_str, s._str);
	}
	String& operator=(const String& s)
	{
		if (this != &s)
		{
			char* Cstr = new char[s._capacity + 1];
			strcpy(Cstr, s._str);
			
			delete[] _str;
			_str = Cstr;
			_size = s._size;
			_capacity = s._capacity;
		}
		return *this;
	}
	//Iterator
	Iterator Begin()
	{
		return _str;
	}
	Iterator End()
	{
		return _str + _size;
	}
	~String()
	{
		if (_str)
		{
			delete[] _str;
			_str = nullptr;
		}
	}
	//扩容
	void Resize(size_t newSize, char c=char())
	{
		if (newSize > _size)
		{
			if (newSize > _capacity)
			{
				Reserve(newSize);
			}
			memset(_str + _size, c, newSize - _size);
		}
		_size = newSize;
		_str[newSize] = '\0';
	}
	//扩容
	void Reserve(size_t NewCapacity)
	{
		if (NewCapacity > _capacity)
		{
			char* str = new char[NewCapacity + 1];
			strcpy(str, _str);

			delete[] _str;
			_str = str;
			_capacity = NewCapacity;
		}
	}

	//功能实现
	//插入字符'c'
	void PushBack(char c)
	{
		if (_size == _capacity)
		{
			Reserve(_capacity * 2);
		}
		_str[_size++] = 'c';
		_str[_size] = '\0';
	}
	//追加插入n个c
	void Append(size_t n, char c)
	{
		for (size_t i = 0; i < n; i++)
		{
			PushBack(c);
		}
	}
	void Append(char* str)
	{
		int m = strlen(str);
		for (int i = 0; i < m; i++)
		{
			PushBack(str[i]);
		}
	}

	String& operator +=(char c)
	{
		PushBack(c);
		return *this;
	}
	String& operator +=(char* str)
	{
		Append(str);
		return *this;
	}
	//清空
	void Clear()
	{
		_size = 0;
		_str[_size] = '\0';
	}
	//交换
	void Swap(String& s)
	{
		swap(_str, s._str);
		swap(_size, s._size);
		swap(_capacity, s._capacity);
	}
	//返回C字符串
	const char* C_str() const
	{
		return _str;
	}


	//容量
	size_t Capacity() const
	{
		return _capacity;
	}
	//大小
	size_t Size() const
	{
		return _size;
	}
	//判空
	bool Empty()
	{
		return _size == 0;
	}
	//[]
	char& operator[] (size_t index)
	{
		assert(index < _size);
		return _str[index];
	}
	const char& operator[] (size_t index) const
	{
		assert(index < _size);
		return _str[index];
	}
	size_t Find(char c, size_t pos = 0) const
	{
		for (int i= pos ; pos < _size; i++)
		{
			if (_str[i] == c )
			{
				return i;
			}
		}
		return -1;
	}
	
	size_t Find(const char* s, size_t pos = 0) const
	{
		char* curstr = strstr(_str + pos, s);//在字符串str1中查找另一个字符串str2首次出现的位置。如果找到匹配的字符串，返回第一次匹配到的字符串的指针，否则返回NULL。
		if (curstr != nullptr)
		{
			return curstr - _str;
		}
		return -1;
	}
	String& Insert(size_t pos,  const char c)
	{
		assert(pos < _size);
		if (_size == _capacity)
		{
			size_t NewC = _capacity == 0 ? 15 : _capacity * 2;
			Reserve(NewC);
		}

		size_t end = _size;
		while (end>pos)
		{
			_str[end] = _str[end - 1];
			end--;
		}
		_str[pos] = 'c';
		_str[++_size] = '\0';
		return *this;
	}
	String& Insert(size_t pos, const char* str)
	{
		int len = strlen(str);
		assert(pos < _size);
		if (_size+len > _capacity)
		{
			Reserve(_size + len);
		}
		size_t end = _size + len;
		while (end > pos + len - 1)  // pos  pos + len
		{
			_str[end] = _str[end - len];
			--end;
		}

		//插入字符串
		while (*str)
		{
			_str[pos++] = *str;
			++str;
		}
		_size += len;
		return *this;
	}
	bool operator>(const String& s)
	{
		char* str1 = _str;
		char* str2 = s._str;
		while (*str1 == *str2)
		{
			str1++;
			str2++;
		}
		if (*str1>*str2)
		{
			return true;
		}
		else
			return false;
	}
	bool operator<=(const String& s)
	{
		if (_str > s._str)
		{
			return false;
		}
		else
			return true;
	}
	bool operator>=(const String& s)
	{
		if (_str < s._str)
		{
			return false;
		}
		else
			return true;
	}
	bool operator==(const String& s)
	{
		char* str1 = _str;
		char* str2 = s._str;
		while (*str1 == *str2)
		{
			str1++;
			str2++;
		}
		if (*str1==*str2)
		{
			return true;
		}
		else
			return false;
	}
	bool operator!=(const String& s)
	{
		if (_str == s._str)
		{
			return true;
		}
		else
			return false;
	}
private:
	friend ostream& operator<<(ostream& _cout, const String& s);

};
ostream& operator<<(ostream& _cout, const String& s)
{
	cout << s._str;
	return _cout;
}

//测试
void Test1()
{
	
	String s;
	String s1("aabbccdd");
	String S2(s1);
	String S3 = S2;
	cout << s1.Capacity() << endl<<s1.C_str()<<endl;
	s1.PushBack('c');
	cout << s1<<endl;
	s1.Append(5, 'c');
	cout << s1 << endl;
	cout<<s1.Begin();
	cout << s.Empty();
	cout << s1[2];
	s1.Insert(2, 'c');
	cout << s1<<endl;

	s1.Insert(2, "abc");
	cout << s1 << endl;
	cout<<s1.Find('d',2);
	
	s1.Append("abc");
	s1.Reserve(2);
	s1.Reserve(20);
	s1.Resize(25,'c');
	s1.Clear();
}
int main()
{
	Test1();
	system("pause");
	return 0;
}