【C++】模拟实现string类

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<assert.h>
#include<stdlib.h>
#include<string.h>
using namespace std;
class String{
    
    
private:
	size_t _size;
	size_t _capacity;
	char* _data;
	static const size_t npos;
public:
	typedef char* iterator;
	typedef const char* const_iterator;
	iterator begin(){
    
    
		return _data;
	}
	const_iterator begin() const{
    
    
		return _data;
	}
	iterator end(){
    
    
		return _data + _size;
	}
	const_iterator end ()const{
    
    //无法仅按返回值作为函数重载，const可以
		return _data + _size;
	}

	
	String(const char* str = '\0')
		:_size(strlen(str))
		, _capacity(_size)
		, _data(new char[strlen(str)+1])
	{
    
    
		strcpy(_data, str);
	}

	void Swap(String& str){
    
    
		swap(_data, str._data);
		swap(_size, str._size);
		swap(_capacity, str._capacity);
	
	}
	String(const String& str)
		:_size(0)
		,_capacity(0)
		, _data(nullptr)
	{
    
    
		String tmp(str._data);
		Swap(tmp);
	}

	~String(){
    
    
		if (_data){
    
    
			delete[] _data;
		}
		_data = nullptr;
		_capacity = _size = 0;
	
	}
	bool String::operator==(const String& str){
    
    
		if (_data == str._data&&_size == str._size&&_capacity == str._capacity)
			return true;
		return false;
	}
	String& String::operator=(const String& str){
    
    //形参也不能是const
		if (*this == str){
    
    
			return *this;
		}
		String tmp(str);
		Swap(tmp);
		return *this;
	}

	char& String::operator[](size_t a){
    
    
		assert(a > _size);
		return _data[a];
	}

	const char& String::operator[](size_t a)const{
    
    
		assert(a > _size);
		return _data[a];
	}
	void reserse(size_t ch){
    
    
		if (_capacity < ch){
    
    
			char* newp = new char[ch+1];//这里有个+1没写 ch表示有效字符的最大个数不包括\0

			//拷贝
			strcpy(newp, _data);
			delete[] _data;
			_data = newp;
			_capacity = ch;
		}
	}

	void resize(size_t ch, const char& a = '\0'){
    
    
		if (_capacity < ch)
			reserse(ch);
		if (_size < ch)
			memset(_data + _size, a, sizeof(char)*(ch - _size));
		_size = ch;
		//忘记\0
		_data[_size] = '\0';
	}

	void pushback(const char&a = '\0'){
    
    
		if (_size == _capacity){
    
    
			//三目运算符顺序
			size_t newcapacity=_capacity == 0 ? 15 : 2 * _capacity;
			reserse(newcapacity);
		}
		_data[_size++] = a;
		_data[_size] = '\0';
	}

	void append(const char* str){
    
    
		if (_capacity < (strlen(str) + _size)){
    
    
			reserse(strlen(str) + _size);
		}
		memcpy(_data + _size, str,sizeof(char)*strlen(str));
		//忘记更新size
		_size += strlen(str);
		_data[_size] = '\0';

	}

	String& String::operator+=(const String& str){
    
    
		append(str._data);
		return *this;
	}

	String& String::operator+=(const char* str){
    
    
		append(str);
		return *this;
	}

	String& String::operator+=(const char& str){
    
    
		pushback(str);
		return *this;
	}

	void insert(size_t pos, const char& ch){
    
    
		assert(pos <= _size);//可以等于，忘写了
		if (_size == _capacity){
    
    
			size_t newc = _capacity == 0 ? 1 : 2 * _capacity;
			reserse(newc);
		}
		/*size_t idx = _size;
		while (idx>pos-1){
			_data[idx+1] = _data[idx];
			--idx;
		}*/
		size_t idx = _size + 1;
		while (idx>pos){
    
    
			_data[idx] = _data[idx - 1];
			idx--;
		}
		_data[pos] = ch;
		++_size;
	}

