1.头文件

//String.h
#pragma once
#include <string.h>
#include <iostream>
class CString
{
	char* m_pData;
	int m_nLength;
public:
	CString();
	CString(const char* p);
	CString(const CString& str);
	CString(const char ch, int nRepeat);
	CString(const char* cstr, int Length);
	~CString();
	int GetLenght() const
	{
		return m_nLength;
	}
	bool IsEmpty() const
	{
		return m_nLength == 0;
	}	
	operator const char*()
	{
		return m_pData;
	}
	void Empty();
	int Find(const char* pszSub, int iStart = 0);
	int Find(const char ch, int iStart = 0);
	CString Mid(int nFirst) const;
	CString Mid(int nFirst, int nCount) const;
	CString Left(int nCount) const;
	CString Right(int nCount) const;
	CString& TrimLeft();
	CString& TrimRight();
	int Compare(CString& str) const;
	char GetAt(int nIndex) const;
	void SetAt(int nIndex, char ch);
	CString& MakeUpper();
	CString& MakeLower();
	CString& MakeReverse();
	//运算符重载
	friend CString operator+(const CString& str1, const CString& str);
	CString& operator=(const CString& str);
	CString& operator=(const char* cstr);
	friend CString& operator+=(CString& str1, const CString& str);
	friend std::ostream& operator<<(std::ostream& out, const CString& str);
	friend std::istream& operator>>(std::istream& in, CString& str);
	friend bool operator!=(const CString& str1, const CString& str2);
	friend bool operator==(const CString& str1, const CString& str2);
	friend bool operator>(const CString& str1, const CString& str2);
	friend bool operator<(const CString& str1, const CString& str2);
	char& operator[](int nIndex);
};

2.源文件

//String.cpp
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <memory.h>
#include "String.h"

CString operator+(const CString& str1, const CString& str2)
{
	int n = str1.GetLenght() + str2.GetLenght();
	CString s;
	s.m_pData = new char[n + 1];
	strcpy(s.m_pData, str1.m_pData);
	strcat(s.m_pData, str2.m_pData);
	s.m_nLength = n;
	return s;
}
CString& operator+=(CString& str1, const CString& str2)
{
	int n = str1.GetLenght() + str2.GetLenght();
	char* p = new char[n + 1];
	strcpy(p, str1.m_pData);
	strcat(p, str2.m_pData);
	delete[]str1.m_pData;
	str1.m_pData = p;
	str1.m_nLength = n;
	return str1;
}
CString& CString::operator=(const CString& str)
{
	if (this->GetLenght() >= str.GetLenght())
		strcpy(this->m_pData, str.m_pData);
	else
	{
		char* p = m_pData;
		m_pData = new char[str.GetLenght() + 1];
		strcpy(m_pData, str.m_pData);
		delete p;
	}
	m_nLength = str.GetLenght();
	return *this;
}
CString& CString::operator=(const char* cstr)
{
	m_nLength = strlen(cstr);
	m_pData = new char[m_nLength + 1];
	strcpy(m_pData, cstr);
	return *this;
}
char& CString::operator[](int nIndex)
{
	return m_pData[nIndex];
}
std::ostream& operator<<(std::ostream& out, const CString& str)
{
	return out << str.m_pData;
}
std::istream& operator >> (std::istream& cin, CString& str)
{
	char s[1024];
	cin >> s;
	str.m_nLength = strlen(s);
	str.m_pData = new char[str.m_nLength + 1];
	strcpy(str.m_pData, s);
	return cin;
}

bool operator!=(const CString& str1, const CString& str2)
{ 
	return strcmp(str1.m_pData, str2.m_pData) != 0 ;
}
bool operator==(const CString& str1, const CString& str2)
{
	return strcmp(str1.m_pData, str2.m_pData) == 0;
}
bool operator>(const CString& str1, const CString& str2)
{
	return strcmp(str1.m_pData, str2.m_pData) > 0;
}
bool operator<(const CString& str1, const CString& str2)
{
	return strcmp(str1.m_pData, str2.m_pData) < 0;
}

