【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;
}