个人主页~
string类（上）

string类

• 二、模拟实现string类
• • 1、头文件string.h
  • 2、常见构造
  • 3、容量函数
  • 4、访问及遍历
  • 5、类对象修改
  • 6、流插入流提取重载

二、模拟实现string类

今天我们来实现一下上篇文章中详细介绍过的接口

1、头文件string.h

#pragma once #include  #include   //const和非const迭代器 typedef char* iterator; typedef const char* const_iterator;  namespace little_monster { 	class string 	{ 	public: 		//重载流输入流提取操作符 		friend std::ostream& operator<<(std::ostream& out, const string& s) 		{ 			for (auto ch : s) 			{ 				out << ch; 			}//范围for一个一个读取 			return out; 		}  		friend std::istream& operator>>(std::istream& in, string& s) 		{ 			s.clear();//清理掉原来的资源 			char buff[129]; 			size_t i = 0; 			char ch; 			ch = in.get();//获取第一个字符 			while (ch != ' ' && ch != '\n') 			{ 				buff[i++] = ch; 				if (i == 128) 				{ 					buff[i] = '\0'; 					s += buff; 					i = 0; 				} 				ch = in.get(); 			}//持续获取字符，如果满128就存到s中，将i置为0继续获取，直到遇到空格或者换行停止获取 			if (i != 0) 			{ 				buff[i] = '\0'; 				s += buff; 			}//如果此时的i不为0，那么就在此位置加一个'\0'，这个位置是有效数据的后一个位置 			return in; 		}		 		//定义一个npos 		const static size_t npos = -1; 		 		//构造、拷贝、析构函数 		string(const char* str); 		string(const string& s); 		~string(); 		 		//有关于类容量的接口 		size_t size() const;//当前数据个数 		size_t capacity() const;//容量 		bool empty();//判空 		void reserve(size_t n);//预留空间 		void clear();//清理资源 		void resize(size_t n,char ch);//调整大小并补齐 		 		//访问以及遍历的接口 		char& operator[](size_t pos); 		const char& operator[](size_t pos) const;//重载下标访问操作符 		iterator begin(); 		const_iterator begin() const;//迭代器begin 		iterator end(); 		const_iterator end() const;//迭代器end //迭代器有很多都是指针，但也有很多不是指针，string类这里的迭代器是指针 		 		//类对象修改的接口 		void push_back(char ch);//尾插一个字符 		void append(const char* str);//尾插一个字符串 		string& operator+=(char ch);//尾插一个字符 		string& operator+=(const char* str);//尾插一个字符串 		void insert(size_t pos,char ch);//pos位置插入一个字符 		void insert(size_t pos, const char* str);//pos位置插入一个字符串 		void erase(size_t pos,size_t len);//pos位置开始往后删除len个字符 		size_t find(char ch, size_t pos);//从pos位置开始往后查找到第一个ch字符，返回它的索引 		size_t find(const char* sub,size_t pos); 		//pos位置开始往后查找到第一个sub指向的字符串，返回第一个字符的索引 		const char* c_str() const;//类转化为c格式 		string substr(size_t pos,size_t len);//从字符串pos位置开始提取len个字符 		string& operator=(string tmp);//重载=操作符 		 		//重载运算符接口 		bool operator<(const string& s) const; 		bool operator==(const string& s) const; 		bool operator>(const string& s) const; 		bool operator<=(const string& s) const; 		bool operator>=(const string& s) const; 		bool operator!=(const string& s) const; 		 		//类交换函数 		void swap(string& s); 	private: 		char* _str;//指向字符串的指针 		size_t _size;//字符个数 		size_t _capacity;//容量 	}; } 

2、常见构造

构造函数、拷贝构造、析构函数