	void insert(size_t pos, const char* ch){
    
    
		assert(pos <= _size);
		size_t len = strlen(ch);
		if (len + _size > _capacity){
    
    
			reserse(len + _size);
		}
		size_t idx = _size + len;
		
		while (idx>pos-1){
    
    
			_data[idx] = _data[idx-len];//不能写size
			idx--;
			
		}
		memcpy(_data + pos, ch, sizeof(char)*len);//不能strcpy-->\0
		_size += len;
	}

	void earse(size_t pos, size_t len = npos){
    
    
		assert(pos<=_size);
		if (pos+len>=_size||len==npos){
    
    
			_size = pos;
			_data[_size] = '\0';
		
		}
		else{
    
    
			size_t idx = pos + len;
			while (idx <= _size){
    
    
				_data[idx - len] = _data[idx];
				++idx;
			}
			_size -= len;
		}
	}

	size_t find(const char* ch, size_t pos = 0){
    
    
		assert(pos < _size);
		char* strpos = strstr(_data + pos, ch);
		if (strpos){
    
    
			return strpos - _data;
		}
		return npos;
	}

	String substr(size_t pos, size_t len = npos){
    
    //创建子串
		assert(pos < _size);
		if (pos + len >= _size || len == npos){
    
    
			return String(_data + pos);//pos是一个数字，指针加数字是指针
		}
		else{
    
    
			char* newc = new char[len + 1];
			memcpy(newc, _data + pos, sizeof(char)*len);
			newc[len] = '\0';
			delete[] newc;
			return String(newc);
		}
	}

	size_t size()const{
    
    
		return _size;
	}

	size_t capacity()const{
    
    
		return _capacity;
	}


	const char* cstr() const{
    
    
		return _data;
	}
};

const size_t String::npos = -1;

String operator+(const String& a, const String& b){
    
    //不能加string：：
	String str(a);  //拷贝构造需要const，否则报错
	//因为const可以接受const和非const，非const只能接受const
	str += b;
	return str;
}
String operator+(const String& a, const char* b){
    
    
	String str(a);  
	str += b;
	return str;
}
String operator+(const String& a, const char& b){
    
    
	String str(a);  
	str += b;
	return str;
}

bool operator<(const String& str1, const String& str2){
    
    
	int a = strcmp(str1.cstr(), str2.cstr());//1>2--大于0 否则小于0
	if (a<0){
    
    
		return true;
	}
	return false;
}

bool operator==(const String& str1, const String& str2){
    
    
	int a = strcmp(str1.cstr(), str2.cstr());
	if (a==0){
    
    
		return true;
	}
	return false;
}

bool operator!=(const String& str1, const String& str2){
    
    
	return !(operator== (str1, str2));
}


ostream& operator<<(ostream& out ,String& str){
    
    
	for (const auto ch : str){
    
    
		cout << ch;
	}
	return out;
}

//相比于输出流简单地输出，输入流相当于尾插string
istream& operator>>(istream& in, String& str){
    
    
	char ch;
	while ((ch = cin.get()) != EOF){
    
    
		if (ch == ' ' || ch == '\0')
			break;
		str += ch;
	}
	return cin;
}

void printffor(const String& str){
    
    //形参也不能是const
	//形参const走的就是const的迭代器
	for (const char&  a : str){
    
       //const_it
		cout << a;
	}
	cout << endl;
}

void printffor2(const String& str){
    
    
	String::const_iterator it = str.begin();
	while (it != str.end()){
    
    
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

//void test(){
    
    
//	String str1 = "hello";
//	String str2 = "nihao";
//	String str3 = "nihao";
//	bool a, b;
//	a = (str1 == str2);
//	b = (str3 == str2);
//	cout << a << endl;
//	cout << b << endl;
//}

int main(){
    
    
	//test();
	system("pause");
	return 0;
}