C++第九弹

admin管理员组
文章数量:1794759

C++第九弹

前言

本文介绍了C++标准库中的string类，包括其定义、使用方法、常用接口.

更多详情点击主页: 酷酷学!!! 持续关注

正文开始

标准库中的string类

C语言中的字符串:

C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string类，很少有人去使用C库中的字符串操作函数。

1. string类

字符串是表示字符序列的类
标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。
string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits 和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。
注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。

总结：

string是表示字符串的字符串类
该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator> string;
不能操作多字节或者变长字符的序列。

在使用string类时，必须包含#include头文件以及using namespace std;

2. string类的常用接口说明

string类对象的常见构造

代码语言：javascript代码运行次数：0运行复制

void test_string1()
{
	string s1;//默认构造
	string s2("hello world");//带参构造
	string s3(s2);//拷贝构造

	string s4(s2, 3, 5);
	string s5(s2, 3);
	string s6(s2, 3, 30);
	string s7("hello world", 5);
	string s8(10, 'x');

	cout << s1 << endl;
	cout << s2 << endl;
	cout << s3 << endl;
	cout << s4 << endl;
	cout << s5 << endl;
	cout << s6 << endl;
	cout << s7 << endl;
	cout << s8 << endl;

	cin >> s1;
	cout << s1 << endl;
}

string类对象的容量操作

注意

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

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

string类对象的修改操作

注意：

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

string类非成员函数

C++参考文档中string的接口: string - C++

vs和g++下string结构的说明

注意：下述结构是在32位平台下进行验证，32位平台下指针占4个字节。

vs下string的结构

string总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，联合体用来定义string中字符串的存储空间：

当字符串长度小于16时，使用内部固定的字符数组来存放当字符串长度大于等于16时，从堆上开辟空间

代码语言：javascript代码运行次数：0运行复制

union _Bxty
{ // storage for small buffer or pointer to larger one
 value_type _Buf[_BUF_SIZE];
 pointer _Ptr;
 char _Alias[_BUF_SIZE]; // to permit aliasing
} _Bx;

这种设计也是有一定道理的，大多数情况下字符串的长度都小于16，那string对象创建好之后，内部已经有了16个字符数组的固定空间，不需要通过堆创建，效率高。其次：还有一个size_t字段保存字符串长度，一个size_t字段保存从堆上开辟空间总的容量最后：还有一个指针做一些其他事情。

故总共占16+4+4+4=28个字节。

g++下string的结构

G++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个指针，该指针将来指向一块堆空间，内部包含了如下字段：

空间总大小字符串有效长度引用计数

代码语言：javascript代码运行次数：0运行复制

struct _Rep_base
{
 size_type _M_length;
 size_type _M_capacity;
 _Atomic_word _M_refcount;
};

指向堆空间的指针，用来存储字符串。

string类的模拟实现

代码语言：javascript代码运行次数：0运行复制

#pragma once
#include<iostream>
#include<assert.h>

//namespace my
//{
//	class string
//	{
//	public:
//		string(const char* str = "")
//			:_size(strlen(str)) //初始化按照声明顺序
//		{
//			_str = new char[_size + 1];
//			_capacity = _size;
//			strcpy(_str, str);//相当于把字符拷贝到字符数组当中了
//		}
//
//		string(const string& s)
//		{
//			//需要进行深拷贝,浅拷贝需要析构两次,程序崩溃
//			_str = new char[s._capacity + 1];
//			strcpy(_str, s._str);//这里也是深拷贝,把一个字符数组的内容拷贝到另一个字符数组中
//			_size = s._size;
//			_capacity = s._capacity;
//		}
//
//		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()
//		{
//			delete[] _str;
//			_str = nullptr;
//			_size = _capacity = 0;
//		}
//
//	private:
//		char* _str;
//		size_t _capacity;
//		size_t _size;
//	};
//}

namespace my
{
	class string
	{
	public:

		string(const char* str = "")
		{
			_size = strlen(str);
			_str = new char[_size + 1];
			_capacity = _size;
			strcpy(_str, str);
 		}

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

