[ c++ ]string的模拟实现及简单测试参考

string 类 ( 了解 )

string 类的文档介绍

1. 字符串是表示字符序列的类

2. 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作

单字节字符字符串的设计特性。

3. string 类是使用 char( 即作为它的字符类型，使用它的默认 char_traits 和分配器类型 ( 关于模板的更多信

息，请参阅 basic_string) 。

4. string 类是 basic_string 模板类的一个实例，它使用 char 来实例化 basic_string 模板类，并用 char_traits

和 allocator 作为 basic_string 的默认参数 ( 根于更多的模板信息请参考 basic_string) 。

5. 注意，这个类独立于所使用的编码来处理字节 : 如果用来处理多字节或变长字符 ( 如 UTF-8) 的序列，这个 类的所有成员( 如长度或大小 ) 以及它的迭代器，将仍然按照字节 ( 而不是实际编码的字符 ) 来操作。

总结：

1. string 是表示字符串的字符串类

2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作 string 的常规操作。

3. string 在底层实际是： basic_string 模板类的别名， typedef basic_string<char, char_traits, allocator>

string;

4. 不能操作多字节或者变长字符的序列。

在 使用 string 类时，必须包含 #include 头文件以及 using namespace std ;

简单了解string过后，这个博客我们主要经行string的常见函数的常见接口的模拟实现，这可以有效帮助大家理解string。

#pragma once
//模拟实现string类，并完成测试
#include<iostream>
#include<assert.h>
using namespace std;
namespace bit
{
	class string
	{
		friend istream& operator>>(istream& in, string& s);
		friend ostream& operator<<(ostream& out, string& s);
	public:
		//
		// iterator
		static const size_t npos = -1;
		typedef char* iterator;
		typedef const char* const_iterator;
		const_iterator begin() const
		{
			return _str;
		}

		const_iterator end() const
		{
			return _str + _size;
		}

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		string(const char* str = "") 
			:_size(strlen(str))
		{
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str,str);
		}
		string(const string& s)
		{
			_str = new char[s._capacity + 1];
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;
		}
		~string() 
		{
			delete[] _str;
		    _str = nullptr;
			_size = 0;
			_capacity = 0;

		}
		const char* c_str() const
		{
			return _str;
		}
		string& operator=(const string& s) {
			char* tmp = new char[s._capacity + 1];
			_size = s._size;
			_capacity = s._capacity;
			delete[] _str;
			strcpy(tmp, s._str);
			_str = tmp;
			return *this;
		}
		/
        // modify
		void push_back(char c) {
			if (_size == _capacity) {
				reserve(++_size);
			}
			_str[_size - 1] = c;
			_str[_size] = '\0';

		}

		string& operator+=(char c) {
			if (_size == _capacity) {
				reserve(++_size);
			}
			_str[_size - 1] = c;
			_str[_size] = '\0';
			return *this;
		}

		void append(const char* str) {
			if (_size + strlen(str) > _capacity) {
				reserve(_size + strlen(str));
			}
			strcpy(&_str[_size], str);
			_size += strlen(str);
		}

		string& operator+=(const char* str) {
			if (_size + strlen(str) > _capacity) {
				reserve(_size + strlen(str));
			}
			strcpy(&_str[_size], str);
			_size += strlen(str);
			return *this;
		}

		void clear() {
			_size = 0;
			_str[_size] = '\0';
		}

		void swap(string& s) {
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}
		/
		// capacity

		size_t size()const {
			return _size;
		}

		size_t capacity()const {
			return _capacity;
		}

		bool empty()const {
			return _size ? false : true;
		}

		void resize(size_t n, char c = '\0') {
			if (n <= _size) {
				_str[n] = '\0';
				_size = n;
			}
			else {
				reserve(n);
				for (size_t i = _size; i < n; i++) {
					_str[i] = c;
				}
				_str[n] = '\0';
				_size = n;
			}
		}

		void reserve(size_t n) {
			if (n > _capacity) {
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}
		/
		// access

		char& operator[](size_t index) {
			return _str[index];
		}

		const char& operator[](size_t index)const {
			return _str[index];
		}
		/
		//relational operators

		bool operator<(const string& s) {
			return strcmp(_str, s._str) < 0 ? true : false;
		}

		bool operator<=(const string& s) {
			return strcmp(_str, s._str) <= 0 ? true : false;
		}

		bool operator>(const string& s) {
			return strcmp(_str, s._str) > 0 ? true : false;
		}

		bool operator>=(const string& s) {
			return strcmp(_str, s._str) >= 0 ? true : false;
		}

		bool operator==(const string& s) {
			return strcmp(_str, s._str) == 0 ? true : false;
		}

		bool operator!=(const string& s) {
			return strcmp(_str, s._str) != 0 ? true : false;
		}



		// 返回c在string中第一次出现的位置
		size_t find(char c, size_t pos = 0) const {
			assert(pos < _size);
			while (pos < _size) {
				if (_str[pos] == c) {
					return pos;
				}
				pos++;
			}
			return npos;
		}

		// 返回子串s在string中第一次出现的位置

		size_t find(const char* s, size_t pos = 0) const {
			assert(pos < _size);

			const char* p = strstr(_str + pos, s);
			if (p)
			{
				return p - _str;
			}
			else
			{
				return npos;
			}
		}

		// 在pos位置上插入字符c/字符串str，并返回该字符的位置

		string& insert(size_t pos, char c) {
			assert(pos <= _size);
			
			if (_size ==_capacity)
			{
				// 扩容
				reserve(++_size);
			}

			size_t end = _size;
			while (end > pos)
			{
				_str[end] = _str[end - 1];
				end--;
			}
			_str[pos] = c;
			return *this;
		}

		string& insert(size_t pos, const char* str) {
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				// 扩容
				reserve(_size + len);
			}

			size_t end = _size + len;
			while (end > pos + len - 1)
			{
				_str[end] = _str[end - len];
				end--;
			}

			strncpy(_str + pos, str, len);
			_size += len;
			return *this;
		}



		// 删除pos位置上的元素，并返回该元素的下一个位置

		void erase(size_t pos, size_t len) {
			assert(pos < _size);

			if (len >= _size - pos)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
			
		}

		string substr(size_t pos = 0, size_t len = npos)
		{
			string sub;
			if (len >= _size - pos)
			{
				for (size_t i = pos; i < _size; i++)
				{
					sub += _str[i];
				}
			}
			else
			{
				for (size_t i = pos; i < pos + len; i++)
				{
					sub += _str[i];
				}
			}

			return sub;
		}
	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;
	};
	istream& operator>>(istream& in, string& s) {
		s.clear();
		char ch=in.get();
		char buff[128] = { 0 };
		int i = 0;
		while (ch != ' ' && ch != '\n') {
			buff[i] = ch;
			i++;
			if (i == 127) {
				s += buff;
				i = 0;
			}
			ch = in.get();
		}
		if (i) {
			buff[i] = 0;
			s += buff;
		}
		return in;
	}
	ostream& operator<<(ostream& out, string& s) {
		for (auto e : s) {
			out << e;
		}
		return out;
	}
	void  test1(){
	    string s1("hello world");
		string s2;

		//cout << s1.c_str() << endl;
		cout << s2.c_str() << endl;
    }
	void  test2() {
		string s3("hello world");
		string s4;
		s3.push_back('x');
		s3.push_back('x');
		s3.push_back('x');
		s3.push_back('x');
		//cout << s1.c_str() << endl;
		cout << s3.c_str() << endl;
	}
	void test3() {
		string s5("hello world");
		s5.push_back('x');
		s5.resize(5);
		cout << s5.c_str() << endl;
	}
	void test4() {
		string s6("hello world");
		s6 += 'x';
		s6 += 'x';
		s6 += 'x';
		cout << s6.c_str() << endl;
	}
	void test5() {
		string s7("hello world");
		s7 += "mao";
		s7 += "毛少东";
		cout << s7.c_str() << endl;
	}
	void test6() {
		string s8("hello world");

		s8[1]++;
		cout << s8.c_str() << endl;
		s8[1]--;
		cout << s8.c_str() << endl;
	}
	void test7() {
		string s9("hello world");

		s9.insert(0," 毛少东");
		cout << s9.c_str() << endl;
		s9.insert(0,'x');
		cout << s9.c_str() << endl;
	}
	void test8() {
		string s10("hello world");
		cout << s10 << endl;
		cout << s10 << "niubi" << endl;
	}
	void test9() {
		string s11("hello world");
		string s12;
		cin >> s11 >> s11;
		cout << s11 << endl;
		cin >> s12>>s11;
		cout << s12 << endl;
		cout << s11 << endl;
	}
}