手动写一个String类型

简言：

        自己写一个string类型，然后实现基本的功能，提供基本的接口。

MyString.h

#pragma once
#include <iostream>
typedef char*  Iterator;
class MyString
{
	friend std::ostream & operator<<(std::ostream &ostream, const MyString& string);
	friend std::istream & operator>>(std::istream &istream, MyString& string);
public:
	MyString();
	MyString(const char * code);
	MyString(const MyString& other);
	~MyString();
	MyString& operator=(const MyString & another);
	MyString& operator=(const char* code);
	MyString operator+(const MyString & another);
	Iterator begin();
	Iterator end();
	Iterator m_pIterator;
	bool operator==(const MyString & another);
	char& operator[](int index);
	int size();
	bool compare(const char* str, const char* other,int strSize,int otherSize);
private:
	char * m_pString;
	int m_size;
};

MyString.cpp

#include "MyString.h"

#pragma  warning (disable:4996) 
MyString::MyString()
{
	m_pString = NULL;
	m_size = 0;
}

MyString::MyString(const char * code)
{
	if (code!=NULL)
	{
		m_size = strlen(code);
		m_pString = new char[m_size + 1];
		memcpy(m_pString, code, (m_size + 1) * sizeof(char));
		return;
	}
	m_size = 0;
	m_pString = new char[1];
	memcpy(m_pString, "", sizeof(char));
}

MyString::MyString(const MyString & other)
{
	m_size = strlen(other.m_pString);
	m_pString = new char[m_size + 1];
	memcpy(m_pString, other.m_pString, (m_size + 1) * sizeof(char));
}

MyString::~MyString()
{
	if (NULL != m_pString)
	{
		delete[] m_pString;
		m_pString = NULL;
	}
}

MyString & MyString::operator=(const MyString & another)
{
	if (NULL != m_pString)
	{
		delete[] m_pString;
		m_size = 0;
		m_pString = NULL;
	}
	m_size = another.m_size;
	m_pString = new char[m_size + 1];
	memcpy(m_pString, another.m_pString, (m_size + 1) * sizeof(char));
	return *this;	
}

MyString & MyString::operator=(const char * code)
{
	if (code != NULL)
	{
		m_size = strlen(code);
		m_pString = new char[m_size + 1];
		memcpy(m_pString, code, (m_size + 1) * sizeof(char));
		return *this;
	}
	m_size = 0;
	m_pString = new char[1];
	memcpy(m_pString, "", sizeof(char));
	return *this;
}

MyString MyString::operator+(const MyString & another)
{
	MyString tempStr;
	tempStr.m_size = m_size + another.m_size;
	tempStr.m_pString = new char[tempStr.m_size + 1];
	memcpy(tempStr.m_pString, m_pString, (tempStr.m_size + 1) * sizeof(char));
	strcat(tempStr.m_pString, another.m_pString); 
	return tempStr;
}



Iterator MyString::begin()
{
	if (NULL != m_pString)
	{
		m_pIterator = m_pString;
	}
	return m_pIterator;
}

Iterator MyString::end()
{
	m_pIterator = &(m_pString[m_size + 1]);
	return m_pIterator;
}

std::ostream & operator<<(std::ostream & ostream, const MyString & string)
{
	ostream << string.m_pString << std::endl;
	return ostream;

}

std::istream & operator>>(std::istream & istream, MyString & string)
{
	char tempStr[1000] = {0};
	istream >> tempStr;
	string.m_size = strlen(tempStr);
	string.m_pString = new char[string.m_size + 1];
	memcpy(string.m_pString, tempStr, (string.m_size + 1) * sizeof(char));
	return istream;
}

bool MyString::operator==(const MyString & another)
{
	return compare(m_pString, another.m_pString, m_size, another.m_size);
}

char & MyString::operator[](int index)
{
	if (index > m_size)
	{
		return m_pString[m_size];
	}
	return m_pString[index];
}

int MyString::size()
{
	return m_size;
}

bool MyString::compare(const char * str, const char * other, int strSize, int otherSize)
{
	if (strSize != otherSize)
	{
		return false;
	}
	for (int i = 0; i < strSize; ++i)
	{
		if ((*str) != (*other))
		{
			return false;
		}
	}
	return true;
}

最后是main.cpp

#include "MyString.h"

int main()
{
	MyString str1("happy");
	MyString str2(" world");
	MyString str3("baby");
	MyString str5("!");
	MyString str4 = str1 + str2;
	if (str3 == str5)
	{
		std::cout << str4;
	}
	else
	{
		std::cout << str4.size() << std::endl;
	}
	for (auto itor = str1.begin(); itor != str1.end(); ++itor)
	{
		std::cout << *itor << std::endl;
	}
	std::cout << str4[5] << std::endl;

}

        欢迎大家讨论指正