CString::CString()
{
	m_pData = new char(0);
	m_nLength = 0;
}
CString::CString(const char* p)
{
	m_nLength = strlen(p);
	m_pData = new char[m_nLength + 1];
	strcpy(m_pData, p);
}
CString::CString(const CString& str)
{
	m_nLength = strlen(str.m_pData);
	m_pData = new char[m_nLength + 1];
	strcpy(m_pData, str.m_pData);
}
CString::CString(const char ch, int nRepeat)
{
	m_pData = new char[nRepeat + 1];
	memset(m_pData, ch, nRepeat);
	m_pData[nRepeat] = '\0';
	m_nLength = nRepeat;
}
CString::CString(const char* cstr, int Length)
{
	int n = strlen(cstr);
	if (n < Length)
		Length = n;
	m_pData = new char[Length + 1];
	memcpy(m_pData, cstr, Length);
	m_pData[Length] = '\0';
	m_nLength = Length;
}
CString::~CString()
{
	delete[]m_pData;
}
void CString::Empty()
{
	delete[]m_pData;
	m_pData = new char(0);
	m_nLength = 0;
}
CString CString::Mid(int nFirst) const
{
	CString str;
	if (nFirst > m_nLength - 1)
		return str;
	delete[]str.m_pData;
	str.m_nLength = m_nLength - nFirst;
	str.m_pData = new char[str.m_nLength+1];
	strcpy(str.m_pData, m_pData + nFirst);
	return str;
}
CString CString::Mid(int nFirst, int nCount) const
{
	CString str;
	delete[]str.m_pData;
	if (m_nLength - nFirst < nCount)
		nCount = m_nLength - nFirst;
	str.m_pData = new char[nCount + 1];
	memcpy(str.m_pData, this->m_pData + nFirst, nCount);
	str.m_pData[nCount] = '\0';
	str.m_nLength = nCount;
	return str;
}
CString CString::Left(int nCount) const
{
	if (nCount > m_nLength)
		nCount = m_nLength;
	CString str;
	delete[]str.m_pData;
	str.m_nLength = nCount;
	str.m_pData = new char[nCount + 1];
	memcpy(str.m_pData, m_pData, nCount);
	str.m_pData[nCount] = '\0';
	return str;
}
CString CString::Right(int nCount) const
{
	if (nCount > m_nLength)
		nCount = m_nLength;
	CString str;
	delete[]str.m_pData;
	str.m_nLength = nCount;
	str.m_pData = new char[nCount + 1];
	memcpy(str.m_pData, m_pData+m_nLength-nCount, nCount);
	str.m_pData[nCount] = '\0';
	return str;
}
CString& CString::MakeUpper()
{
	_strupr_s(m_pData, m_nLength + 1);
	return *this;
}
CString& CString::MakeLower()
{
	_strlwr_s(m_pData, m_nLength + 1);
	return *this;
}
CString& CString::MakeReverse()
{
	char* pbeg = m_pData, *pend = m_pData + m_nLength - 1;
	while (pend-pbeg>0)
	{
		char c = *pbeg;
		*pbeg = *pend;
		*pend = c;
		++pbeg;
		--pend;
	}
	return *this;
}
int CString::Find(const char* pszSub, int iStart)
{
	char* pRes = strstr(m_pData+iStart, pszSub);
	return int(pRes-m_pData);
}
int CString::Find(const char ch, int iStart)
{
	char* pRes = strchr(m_pData + iStart, ch);
	return int(pRes - m_pData);
}
char CString::GetAt(int nIndex) const
{
	return m_pData[nIndex];
}
void CString::SetAt(int nIndex, char ch)
{
	m_pData[nIndex] = ch;
}
int CString::Compare(CString& str) const
{
	return strcmp(m_pData, str.m_pData);
}
CString& CString::TrimLeft()
{
	char *p = m_pData;
	while (*p==' '|| *p == '\n' || *p == '\t')
		++p;
	if (p != m_pData)
	{
		char* pNew = new char[m_nLength-(p-m_pData)+1];
		memcpy(pNew, p, m_nLength - (p - m_pData) + 1);
		delete[]m_pData;
		m_pData = pNew;
		m_nLength = strlen(m_pData);
	}
	return *this;
}
CString& CString::TrimRight()
{
	char *p = m_pData + m_nLength - 1;
	while (*p == ' ' || *p == '\n' || *p == '\t')
		--p;
	if (p != m_pData + m_nLength - 1)
		*(p + 1) = '\0';
	m_nLength = p - m_pData + 1;
	return *this;
}