		//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()
		{
			if (_str)
			{
				delete[] _str;
				_str = nullptr;
			}
			_capacity = _size = 0;
		}

		void swap(string& s)
		{
			std::swap(_str,s._str);
			std::swap(_capacity, s._capacity);
			std::swap(_size, s._size);
		}

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

		string& operator=(string s)
		{
			swap(s);
			return *this;
		}

		//迭代器
		typedef char* iterator;

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

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

		void push_back(char ch)
		{
			//if (_size == _capacity)
			//{
			//	size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			//	reserve(newcapacity);
			//}
			//_str[_size] = ch;
			//_str[_size + 1] = '\0';
			//++_size;
			insert(_size, ch);
		}

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

		void insert(size_t pos, const char c)
		{
			assert(pos <= _size);
			if (_size == _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}
			size_t end = _size + 1;
			while (end > pos)
			{
				_str[end] = _str[end - 1];
				--end;
			}
			_str[pos] = c;
			_size += 1;
		}

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

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

		void erase(size_t pos, size_t len)
		{
			assert(pos < _size);
			if (len >= _size - pos) //如果len大于后面可删除的长度
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
		}

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

上面已经对string类进行了简单的介绍，大家只要能够正常使用即可。在面试中，面试官总喜欢让学生自己来模拟实现string类，最主要是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数。大家看下以下string类的实现是否有问题？

代码语言：javascript代码运行次数：0运行复制

// 为了和标准库区分，此处使用String
class String
{
public: /*String()
 :_str(new char[1])
 {*_str = '\0';}
 */
 //String(const char* str = "\0") 错误示范
 //String(const char* str = nullptr) 错误示范
	String(const char* str = "")
	{
		// 构造String类对象时，如果传递nullptr指针，可以认为程序非
		if (nullptr == str)
		{
			assert(false);
			return;
		}

		_str = new char[strlen(str) + 1];
		strcpy(_str, str);
	}

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

// 测试
void TestString()
{
	String s1("hello bit!!!");
	String s2(s1);
}

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

1. 浅拷贝

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

就像一个家庭中有两个孩子，但父母只买了一份玩具，两个孩子愿意一块玩，则万事大吉，万一不想分享就你争我夺，玩具损坏。

可以采用深拷贝解决浅拷贝问题，即：每个对象都有一份独立的资源，不要和其他对象共享。父母给每个孩子都买一份玩具，各自玩各自的就不会有问题了。

2. 深拷贝

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

传统版写法

代码语言：javascript代码运行次数：0运行复制

namespace my
{

	class string
	{
	public:
		string(const char* str = "")
		{
			if (str == nullptr)
			{
				assert(false);
				return;
			}
			_str = new char[strlen(str) + 1];
			strcpy(_str, str);
		}

		string(const string& str)
			:_str(new char[strlen(str._str) + 1])
		{
			strcpy(_str, str._str);
		}

		string& operator=(const string& s)
		{
			if (this != &s)
			{
				char* pstr = new char[strlen(s._str) + 1];
				strcpy(_str, s._str);
				delete[] _str;
				_str = pstr;

			}
			return *this;
		}

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

}

现代版写法

代码语言：javascript代码运行次数：0运行复制

namespace my
{
	class string
	{
	public:
		string(const char* str = "")
		{
			if (nullptr == str)
			{
				assert(false);
				return;
			}
			_str = new char[strlen(str) + 1];
			strcpy(_str, str);
		}

		string(const string& s)
			:_str(nullptr)
		{
			string Tmp(s._str);
			std:: swap(_str, Tmp._str);
		}

		//对比上面和下面的赋值实现
		string& operator=(string s)
		{
			std::swap(_str, s._str);
			return *this;
		}

		string& operator=(const string& s)
		{
			if (this != &s)
			{
				string strTmp(s);
				std::swap(_str, strTmp._str);
			}
			return *this;
		}

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

其余接口模拟实现代码

string.h

代码语言：javascript代码运行次数：0运行复制

#pragma once

#include<iostream>
#include<assert.h>
using namespace std;

namespace mystring
{
	class string
	{
	public:
		//string();
		string(const char* str = "");
		string(const string& s);
		string& operator=(const string& s);
		~string();

