string类的基本使用及模拟实现（深浅拷贝）

想变成自大狂

已于 2022-12-29 16:01:56 修改

阅读量377

点赞数 2

分类专栏： # C++ 文章标签： c++ 数据结构开发语言 string

于 2022-12-29 15:36:37 首次发布

本文链接：https://blog.csdn.net/m0_55752775/article/details/128476177

版权

C++ 专栏收录该内容

14 篇文章 1 订阅

订阅专栏

浅拷贝与深拷贝

string的基本使用和模拟实现

浅拷贝与深拷贝

namespace lyl
{
   class string
   {
   public:
       string(const char* str)
           :_str(new char[strlen(str)+1])
       {
           strcpy(_str, str);
       }

       ~string()
       {
           delete[] _str;
           _str = nullptr;
       }
   private:
       char* _str;
   };

   void test_string1()
   {
       string s1("hello world");
       string s2(s1);//拷贝构造

   }
}

上述string类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认的，当用s1构造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。

s1和s2中的_str是同一块地址，即s1和s2指向的是同一块空间。

后定义的变量先析构，当s2生命周期结束后，s2调用析构函数，空间已经被销毁，s1所指向的空间就不存在了，s1就是一个野指针，s1生命周期结束也会调用析构函数，这时就会析构一块不存在的空间，造成程序崩溃。这时由于浅拷贝引起的，所以当涉及到资源申请时，我们需要用到深拷贝，在这里，拷贝构造函数和赋值重载一定是需要我们自己实现的，不能使用默认的。

浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。

深拷贝 ：如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。（给每个对象独立分配资源，保证多个对象不会因共享资源而造成多次释放而造成程序崩溃）

//s2(s1) -----拷贝构造
   string(const string& s)
       :_str(new char[strlen(s._str)+1])
   {
       strcpy(_str, s._str);
   }

string的基本使用和模拟实现

namespace lyl
{
   class string
   {
   public:

//

private:
       char* _str;
       size_t _size;
       size_t _capacity;

       static const size_t npos;
   };

   const size_t string::npos = -1;
}

_size 是当前 vector 容器真实占用的大小，也就是容器当前拥有多少空间。

_capacity 是指在发生 realloc 前能允许的最大元素数，即预分配的内存空间。

构造函数

//构造函数
		string(const char* str = "")
			:_size(strlen(str)),
			_capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

空字符串初始化不能写成string(const char* str = "\0") 或者string(const char* str = nullptr) 。

拷贝构造 s2(s1)

传统写法


		string(const string& s)
			:_size(s._size),
			_capacity(s._capacity)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, s._str);
		}

现代写法（间接复用构造函数）


		string(const string& s)
			:_str(nullptr),
			_size(0),
			_capacity(0)
		{
			string tmp(s);
			swap(tmp);
			strcpy(_str, s._str);
		}

赋值重载（s1=s2）

传统写法

string& operator = (const string& s)
		{
			if (this != &s)
			{
				char* tmp = new char[s._capacity + 1];
				strcpy(tmp, s._str);
				delete[] _str;
				_str = tmp;
				_size = s._size;
				_capacity = s._capacity;
			}
			return *this;
		}

现代写法

string& operator=(const string& s)
		{
			if (this != &s)
			{
				string tmp(s);
				swap(_str, tmp._str);
			}

			return *this;
		}

/*string& operator=(string s)//传值传参调用拷贝构造
		{
			swap(s);

			return *this;
		}*/

析构函数

~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}

c_str()

const char* c_str() const
		{
			return _str;
		}

size()

此函数用于以字节为单位返回字符串的长度。它定义了符合字符串对象内容的实际字节数，不一定等于容量。（有效字符的长度，不包含'\0'）

size_t size() const
		{
			return _size;
		}

[] 操作符

char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

const char& operator[](size_t pos) const
		{
			assert(pos < _size);
			return _str[pos];
		}

使用 [] 操作符访问容器内的对象，很可能出现数组越界的问题。

reserve() ---开辟空间

void reserve (size_t n = 0);

更改_str的容量。

void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n+1];
				strcpy(tmp, _str);
				delete[] _str;

				_str = tmp;

				_capacity = n;
			}
		}

对于 reserve(10) 后接着直接使用 [] 访问越界报错。用at()是抛异常。

resize() ---开辟空间+初始化（如果不给初始化的值，初始化为0）

void resize (size_t n);
void resize (size_t n, char c);

如果 n 小于字符串的长度，则将字符串长度缩短为 n 指定的长度，删除 n 之外的所有字符。

如果 n大于字符串的长度，则字符串长度扩展到 k 指定的长度。

n:n 是第一个参数中指定的字符数。它调整字符串的大小，使字符串包含 k 个字符。
c:如果 n 大于字符串的长度，则 c 是要添加到新空格中的新字符。是可选参数。

