C++string类的自行实现

string类的实现

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string.h>//not cstring, sting 只属于cpp
#include <cstdlib>
#include <stdlib.h>
#include <string>
#define DEFAULTCAPA 16	

using namespace std;
//自行实现string类
class String
{
	char* m_data;
	size_t m_size;
	size_t m_capacity;
public:
	String(const char* str = "") :
		m_capacity(16)
	{
		if (nullptr == str)
		{
			m_size = 0;
		}
		else
		{
			m_size = strlen(str);
		}
		m_capacity = (m_size / DEFAULTCAPA + 1) * DEFAULTCAPA;

		m_data = new char[m_capacity];
		strncpy(m_data, str, m_size);

	}

	String(size_t n, char ch) :
		m_size(n),
		m_capacity(DEFAULTCAPA)
	{
		m_capacity = (m_size / DEFAULTCAPA + 1) * DEFAULTCAPA;
		m_data = new char[m_capacity];
		memset(m_data, ch, m_size);
	}

	String(String& s)
	{
		m_size = s.m_size;
		m_capacity = s.m_capacity;
		m_data = new char[m_capacity];
		strcpy(m_data, s.m_data);
	}

	~String()
	{
		if (m_data)
		{
			delete[]m_data;
			m_data = NULL;
		}
		m_size = m_capacity = 0;
	}

	void reserve(size_t size)
	{
		if (size >= m_capacity)
		{
			m_capacity = (size / DEFAULTCAPA + 1) * DEFAULTCAPA;
			m_data = (char*)realloc(m_data, m_capacity);
		}
	}

	void resize(size_t size, char ch = '\0')
	{
		reserve(size);

		if (m_size < size)
		{
			memset(m_data + m_size, ch, size - m_size);
		}
		m_size = size;
	}

	int capacity()
	{
		return m_capacity;
	}
	int size()
	{
		return m_size;
	}

	char& operator [] (int i)
	{
		return m_data[i];
	}

	typedef char* iterator;//迭代器

	iterator begin()
	{
		return m_data;
	}

	iterator end()
	{
		return m_data + m_size;
	}

	void push_back(char ch)
	{
		reserve(m_size + 1);
		m_data[m_size] = ch;
		m_size++;
	}

	void pop_back()
	{
		if (m_data)
		{
			m_size--;
		}
	}

	String& operator += (const char* str)
	{
		int tmp = m_size;
		m_size += strlen(str);
		reserve(m_size);

		strcpy(m_data + tmp, str);
		return* this;
	}

	String& operator += (String& s)
	{
		int tmp = m_size;
		m_size += s.m_size;
		reserve(m_size);

		strcpy(m_data + tmp, s.m_data);
		return* this;
	}

	String& operator = (const char* str)
	{
		m_size = strlen(str);
		reserve(m_size);

		strcpy(m_data, str);
		return* this;
	}

	String& operator = (String& s)
	{
		m_size = s.m_size;
		reserve(m_size);

		strcpy(m_data, s.m_data);
		return* this;
	}

	const char * c_str()
	{
		return m_data;
	}

	size_t find(char ch, int pos = 0)
	{
		if (pos < 0 || pos >= m_size)
		{
			return -1;
		}
		char* tmp = strchr(m_data + pos, ch);
		if (tmp)
		{
			return tmp - m_data;
		}
		return -1;
	}

	size_t find(const char* str, int pos = 0)
	{
		if (pos < 0 || pos >= m_size)
		{
			return -1;
		}
		char* tmp = strstr(m_data + pos, str);
		if (tmp)
		{
			return tmp - m_data;
		}
		return -1;
	}

	size_t find(const String& s, int pos = 0)
	{
		if (pos < 0 || pos >= m_size)
		{
			return -1;
		}
		char* tmp = strstr(m_data + pos, s.m_data);
		if (tmp)
		{
			return tmp - m_data;
		}
		return -1;
	}



	void revstr()
	{
		int left = 0;
		int right = m_size - 1;
		while (left < right)
		{
			swap(m_data[left], m_data[right]);
			left++;
			right--;
		}
	}

	String substr(size_t start, size_t num)
	{
		String tmp;
		tmp.resize(num);
		strncpy(tmp.m_data, m_data + start, num);
		return tmp;
	}

	String operator + (const char* str) const
	{
		String res;
		res.m_size = m_size + strlen(str);
		res.reserve(res.m_size);

		strcpy(res.m_data, m_data);
		strcat(res.m_data, str);

		return res;
	}
	String operator + (const String& s) const
	{
		String res;
		res.m_size = m_size + s.m_size;
		res.reserve(res.m_size);

		strcpy(res.m_data, m_data);
		strcat(res.m_data, s.m_data);

		return res;
	}

	String& append(int n, const char& ch)
	{
		int i;
		int tmp = m_size;
		m_size += n;
		reserve(m_size);
		for (i = 0; i < n; i++)
		{
			m_data[tmp + i] = ch;
		}

		return* this;
	}

	String& append(const String& s)
	{
		int tmp = m_size;
		m_size += s.m_size;
		reserve(m_size);

		strcpy(m_data + tmp, s.m_data);
		return* this;
	}

	friend String operator +(const char* str, const String& s);

	friend ostream& operator << (ostream& os, const String& s);
	friend istream& operator >> (istream& os, String& s);
};

String operator + (const char* str, const String& s)
{
	String res;

	res.m_size = strlen(str) + s.m_size;
	res.reserve(res.m_size);

	strcpy(res.m_data, str);
	strncat(res.m_data, s.m_data, s.m_size);

	return res;
}

ostream& operator << (ostream& os,const String& s)
{
	size_t i;
	for (i = 0; i < s.m_size; i++)
	{
		os << s.m_data[i];
	}
	return os;
}

istream& operator >> (istream& is, String& s)
{
	char* tmp = new char[1024];
	is.getline(tmp, 1024);

	s.m_size = strlen(tmp);
	s.m_capacity = (s.m_size / DEFAULTCAPA + 1) * DEFAULTCAPA;
	delete[]s.m_data;
	s.m_data = tmp;
	return is;
}

int main()
{
	String s(4, 'n');
	String s2("ikunkun");
	String s3("un");
	string s4 = "adbcdedb";
	s3.append(s2);
//	s2 += s;
	cout << s3;
	
	system("pause");
	return 0;
}