//交换函数 void::string::swap(string& s) { 	std::swap(_str, s._str); 	std::swap(_capacity, s._capacity); 	std::swap(_size, s._size); 	//交换值 }  //构造函数 string::string(const char* str = "")//给一个缺省值，在无参时为'\0' 	:_size((size_t)strlen(str))//强制类型转换为size_t型 	, _capacity(_size) { 	_str = new char[_capacity + 1]; 	strcpy(_str, str); }  //拷贝构造函数 string::string(const string& s) 	:_str(nullptr) 	,_size(0) 	,_capacity(0) { 	string tmp(s._str); 	swap(tmp); }  //析构函数 string::~string() { 	if(_str) 	{ 		delete[] _str; 		_str = nullptr; 		_size = _capacity = 0; 	} } 

构造函数new的地方开多一个空间放’\0’,因为是字符串，由于初始化时的顺序是按照声明的顺序，在初始化列表初始化指针_str会因为容量无数据导致随机值，所以我们不用初始化列表初始化指针_str，等它们通过初始化列表初始化完成后再赋初值

拷贝构造函数是拷贝构造的一种方法，创建一个拷贝对象，将该对象按照初始化列表初始化为一个空类，用s的_str指针构造一个tmp类，然后将tmp类的参数与空类的参数进行swap互换，这样此时的空类也就是拷贝对象就有了数据，并且tmp作为一个临时类，会在函数结束后自动调用析构函数析构

析构函数就很简单了，按照delete[]的方式释放空间后将指针_str置为空，然后将容量和大小置为0，但其实容量和大小没必要操作的，这个无所谓

构造函数和拷贝构造调试：

析构函数调试：先析构s2再析构s1

3、容量函数

size、empty、capacity、reserve、clear、resize

函数后面加一个const我们讲过，因为this指针是隐参数，不能在括号里边修饰，后加const修饰的是隐参数this