void resize(size_t n, char ch = '\0')
		{
			if (n <= _size) 
			{
				_size = n;
				_str[_size] = '\0';
			}
			else
			{
				if (n > _capacity)
				{
					reserve(n);
				}

				memset(_str + _size, ch, n - _size);
				_size = n;
				_str[_size] = '\0';
			}
		}

使用 resize() 容器内的对象内存空间是真正存在的。(_size)

使用 reserve() 仅仅只是修改了 _capacity 的值，容器内的对象并没有真实的内存空间(空间是"野"的)。

push_back(尾插字符)

void push_back(char ch)
		{
			/*if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';*/
			insert(_size, ch);
		}

append() --- 追加字符串

void append(const char* str)
		{
			/*size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}

			strcpy(_str + _size, str);
			_size += len;*/

			insert(_size, str);
		}

+=运算符重载

string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}

find()

寻找字符

size_t find(char ch)
		{
			for (size_t i = 0; i < _size; ++i)
			{
				if (ch == _str[i])
				{
					return i;
				}
			}

			return npos;
		}

寻找字符串

size_t find(const char* s, size_t pos = 0)
		{
			const char* ptr = strstr(_str + pos, s);
			if (ptr == nullptr)
			{
				return npos;
			}
			else
			{
				return ptr -_str;
			}
		}

insert() ---头插

插入字符

string& insert(size_t pos, char ch)
		{
			assert(pos <= _size);

			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}

			size_t end = _size + 1;
			while (end > pos)
			{
				_str[end] = _str[end-1];
				--end;
			}

			_str[pos] = ch;
			++_size;

			return *this;
		}

插入字符串

string& insert(size_t pos, const char* s)
		{
			assert(pos <= _size);
			size_t len = strlen(s);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}

			size_t end = _size + len;
			while (end > pos)
			{
				_str[end] = _str[end - len];
				--end;
			}

			strncpy(_str+pos, s, len);

			return *this;
		}

erase()

string&	erase(size_t pos = 0, size_t len = npos)
		{
			assert(pos < _size);

			if (len == npos || pos+len >= _size)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}

			return *this;
		}

迭代器 （这里可以看做指向字符的一个指针）

begin()此函数提供对第一个元素的引用。

iterator it = s.begin();

        typedef char* iterator;
		typedef const char* const_iterator;

		const_iterator begin() const
		{
			return _str;
		}

		const_iterator end() const
		{
			return _str + _size;
		}

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str+_size;
		}

clear() 函数删除元素，变成一个空字符串。

void clear()
		{
			_str[0] = '\0';
			_size = 0;
		}

运算符重载

    // "abcd"  "abcd"  false
	// "abcd"  "abcde" true
	// "abcde" "abcd"  false 
	bool operator<(const string& s1, const string& s2)
	{
		/*size_t i1 = 0, i2 = 0;
		while (i1 < s1.size() && i2 < s2.size())
		{
			if (s1[i1] < s2[i2])
			{
				return true;
			}
			else if (s1[i1] > s2[i2])
			{
				return false;
			}
			else
			{
				++i1;
				++i2;
			}
		}

		return i2 < s2.size() ? true : false;*/

		return strcmp(s1.c_str(), s2.c_str()) < 0;
	}

    bool operator==(const string& s1, const string& s2)
	{
		return strcmp(s1.c_str(), s2.c_str()) == 0;
	}

	bool operator<=(const string& s1, const string& s2)
	{
		return s1 < s2 || s1 == s2;
	}

	bool operator>(const string& s1, const string& s2)
	{
		return !(s1 <= s2);
	}

	bool operator>=(const string& s1, const string& s2)
	{
		return !(s1 < s2);
	}

	bool operator!=(const string& s1, const string& s2)
	{
		return !(s1 == s2);
	}

<< 流输出

ostream& operator<<(ostream& out, const string& s)
	{
		/*for (auto ch : s)
		{
			out << ch;
		}*/

		for (size_t i = 0; i < s.size(); ++i)
		{
			out << s[i];
		}

		//out << s.c_str(); // 不能这么写

		return out;
	}

>>流提取

istream& operator>>(istream& in, string& s)
	{
		s.clear();

		char ch = in.get();
		while (ch != ' ' && ch != '\n')
		{
			s += ch;
			ch = in.get();
		}

		return in;
	}

rbegin() 函数代表反向开始。该函数用于指向字符串的最后一个字符。它返回指向字符串最后一个字符的反向迭代器。

rend() 函数代表反向结束。该函数指向字符串的第一个字符。它返回一个指向字符串开头的反向迭代器。

empty()函数检查字符串是否为空。函数返回一个布尔值 true 或 false。