		const char* c_str() const;
		size_t size() const;
		char& operator[](size_t pos);
		const char& operator[](size_t pos) const;

		void reserve(size_t n);
		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);
		void insert(size_t pos, const char* str);
		void erase(size_t pos = 0, size_t len = npos);
		
		size_t find(char ch, size_t pos = 0);
		size_t find(const char* str, size_t pos = 0);
		
		void swap(string& s);
		string substr(size_t pos = 0, size_t len = npos);
		
		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 clear();

		//迭代器可理解像指针但不是指针
		typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin();
		iterator end();

		const_iterator begin() const;
		const_iterator end() const;

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

		const static size_t npos;
	};
	istream& operator>>(istream& is, string& str);
	ostream& operator<<(ostream& os, const string& str);
}

string.cpp

代码语言：javascript代码运行次数：0运行复制

#include"string.h"

namespace mystring
{
	const size_t string::npos = -1;

	//string::string()
	//{
	//	_str = new char[1]{'\0'};
	//	_size = 0;
	//	_capacity = 0;
	//}
	//不如写成带缺省参数的构造
	string::string(const char* str)
 		:_size(strlen(str))
	{
		_str = new char[_size + 1];
		_capacity = _size;
		strcpy(_str, str);
	}

	//拷贝构造 深度拷贝
	string::string(const string& s)
	{
		_str = new char[s._capacity + 1];
		strcpy(_str, s._str);
		_size = s._size;
		_capacity = s._capacity;
	}

	string& 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::~string()
	{
		delete[] _str;
		_str = nullptr;
		_size = _capacity = 0;
	}

	//修饰*this,并且返回值为const
	const char* string::c_str() const
	{
		return _str;
	}

	size_t string::size() const
	{
		return _size;
	}
	
	//可修改
	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];
	}

	//修改capacity
	void string::reserve(size_t n)
	{
		//一般不缩容
		if (n > _capacity)
		{
			char* tmp = new char[n + 1];
			strcpy(tmp, _str);
			delete[] _str;
			_str = tmp;
			_capacity = n;
		}
	}

	void string::push_back(char ch)
	{
		if (_size == _capacity)
		{
			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newcapacity);
		}
		_str[_size] = ch;
		_str[_size + 1] = '\0';
		++_size;
	}

	void string::append(const char* str)
	{
		size_t len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}
		strcpy(_str + _size, str);
		_size += len;
	}

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

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

	void string::insert(size_t pos, char ch)
	{
		assert(pos <= _size);
		if (_size == _capacity)
		{
			size_t newcapcity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newcapcity);
		}
		//错误,pos==0会导致越界, end会被转化为无符号整形
		/*int end = _size;
		while (end >= (int)pos)
		{
			_str[end + 1] = _str[end];
			--end;
		}*/

		//在后一个位置,把前一个位置的数据往后挪
		size_t end = _size + 1;
		while (end > pos)
		{
			_str[end] = _str[end - 1];
			--end;
		}
		_str[pos] = ch;
		++_size;
	}

	void string::insert(size_t pos, const char* str)
	{
		assert(pos <= _size);
		size_t len = strlen(str);

		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}

		//法一
		//int end = _size;
		//while (end >= (int)pos)
		//{
		//	_str[end + len] = _str[end];
		//	--end;
		//}
		//法二