size_t string::size() const { 	return _size; }  size_t string::capacity() const { 	return _capacity; }  bool string::empty() { 	if (_size == 0) 	{ 		return true; 	} 	return false; }  void string::reserve(size_t n) { 	if (n > _capacity)//n < _capacity不用预留 	{ 		char* tmp = new char[n + 1];//创建一个指针tmp指向new出来的n+1大小的字符串位置 		strcpy(tmp, _str);//将内容拷贝过去 		delete[] _str;//释放原来的空间 		_str = tmp;//指针指向tmp的位置 		_capacity = n;//将容量置为n 	}//这里不用担心tmp没有置空的问题，因为除了作用域tmp就会销毁，其他人是访问不到的 }  void string::clear() { 	_str[0] = '\0'; 	_size = 0; }//将第一个位置放\0，然后size为0就可以使后来的数据覆盖原来的数据，访问时也只有\0  void string::resize(size_t n,char ch = '\0') { 	if (n <= _size) 	{ 		_str[n] = '\0'; 	}//如果n<=size，就是缩小或者不动，直接在n的位置放一个'\0'就可以了 	else 	{ 		reserve(n);//如果n>_size，不管_capacity是多大直接预留出n个位置 		while (n > _size) 		{ 			_str[_size] = ch; 			++_size; 		}//将ch填充进去，ch若是没有就是缺省参数'\0' 		_str[_size] = '\0';//在最后的位置填一个'\0' 	} } 

4、访问及遍历

operator[]、begin和end

char& string::operator[](size_t pos) { 	assert(pos < _size); 	return _str[pos]; }  const char& string::operator[](size_t pos) const { 	assert(pos < _size); 	return _str[pos]; }  iterator string::begin() { 	return _str; }  const_iterator string::begin() const { 	return _str; }  iterator string::end() { 	return _str + _size; }  const_iterator string::end() const { 	return _str + _size; } 

范围for用的就是迭代器begin和end
这是还未进入范围for的调试过程

进入范围for，首先找到迭代器begin

然后找到迭代器end

5、类对象修改

operator+=、push_back、append、insert、erase、find、c_str、substr、operator=

void string::push_back(char ch) { 	if (_size == _capacity) 	{ 		reserve(_capacity == 0 ? 4 : 2 * _capacity); 	}//空间问题，如果空间为0，则开辟空间 	_str[_size++] = ch; 	_str[_size] = '\0';//在最后的位置插入后++，在++后的位置放一个'\0' }  void string::append(const char* str) { 	size_t len = strlen(str);//len是字符串有效字符的个数 	if (_capacity < (len + _size)) 	{ 		reserve(len + _size); 	}//如果容量较小，就预留出刚刚够的空间 	strcpy(_str + _size, str);//将str拷贝到_str的后面，strcpy的拷贝是包括'\0'的 	_size += len; }  string& string::operator+=(char ch) { 	push_back(ch); 	return *this;//复用push_back }  string& string::operator+=(const char* str) { 	append(str); 	return *this;//复用append }  void string::insert(size_t pos, char ch) { 	assert(pos <= _size); 	size_t n = _size + 1; 	if (_size == _capacity) 	{ 		reserve(_capacity == 0 ? 4 : 2 * _capacity); 	} 	while (pos < n) 	{ 		_str[n] = _str[n - 1]; 		--n; 	} 	_str[pos] = ch; 	++_size; }  void string::insert(size_t pos, const char* str) { 	assert(pos <= _size); 	size_t len = strlen(str); 	if (len + _size > _capacity) 	{ 		reserve(len + _size); 	} 	int n = (int)_size; 	while (n >= (int)pos) 	{ 		_str[n + len] = _str[n]; 		--n; 	} 	strncpy(_str + pos, str, len); 	_size += len; }  void string::erase(size_t pos, size_t len = npos) { 	assert(pos < _size); 	if (len == npos || len + pos > _size) 	{ 		_str[pos] = '\0'; 		_size = pos; 	}//如果len太大，就是从pos开始往后删干净 	else 	{ 		size_t begin = pos + len;//这里的begin其实是移动数据的begin而不是删除那段数据的begin 		while (begin < _size) 		{ 			_str[begin - len] = _str[begin]; 			begin++; 		}//将数据移动到len个位置之前 		_size -= len; 	} }  size_t string::find(char ch, size_t pos = 0) { 	for (int i = (int)pos; i < _size; i++) 	{ 		if (_str[i] == ch) 		{ 			return i; 		} 	} 	return npos; }  size_t string::find(const char* sub, size_t pos = 0) { 	const char* p = strstr(_str, sub); 	if (p) 	{ 		return p - _str; 	} 	return npos; }  string string::substr(size_t pos, size_t len = npos) { 	string s; 	size_t end = pos + len;//找到末尾的位置end 	if (len == npos || pos + len >= _size) 	{ 		len = _size - pos; 		end = _size; 	}//如果len太大就直接从pos位置截取到最后  	s.reserve(len);//给新创建的类预留len大小的空间 	for (size_t i = pos; i < end; i++) 	{ 		s += _str[i]; 	}//从pos位置开始，一直到end，输入所需要插入的字符  	return s; }  string& string::operator=(string tmp) { 	swap(tmp);  	return *this; }  const char* string::c_str() const { 	return _str; } 

insert一个字符这里，插入一个字符，就是在最后位置开始往后移动一位，一直到pos位置，这样pos位置就空出来了，再把ch字符填入到pos位置，比较简单

insert字符串也是差不多的方法，插入一个字符串，用类似append那里的方法，先要知道当前的容量够不够容纳这两段字符串，然后不够就用reserve预留空间，然后再将字符从最后面挨个王后移动 len 位次，最后把字符串放里边，当然这次不要’\0’，所以我们用strncpy

find一个字符这里，找到从pos位置开始的第一个字符ch很简单，直接for循环比对就可以了，比较简单

find字符串需要请出C语言中的函数strstr，它可以比对两个指针指向位置的字符串是否有重合的部分，如果有就返回重合那部分的指针，如果没有返回空，指针减去指针得到两指针之间的数据个数

operator=的实现方式是一种极简的方法，也叫现代方法，直接将两者的数据进行交换，参数类tmp在出作用域也会自动调用析构函数销毁，代码简洁，很方便

6、流插入流提取重载

代码搁上边头文件里

今日分享就到这了~