C++-string概念及实现

Posted 2021-05-17 天津 唐秙

文章目录

• 1. 为什么要学习string类
• 2. string类
• 3. string类的常见接口说明
• • 3.1 string类对象的常见构造
  • 3.2 string类对象的容量操作
  • 3.3 string类对象的访问及遍历操作
  • 3.4 string类对象的修改操作
  • 3.5 string类非成员函数
• 4. 浅拷贝
• 5. 深拷贝
• 6. string类实现
• 7. 写时拷贝

1. 为什么要学习string类

  C语言中，字符串是以’\\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP（Object Oriented Programming）的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。

2. string类

  1.string是表示字符串的字符串类
  2.该类的接口与常规容器的接口基本相同，再添加一些专门用来操作的string的常规操作。
  3.string在底层实际上是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator> string;
  4.不能操作多个字节或者变长字符的序列。
  5.在使用string类时，必须包含#include头文件以及using namespace std;

3. string类的常见接口说明

3.1 string类对象的常见构造

constructor函数名称	功能说明
string	构造空的string类对象，即空字符串
string(const char*s	用C-string来构造string类对象
string(size_t n, char c	string类对象中包含n个字符c
string（const string&s）	拷贝构造函数

3.2 string类对象的容量操作

函数名称	功能说明
size	返回字符串有效字符长度
length	返回字符串有效字符长度
capacity	返回空间总大小
empty	检测字符串释放为空串，是返回true，否则返回false
clear	清空有效字符
reserve	为字符串预留空间
resize	将有效字符的个数改为n个，多出的空间用字符c填充

注意:
  1.size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
  2.clear()只是将string中有效字符清空，不改变底层空间大小。
  3.resize(size_t n)与resize(size_t, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
  4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。

3.3 string类对象的访问及遍历操作

函数名称	功能说明
operator[]	返回pos位置的字符，const string类对象调用
begin + end	begin获取一个字符的迭代器+end获取最后一个字符下一个位置的迭代器
rbegin+rend	begin获取一个字符的迭代器+end获取最后一个字符下一个位置的迭代器
范围for	C++11支持更简洁的范围for的新遍历方式

3.4 string类对象的修改操作

函数名称	功能说明
push back	在字符串后尾插字符c
append	在字符串后追加一个字符串
operator+=	在字符串后追加字符串str
c str	返回c格式字符串
find+npos	从字符串pos位置开始往后找字符，返回该字符在字符串中的位置
rfind	从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置
substr	在str中从pos位置开始，截取n个字符，然后将其返回

注意：
  1.在string尾部追加字符时，s.push_back© / s.append(1, c) / s += 'c’三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
  2.对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。

3.5 string类非成员函数

函数	功能说明
operator+	尽量少用，因为传值返回，导致深拷贝效率低
operator>>	输入运算符重载
operator<<	输出运算符重载
getline	获取一行字符串
relational operators	大小比较

4. 浅拷贝

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

5. 深拷贝

  如果一个类中涉及到资源的管理，其拷贝构造函数，赋值运算符重载以及构造函数必须要显示给出，一般按照深拷贝方法提供。

6. string类实现

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

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

		return *this;
	}

	//析构函数
	~string()
	{
		if (_str)
		{
			delete[] _str;
			_str = nullptr;
		}
	}
private:
	char* _str;
};

7. 写时拷贝

  写时拷贝是在浅拷贝的基础上增加了引用计数的方式来实现的。
引用计数：
  用来记录资源使用者的个数，在构造的时候，将资源的计数给成了1，每增加一个对象使用该资源，就给计数器增加1，当某个对象被销毁的时候，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象是使用该资源的最后一个使用者，将该对象释放，该资源也将被释放。

namespace bit58
{
	class string
	{
		friend ostream& operator<<(ostream &out, const string &s);
	public:
		typedef char* iterator;
	public:
		string() :_str(nullptr), _capacity(0), _size(0)
		{
			_str = new char[1];
			_str[0] = '\\0';
		}
		string(const char *str)
		{
			int len = strlen(str);
			_str = new char[len + 1];
			strcpy(_str, str);
			_capacity = len;
			_size = len;
		}
		string(const string &s) :_str(nullptr), _capacity(0), _size(0)
		{
			string tmp(s._str);
			swap(tmp); //swap(*this, tmp);
		}
		~string()
		{
			if (_str)
			{
				delete[]_str;
				_str = nullptr;
				_capacity = _size = 0;
			}

		}
	public:
		size_t size()const
		{
			return _size;
		}
		size_t capacity()const
		{
			return _capacity;
		}
		bool empty()const
		{
			return size() == 0;
		}
	public:
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
	public:
		const char* c_str()const
		{
			return _str;
		}
		char& operator[](int pos)
		{
			assert(pos >= 0 && pos<size());
			return _str[pos];
		}
	public:
		void push_back(char c)
		{
			if (_size + 1 > _capacity)
			{
				int new_capacity = _capacity == 0 ? 1 : 2 * _capacity;
				reserve(new_capacity);
			}
			_str[_size++] = c;
			_str[_size] = '\\0';
		}
		string& operator+=(char c)
		{
			push_back(c);
			return *this;
		}
		string& operator+=(const char *str)
		{
			while (*str != '\\0')
				push_back(*str++);
			return *this;
		}
	public:
		void clear()
		{
			_str[0] = '\\0';
			_size = 0;
		}
		void resize(size_t newSize, char c = '\\0')
		{
			if (newSize > _capacity)
			{
				reserve(newSize);
				memset(_str + _size, c, newSize - _size);
				_size = newSize;
			}

			_str[newSize] = '\\0';
			_size = newSize;
		}
		void reserve(size_t newCapacity)
		{
			if (newCapacity > _capacity)
			{
				char *new_str = new char[newCapacity + 1];
				memset(new_str, 0, newCapacity + 1);
				memcpy(new_str, _str, _capacity);
				delete[]_str;
				_str = new_str;

				_capacity = newCapacity;
			}
		}
	public:
		void swap(string &s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}
	private:
		char *_str;
		size_t _capacity;
		size_t _size;
	};

	ostream& operator<<(ostream &out, const string &s)
	{
		out << s._str;
		return out;
	}
};