C++ string类

目录

[1 · STL简介](#1 · STL简介)

[1 - 1 · 什么是STL](#1 - 1 · 什么是STL)

[1 - 2 · STL的六大核心组件](#1 - 2 · STL的六大核心组件)

[2 · auto和范围for](#2 · auto和范围for)

[2 - 1 · auto关键字](#2 - 1 · auto关键字)

[2 - 2 · 范围for](#2 - 2 · 范围for)

[3 · string类的基本概念](#3 · string类的基本概念)

[4 · string的常用接口](#4 · string的常用接口)

[4 - 1 · 构造](#4 - 1 · 构造)

[4 - 2 · 容量操作](#4 - 2 · 容量操作)

[4 - 3 · 访问与遍历](#4 - 3 · 访问与遍历)

[4 - 4 · 查找与修改](#4 - 4 · 查找与修改)

[4 - 5 · 非成员函数](#4 - 5 · 非成员函数)

[5 · VS下string的结构](#5 · VS下string的结构)

[6 · 浅拷贝 / 深拷贝](#6 · 浅拷贝 / 深拷贝)

[6 - 1 · 模拟实现string类常见的问题](#6 - 1 · 模拟实现string类常见的问题)

[6 - 2 · 浅拷贝](#6 - 2 · 浅拷贝)

[6 - 3 · 深拷贝](#6 - 3 · 深拷贝)

[6 - 4 · 写时拷贝](#6 - 4 · 写时拷贝)

[7 · 拷贝实现的现代写法与传统写法](#7 · 拷贝实现的现代写法与传统写法)

[7 - 1 · 传统写法](#7 - 1 · 传统写法)

[7 - 2 · 现代写法](#7 - 2 · 现代写法)

[8 · string类的模拟实现](#8 · string类的模拟实现)

[8 - 1 · string.h](#8 - 1 · string.h)

[8 - 2 · string.cpp](#8 - 2 · string.cpp)

---

1 · STL简介

1 - 1 · 什么是STL

STL(standard template libaray-标准模板库 ) ： 是 C++ 标准库的重要组成部分 ，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。提供了一系列 通用的模板类和函数 ，用于实现常见的数据结构和算法。它基于模板编程，支持泛型设计，允许开发者以高效、可复用的方式处理数据。

---

1 - 2 · STL的六大核心组件

1. **容器（Containers）**用于存储和管理数据的类模板，分为序列容器和关联容器。

2. **算法（Algorithms）**提供对容器中数据的操作，如排序、查找、遍历等。

3. **迭代器（Iterators）**类似指针的对象，用于遍历容器中的元素，是容器与算法之间的桥梁。类型包括：输入迭代器、输出迭代器、前向迭代器、双向迭代器、随机访问迭代器等。

4. 仿函数（Functor） 重载了operator()的类对象，可像函数一样调用，常用于自定义算法行为。

5. 适配器（Adapters） 基于现有容器或迭代器提供特殊接口，如stack（栈）、queue（队列）、priority_queue（优先队列）。

6. **空间适配器（Allocator）**是C++标准库中用于管理内存分配的模板类，允许用户自定义内存分配策略。

---

2 · auto和范围for

介绍两个C++11的小语法，方便更好了解

2 - 1 · auto关键字

1. 在早期 C/C++ 中 auto 的含义是：使用 auto 修饰的变量，是具有自动存储器的局部变量，后来这个 不重要了。 C++11 中，标准委员会变废为宝赋予了 auto 全新的含义即： auto 不再是一个存储类型 指示符，而是作为一个新的类型指示符来指示编译器， auto 声明的变量必须由编译器在编译时期 推导而得 。
2. 用 auto 声明指针类型时，用 auto 和 auto* 没有任何区别，但用 auto 声明引用类型时则必须加 &
3. 当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际 只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
4. auto 不能作为函数的参数，可以做返回值，但是建议谨慎使用
5. auto 不能直接用来声明数组

---

2 - 2 · 范围for

1. 对于一个 有范围的集合 而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的 for 循环。 for 循环后的括号由冒号 " ： " 分为两部分：第一部分是范围 内用于迭代的变量，第二部分则表示被迭代的范围 ，自动迭代，自动取数据，自动判断结束。
2. 范围for可以作用到数组和容器对象上进行遍历
3. 范围for的底层很简单，容器遍历实际就是替换为迭代器

int array[] = { 1, 2, 3, 4, 5 };

// C++98的遍历
for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
{
    array[i] *= 2;
}

for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
{
    cout << array[i] << endl;
}

// C++11的遍历
for (auto& e : array)
    e *= 2;

for (auto e : array)
    cout << e << " " << endl;

---

3 · string类的基本概念

在C++中，string类是标准库提供的用于处理字符串的类，属于std 命名空间。它封装了字符序列的操作，提供了丰富的成员函数，支持动态内存管理，比C风格的字符数组（char[]）更安全、更高效。

---

4 · string的常用接口

4 - 1 · 构造

|------------------------------|----------------------------------------------|
| 函数 | 功能 |
| string() | 构造空的 string 类对象，即空字符串 |
| string(const char* s) | 用 C格式的字符串 来构造 string 类对象 |
| string(size_t n, char c) | string 类对象中包含 n 个字符 c |
| string(const string&s) | 拷贝构造函数 |

void Teststring()
{
    string s1; // 构造空的string类对象s1
    string s2("hello world"); // 用C格式字符串构造string类对象s2
    string s3(s2); // 拷贝构造s3
}

---

4 - 2 · 容量操作

|----------|--------------------------|
| 函数 | 功能 |
| size | 返回字符串有效字符长度 |
| length | 返回字符串有效字符长度 |
| capacity | 返回空间总大小 |
| empty | 判空，空串返回true，非空返回false |
| clear | 清空字符串中字符 |
| reserve | 预留空间 |
| resize | 将有效字符的个数该成n个，多出的空间用字符c填充 |

注意：

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

---

4 - 3 · 访问与遍历

|---------------|------------------------------------------|
| 函数 | 功能 |
| operator | 返回pos位置的字符，如果是const修饰的对象调用，那么只允许访问 |
| begin + end | begin获取第一个字符的迭代器，end获取最后一个字符的下一个位置的迭代器 |
| rbegin + rend | rbegin获取最后一个字符的迭代器，rend获取第一个字符的前一个位置的迭代器 |
| 范围for | C++11支持 |

---

4 - 4 · 查找与修改

|------------|--------------------------------------------------------------|
| 函数 | 功能 |
| push_back | 在字符串后尾插一个字符 |
| append | 在字符串后追加一个字符串 |
| operator+= | 在字符串后追加一个字符串str |
| c_str | 返回C格式字符串 |
| find | 从字符串pos位置(默认是0)开始往后找字符c或字符串str，返回第一次在查找中出现的位置，如果没找到，则返回 npos |
| rfind | 从字符串pos位置(默认是尾)开始往前找字符c或字符串str，返回第一次在查找中出现的位置，如果没找到，则返回 npos |
| substr | 从字符串pos位置开始，截取n个字符，然后将其返回 |

注意：

1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差
   不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可
   以连接字符串。
2. 对string操作时，如果能够大概预估到需要放多少字符，可以先通过reserve把空间预留好。
3. npos是string类的一个静态成员变量，为整型的最大值，使用时需要指定类域。

---

4 - 5 · 非成员函数

|----------------------|---------------------------------------------------|
| 函数 | 功能 |
| operator+ | 不作为成员函数可能是因为想要支持字符串 + string，尽量少用，因为传值返回，导致深拷贝效率低 |
| operator>> | 运算符重载，输入 |
| operator<< | 运算符重载，输出 |
| getline | 获取字符串，默认是遇到换行终止，也可以自己定终止符，终止符为第三个参数 |
| relational operators | 大小比较 |

---

5 · VS下string的结构

在32位平台下，指针占4个字节

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

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

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

---

6 · 浅拷贝 / 深拷贝

6 - 1 · 模拟实现string类常见的问题

class string
{
public:
    string(const char* str = "")
    {
	    _size = strlen(str);
	    _capacity = _size;//capacity不包含\0
	    _str = new char[_capacity + 1];
    	strcpy(_str, str);
    }

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

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

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

上面这段代码没有显示实现拷贝构造，那么此时测试中用的是默认的拷贝构造，也就是一个字节一个字节拷贝，此时_size与_capacity是没有问题的，问题出在_str，如下图：

最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。

具体说说就是当TestString函数结束，需要销毁s1和s2，先对s2进行销毁，此时s1与s2共用的_str指向的空间被释放，s2销毁成功，s1中的_str变为野指针，随后销毁s1，此时就崩溃了。

---

6 - 2 · 浅拷贝

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

可以采用深拷贝解决浅拷贝问题，即：每个对象都有一份独立的资源，不要和其他对象共享。

---

6 - 3 · 深拷贝

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

深拷贝，给每个对象独立分配资源，保证多个对象不会因为共享资源而导致多次释放而导致程序崩溃。

---

6 - 4 · 写时拷贝

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

---

7 · 拷贝实现的现代写法与传统写法

7 - 1 · 传统写法

//传统写法
string(const string& str)
{
	_size = str._size;
	_capacity = str._capacity;
	_str = new char[_capacity + 1];
	strcpy(_str, str._str);
}

//传统写法
string& operator=(const string& str)
{
	//防止自己给自己赋值的情况
	if (this != &str)
	{
		delete[] _str;

		_size = str._size;
		_capacity = str._capacity;
		_str = new char[_capacity + 1];
		strcpy(_str, str._str);
	}

	return *this;
}

传统写法就是自己手动进行深拷贝操作，开空间，复制值。

---

7 - 2 · 现代写法

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

//现代写法
string(const string& s)
{
	string tmp(s._str);
	swap(tmp);
}

//现代写法
string& operator=(string tmp)
{
	swap(tmp);
	
	return *this;
}

现代写法相当于把我们需要做的工作交给编译器，让编译器帮我们生成一个对象，然后我们只需要窃取劳动成果，将对象中的成员变量全部交换过来。

在运算符重载= 中更能体现出现代写法的价值，因为赋值需要将原空间进行释放，而tmp作为临时变量，出了作用域就要销毁，所以在交换过后，tmp会自动帮助将原空间进行释放。同时此时无需考虑自己给自己赋值的情况，在传统写法中，由于需要先释放原空间，所以需要考虑自己给自己赋值的情况，否则是找不到字符串的。

---

8 · string类的模拟实现

下面模拟实现几个string类的常用功能

8 - 1 · string.h

#pragma once

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

namespace naobeng
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;


		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		const_iterator begin() const
		{
			return _str;
		}

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

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

		string(const char* str = "")
		{
			_size = strlen(str);
			_capacity = _size;//capacity不包含\0
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		//传统写法
		//string(const string& str)
		//{
		//	_size = str._size;
		//	_capacity = str._capacity;
		//	_str = new char[_capacity + 1];
		//	strcpy(_str, str._str);
		//}

		//现代写法
		string(const string& s)
		{
			string tmp(s._str);
			swap(tmp);
		}

		//传统写法
		//string& operator=(const string& str)
		//{
		//	//防止自己给自己赋值的情况
		//	if (this != &str)
		//	{
		//		delete[] _str;

		//		_size = str._size;
		//		_capacity = str._capacity;
		//		_str = new char[_capacity + 1];
		//		strcpy(_str, str._str);
		//	}

		//	return *this;
		//}

		//现代写法
		string& operator=(string tmp)
		{
			swap(tmp);
			
			return *this;
		}

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

		size_t size() const
		{
			return _size;
		}

		size_t capacity() const
		{
			return _capacity;
		}

		bool empty() const
		{
			return _size == 0;
		}

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

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

			//return *(_str + pos);
			return _str[pos];
		}

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

			return _str[pos];
		}

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

		void reserve(size_t n);
		void push_back(char c);
		void append(const char* str);
		string& operator+=(char c);
		string& operator+=(const char* str);

		void insert(size_t pos, char c);
		void insert(size_t pos, const char* str);
		void erase(size_t pos, size_t len = npos);

		size_t find(char c, size_t pos = 0);
		size_t find(const char* str, size_t pos = 0);
		string substr(size_t pos, size_t len = npos);

	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;

		static const size_t npos;
	};

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

	ostream& operator<<(ostream& out, const string& str);
	istream& operator>>(istream& in, string& str);

}

一些频繁调用的功能可以不用做声明定义分离，让它成为内联

---

8 - 2 · string.cpp

#include "string.h"

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

	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 c)
	{
		if (_size == _capacity)
		{
			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newcapacity);
		}

		_str[_size] = c;
		_size++;
		_str[_size] = '\0';
	}

	void string::append(const char* str)
	{
		size_t newLength = _size + strlen(str);
		if (newLength > _capacity)
		{
			reserve(newLength > 2 * _capacity ? newLength : 2 * _capacity);
		}

		//strcat(_str, str);
		//_size = newLength;
		//_str[_size] = '\0';

		strcpy(_str + _size, str);
		_size = newLength;
	}

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

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

	void string::insert(size_t pos, char c)
	{
		assert(pos <= _size);

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

		//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] = c;
		++_size;
	}

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

		size_t len = strlen(str);
		if (len == 0)
			return;

		size_t newLength = _size + len;
		if (newLength > _capacity)
		{
			reserve(newLength > 2 * _capacity ? newLength : 2 * _capacity);
		}

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

		for (size_t i = 0; i < len; i++)
		{
			_str[pos + i] = str[i];
		}
		_size = newLength;
	}

	void string::erase(size_t pos, size_t len)
	{
		assert(pos < _size);

		if (len >= _size - pos)
		{
			_str[pos] = '\0';
			_size = pos;
		}
		else
		{
			for (size_t i = pos + len; i <= _size; i++)
			{
				_str[i - len] = _str[i];
			}
			_size -= len;
		}
	}

	size_t string::find(char c, size_t pos)
	{
		assert(pos < _size);

		for (size_t i = pos; i < _size; i++)
		{
			if (_str[i] == c)
			{
				return i;
			}
		}

		return npos;
	}

	size_t string::find(const char* str, size_t pos)
	{
		assert(pos < _size);

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

	string string::substr(size_t pos, size_t len)
	{
		assert(pos < _size);

		if (len > _size - pos)
		{
			len = _size - pos;
		}

		string str;
		str.reserve(len);
		for (size_t i = 0; i < len; i++)
		{
			str += _str[pos + i];
		}

		return str;
	}

	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 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) || (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& str)
	{
		for (auto c : str)
		{
			out << c;
		}
		return out;
	}

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

		//优化，用数组做缓冲
		const int N = 128;
		char buff[N];
		int i = 0;

		char c;
		c = in.get();
		while (c != ' ' && c != '\n')
		{
			buff[i++] = c;
			if (i > N - 1)
			{
				buff[i] = '\0';
				str += buff;
				i = 0;
			}

			c = in.get();
		}

		if (i > 0)
		{
			buff[i] = '\0';
			str += buff;
		}

		return in;
	}

}

---

以上内容如有错误或不准确之处，欢迎指出，或者你有更好的想法，也欢迎交流。