实现String类

#include <iostream>
#include <string>

using namespace std;

class String
{
public:
    String(const char* str = nullptr);	//构造函数
    String(const String& str);			//拷贝构造
    ~String();
    
    String& operator=(const String& str);	//赋值运算符，返回引用
    String operator+(const String& str) const;	//+运算符，返回右值
    String& operator+=(const String& str);		//+=操作符，返回引用
    char& operator[](int n) const;				//下标操作符,返回引用
    bool operator==(const String& str) const;
    
    int size() const;	//字符串实际大小，不包含操作符
    const char* c_str() const;		//将string转为char*

private:
    char* data;
    int length;
};

String::String(const char* str)		//通用构造
{
    if(str == nullptr)
    {
        length = 0;
        data = new char[1];		//对空字符串自动申请存放结束标志'\0'
        *data = '\0';
    }
    else
    {
        length = strlen(str);
        data = new char[length+1];
        strcpy(data, str);		//拷贝到变量data中
    }
}

String::String(const String& str)	//拷贝构造
{									//深拷贝
    length = str.size();
    data = new char[length + 1];
    strcpy(data, str.c_str());
}

String::~String()
{
	delete[] data;
    length = 0;
}

String& String::operator=(const String& str)	//赋值操作符4步
{
    if(this == &str)
        return *this;	//1 自我赋值，返回自身引用
    delete[] data;		//2 删除原有数据
    
    length = str.size();	//3 深拷贝
    data = new char[length + 1];
    strcpy(data, str.c_str());
    
    return *this;			//4 返回自身引用
}

String String::operator+(const String& str) const //+操作符3步
{//新建对象包括新空间，拷贝两个数据，返回新空间
    String newString;
    newString.length = length + str.size();
  	newString.data = new char[newString.length + 1];
    strcpy(newString.data, data);
    strcat(newString.data, str.data);
    return newString;
}

String& String::operator+=(const String& str)	//+=操作符5步
{//重分配新空间，拷贝两个数据，删除自己原空间，赋值为新空间，返回引用
    length += str.size();	//成员length是实际长度
    char* newdata = new char[length + 1];
    strcpy(newdata, data);
    strcat(newdata, str.c_str());
    delete[] data;
    data = newdata;
    return *this;
}

char& String::operator[](int n) const
{//下标操作符，返回引用
    if(n >= length)
        return data[length - 1];	//如果越界，返回最后一个字符
    else
        return data[n];
}

bool String::operator==(const String& str) const
{
    if(length != str.size())
        return false;
    return strcmp(data, str.c_str()) ? false : true;
}

int String::size() const
{
	return length;
}

const char* String::c_str() const
{
    return data;
}

另一个版本

#include <cstring>
#include <iostream>
using namespace std;
class Mystring
{
	friend ostream& operator<<(ostream& os, const Mystring& obj);

	friend istream& operator>>(istream& is, Mystring& obj);

	friend Mystring operator+(const Mystring& lhs, const Mystring& rhs);

	char* str;

public:
	Mystring();
	
	void pop_bk();
	
	void push_bk(char a);
	
	int get_length();

	void cpy(char s[], int len, int pos);

	void swp(Mystring& rhs);

	Mystring(char* val);
	
	Mystring(const Mystring& source);

	Mystring(Mystring&& source);

	Mystring& operator=(const Mystring& rhs);

	~Mystring() { delete str; }
};

Mystring::Mystring() : str(nullptr)
{
	str = new char[1];
	str[0] = '\0';
}

int Mystring::get_length()
{
	return strlen(str);
}

Mystring::Mystring(char* val)
{
	if (val == nullptr)
	{
		str = new char[1];
		str[0] = '\0';
	}
	else
	{
		str = new char[strlen(val) + 1];
		strcpy(str, val);
		str[strlen(val)] = '\0';
	}
}
Mystring::Mystring(const Mystring& source)
{
	str = new char[strlen(source.str) + 1];
	strcpy(str, source.str);
}

Mystring::Mystring(Mystring&& source)
{
	str = source.str;
	source.str = nullptr;
}

Mystring& Mystring::operator=(const Mystring& rhs)
{
	if (this == &rhs)
		return *this;
	delete[] str;
	str = new char[strlen(rhs.str) + 1];
	strcpy(str, rhs.str);
	return *this;
}

Mystring operator+(const Mystring& lhs, const Mystring& rhs)
{
	int length = strlen(lhs.str) + strlen(rhs.str);
	
	char* buff = new char[length + 1];
	strcpy(buff, lhs.str);
	strcat(buff, rhs.str);
	buff[length] = '\0';

	Mystring temp{ buff };
	delete[] buff;

	return temp;
}

istream& operator>>(istream& is, Mystring& obj)
{
	char* buff = new char[1000];
	memset(&buff[0], 0, sizeof(buff));
	is >> buff;
	obj = Mystring{ buff };
	delete[] buff;
	return is;
}

ostream& operator<<(ostream& os, const Mystring& obj)
{
	os << obj.str;
	return os;
}

void Mystring::swp(Mystring& rhs)
{
	Mystring temp{ rhs };
	rhs = *this;
	*this = temp;
}

void Mystring::cpy(char s[], int len, int pos)
{
	for (int i = 0; i < len; i++)
		s[i] = str[pos + i];
	s[len] = '\0';
}

void Mystring::push_bk(char a)
{
	int length = strlen(str);

	char* buff = new char[length + 2];
	for (int i = 0; i < length; i++)
		buff[i] = str[i];
	buff[length] = a;
	buff[length + 1] = '\0';

	*this = Mystring{ buff };
	delete[] buff;
}

void Mystring::pop_bk()
{
	int length = strlen(str);
	char* buff = new char[length];
	for (int i = 0; i < length - 1; i++)
		buff[i] = str[i];
	buff[length - 1] = '\0';

	*this = Mystring{ buff };
	delete[] buff;
}