		size_t end = _size + len;
		while (end > pos + len - 1)
		{
			_str[end] = _str[end - len];
			--end;
		}
		memcpy(_str + pos, str, len);
		_size += len;
	}
	void string::erase(size_t pos, size_t len)
	{
		assert(pos < _size);

		//len大于前面的字符个数时,有多少删多少
		if (len >= _size - pos)
		{
			_str[pos] = '\0';
			_size = pos;
		}
		else
		{
			strcpy(_str + pos, _str + pos + len);
			_size -= len;
		}
	}

	size_t string::find(char ch, size_t pos)
	{
		for (size_t i = pos; i < _size; i++)
		{
			if (_str[i] == ch)
			{
				return i;
			}
		}
		return npos;
	}

	size_t string::find(const char* str, size_t pos)
	{
		char* p = strstr(_str, str);
		return p - _str;
	}

	void string::swap(string& s)
	{
		std::swap(_str, s._str);
		std::swap(_size, s._size);
		std::swap(_capacity, s._capacity);
	}

	string string::substr(size_t pos, size_t len)
	{
		if (len >= _size - pos)
		{
			string sub(_str + pos);
			return sub;
		}
		else
		{
			string sub;
			sub.reserve(len);
			for (size_t i = 0; i < len; i++)
			{
				sub += _str[pos+i];
			}
			return sub;
		}
	}
	bool string::operator<(const string& s)const
	{
		return strcmp(_str, s._str) < 0;
	}
	bool string::operator>(const string& s)const
	{
		return !(*this <= s);
	}
	bool string::operator<=(const string& s)const
	{
		return *this < s || *this == s;
	}
	bool string::operator>=(const string& s)const
	{
		return !(*this < s);
	}
	bool string::operator==(const string& s)const
	{
		return strcmp(_str, s._str) == 0;
	}
	bool string::operator!=(const string& s)const
	{
		return !(*this == s);
	}
	void string::clear()
	{
		_str[0] = '\0';
		_size = 0;
	}

	istream& operator>>(istream& is, string& str)
	{
		str.clear();
		char ch = is.get();//默认的读取不会读取到' '和\n
		while (ch != ' ' && ch != '\n')
		{
			str += ch;
			ch = is.get();
		}
		return is;
	}
	ostream& operator<<(ostream& os, const string& str)
	{
		for (size_t i = 0; i < str.size(); i++)
		{
			os << str[i];
		}
		return os;
	}

	string::iterator string::begin()
	{
		return _str;
	}
	string::iterator string::end()
	{
		return _str + _size;
	}

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

拓展阅读

面试中string的一种正确写法

STL中的string类怎么了?

总结

本文介绍了C++标准库中的string类，包括其定义、使用方法、常用接口以及与C语言字符串的比较。string类避免了C语言字符串操作的复杂性，提供易用的接口和内存管理，同时还探讨了浅拷贝与深拷贝的概念，以帮助开发者更好地理解在管理动态内存时的潜在问题。最后感谢您的点赞关注~

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。原始发表：2024-07-28，如有侵权请联系 cloudcommunity@tencent 删除sizestlstring字符串c++

本文标签： C第九弹

版权声明：本文标题：C++第九弹内容由林淑君副主任自发贡献，该文观点仅代表作者本人，转载请联系作者并注明出处：http://www.xiehuijuan.com/baike/1754790883a1706484.html，本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。

写会百科网

C++第九弹

C++第九弹

前言

标准库中的string类

1. string类

2. string类的常用接口说明

string类的模拟实现

1. 浅拷贝

2. 深拷贝

总结

更多相关文章

C++第九弹

发表评论

推荐文章

策略路由与路由策略的区别

C语言详解（预编译）

掌握死锁检测：策略和最佳实践

如何快速上手一个新项目？

探索后量子安全：基于格加密技术的未来密码学展望

热门文章

SSHamble：测试您的服务器是否存在潜在的SSH问题

【C++】 —— string的使用

【Docker Compose系列】Docker Compose中depends

性能测试流程规范测试准备阶段

Idea SpringBoot 子模块 加载不到该子模块根目录config下面的配置文件

C# try, catch, finally

【C语言】预处理

MobaXterm升级专业版

宝塔一键迁移网站后出现错误“unknown &quot;connection

Linux 查看端口占用及是否开放命令

最新文章

Linux系统之jobs命令的基本使用

手把手教学！简单上手“AI复活”技术

单细胞Seruat和h5ad数据格式互换(R与python)方法学习和整理

JVM专题

学会5个图表，让数据分析简洁高效

写“藤”的作文1200字

有关于进步的作文

幼儿园见习报告

语数英寒假作业上册答案五年级

伊索寓言经典语词句摘抄

Idea SpringBoot 子模块加载不到该子模块根目录config下面的配置文件

宝塔一键迁移网站后出现错误“unknown "connection