C++运算符重载二：模拟实现string类

模拟实现string类：

我们使用C语言的string时，有一些不方便的地方：
1.定义数组的时候大小必须固定。
2.字符串进行比较大小，连接的时候必须调用相应的字符串操作函数。
3.还必须考虑内存是否够用，操作起来比较麻烦。
而我们C++提供了string类型，操作起来比较简单，这些操作都可以通过string来使用：

string str1;//默认构造
string str2 = "aaa";//string(const char*) 
string str3 = "bbb";
string str4 = str2 + str3;
string str5 = str2 + "ccc";
string str6 = "ddd" + str2;

cout << "str6:" << str6 << endl;
if (str5 > str6)
{
	cout << str5 << " > " << str6 << endl;
}
else
{
	cout << str5 << " < " << str6 << endl;
}

int len = str6.length();
for (int i=0; i<len; ++i)
{
	cout << str6[i] << " ";
}
cout << endl;

//string->char*
char buf[1024] = {0};
strcpy(buf, str6.c_str());//将string对象的字符串拷贝到C中的字符数组中
cout << "buf:" << buf << endl;

调用库中的string执行一下：执行成功。

现在，我们利用运算符重载来模拟一下string类将其简单实现：

//自己实现的string类
class String
{
public:
	String(const char *p = nullptr)
	{
		if (p != nullptr)
		{
			_pstr = new char[strlen(p) + 1];
			strcpy(_pstr, p);
		}
		else
		{
			_pstr = new char[1];
			*_pstr = '0';
		}
	}
	~String()
	{
		delete[]_pstr;
		_pstr = nullptr;
	}
	String(const String &str)
	{
		_pstr = new char[strlen(str._pstr) + 1];
		strcpy(_pstr, str._pstr);
	}
	String& operator=(const String &str)
	{
		if (this == &str)
		{
			return *this;
		}
		delete[]_pstr;

		_pstr = new char[strlen(_pstr) + 1];
		strcpy(_pstr, str._pstr);
		return *this;
	}
	bool operator>(const String &str)const
	{
		return strcmp(_pstr, str._pstr) > 0;
	}
	bool operator<(const String &str)const
	{
		return strcmp(_pstr, str._pstr) < 0;
	}
	bool operator==(const String &str)const
	{
		return strcmp(_pstr, str._pstr) == 0;
	}
	int length()const
	{
		return strlen(_pstr);
	}
	char& operator[](int index)
	{
		return _pstr[index];
	}
	const char& operator[](int index)const
	{
		return _pstr[index];
	}
	const char* c_str()const//返回字符串底层管理的char*，返回为const char*
	{
		return _pstr;
	}
private:
	char *_pstr;
	friend ostream& operator<<(ostream &out, const String &str);
	friend String operator+(const String &lhs, const String &rhs);
};

String operator+(const String &lhs, const String &rhs)
{
	char *ptmp = new char[strlen(lhs._pstr) + strlen(rhs._pstr) + 1];
	strcpy(ptmp, lhs._pstr);
	strcat(ptmp, rhs._pstr);
	String tmp(ptmp);//防止内存泄露，但效率低
	delete[]ptmp;
	return tmp;
}

ostream& operator<<(ostream &out, const String &str)
{
	out << str._pstr;
	return out;
}

执行结果：执行成功。

虽然实现了功能，但是这里我们的+运算符重载函数，功能实现是可以的，但是效率并不高。 ptmp指向了一块内存，进行字符串拷贝与连接之后，将它当作一个参数传入构造的tmp对象中。tmp字符串构造函数中，又会根据外面传入的指针，开辟字符串底层的指针，再进行数据拷贝。最后再将字符串内存delete，return tmp后，还要再析构一次。总共发生了2次new，2次delete，效率太低。
我们对其改进一下：
直接定义一个tmp对象，直接为其底层进行内存开辟，拷贝与连接也直接到其底层的字符串对象中，最后出作用域析构将其底层指针delete。总共发生了1次new，1次delete，效率提高了。

String operator+(const String &lhs, const String &rhs)
{
	String tmp;
	tmp._pstr = new char[strlen(lhs._pstr) + strlen(rhs._pstr) + 1];
	strcpy(tmp._pstr, lhs._pstr);
	strcat(tmp._pstr, rhs._pstr);
	
	return tmp;
}

来源：CSDN

作者：硕～

链接：https://blog.csdn.net/qq_42441693/article/details/104797222