C++篇 String实现避坑指南：搞定构造，拷贝与析构，增删查改，流提取流插入与比对大小 一文全解 - 教程

胖咕噜的稞达鸭：个人主页

个人专栏: 《数据结构》《C++初阶高阶》

⛺️技术的杠杆，撬动整个世界!

文章开始之前，string官方文档供大家参考。string官方文档

注意！！！本文注释是重点！！！

string的常用接口说明

1. string类对象的常见构造

函数名称	用途
string()	构造空的string类对象，即空字符串
string(const char s)	用C-string来构造string类对象
string(size_t n, char c)	string类对象中包含n个字符c
string(const string&s)	拷贝构造函数

---

2. string类对象的容量操作

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

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

函数名称	用途
operator[]	返回pos位置的字符，const string类对象调用
begin+ end	**begin获取一个字符的迭代器 + end获取最后一个字符下一个位
置的迭代器**
rbegin + rend	**begin获取一个字符的迭代器 + end获取最后一个字符下一个位
置的迭代器**

4. string类对象的修改操作

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

5. string类非成员函数

函数名称	用途
operator+	尽量少用，因为传值返回，导致深拷贝效率低
operator>>	输入运算符重载
operator<<	输出运算符重载
getline	获取一行字符串

现在我们就从初始化，拷贝构造，string的增删查改等多个方面进行讲述。
在string.h和string.cpp中进行声明和定义分离。

初始化和拷贝构造，析构以及频繁调用的函数实现

//string.h注意看注释

#pragma once
#include<iostream>#include<assert.h>using namespace std;namespace Byte{class string{public://string()//	:_str(new char[1] {'\0'})//_str初始化申请一个字符的空间，里面放/0，避免解引用报错，这里不是在库string里//	,_size(0)//	,_capacity(0)//{ }//string(const char* str)//{//	_size = strlen(str);//	_capacity = _size;//初始化,capacity不包含\0//	_str = new char[_capacity + 1];//在开空间的时候多开一个//	strcpy(_str, str);//然后把这块空间拷贝过来//}//这样写没有考虑到\0//短小频繁调用的函数可以直接定义到类里面，默认是inlinestring(const char* str="")//注意这里需要"",常量字符串后面都有一个\0，这里什么都没有也会加一个\0，所以传“ ”{_size = strlen(str);//计算str的长度并将其赋值给_size_capacity = _size;//初始化,capacity不包含\0_str = new char[_capacity + 1];//在开空间的时候多开一个strcpy(_str, str);//然后把这块空间拷贝过来。_str为目标地}//s2要拷贝s1,首先让s2指向空，给了缺省值，在初始化列表的时候//给随机值，也有可能是空，成员变量_str初始化指向nullptr，//显示提供拷贝构造//假如用s1拷贝s2  s2(s1)//这里的s就是s1string(const string& s){_str = new char[s._capacity + 1];//还是多开一个空间用来存放\0strcpy(_str, s._str);//拷贝进去_size = s._size;_capacity = s._capacity;}void swap(string& s){//这个是要调用算法库中的swap，局部域在交换swap的时候要先找swap,否则会认为参数不匹配std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}//s2要跟s1有一样大的空间，让tmp去初始化string(const string& s){string tmp(s._str);//拷贝构造swap( tmp);}//s1假设有一串字符，用s._str去构造tmp,s就是s1，用s1._str去构造tmp，// s1假设有一串字符，tmp中也有一串字符，而tmp中构造出的对象就是s2中想要的//这里就要进行交换，调用swap,交换里面的指针，size,capacity,成员前//前面没有写的，默认都是this，this在调用这个swap，this就是s2，//swap(this(s2),tmp),这里 就很好的完成了深拷贝//出了作用域，tmp会不会被销毁，会的；但是tmp销毁的是空指针，因为s2和tmp进行了交换//这里也就更好说明了为什么要初始化为nullptr.简单说也就是让tmp去干活，然后通过交换的方式去拿取//s1赋值给s2,string的深拷贝string& operator=(const string& s){//为了防止自己给自己赋值 if (this != &s){//s就是s1，this就是s2。this之前是有空间的，所以把_str释放掉delete[]_str;_str = new char[s._capacity + 1];//空间要多开一个，让s2指向一块新的空间strcpy(_str, s._str);//拷贝它的值，把s1拷贝给s2_size = s._size;_capacity = s._capacity;}return *this;}//新的写法/////////////////////////////////////string& operator=(const string& s){if (this != &s){string tmp(s._str);swap(tmp);}return *this;}string& operator=(string tmp){swap(tmp);return *this;}//////////////////////////////////////////////////写析构~string(){delete[]_str;//释放掉_str_str = nullptr;//将其置为空nullptr_size = _capacity = 0;//空间和大小赋值为0}const char* c_str()const//用于遍历{return _str;}size_t size()const{return _size;}size_t capacity()const{return _capacity;}//operator[]返回pos位置的引用方便读和写char& operator[](size_t pos){assert(pos < _size);return _str[pos];}const char& operator[](size_t pos)const{assert(pos < _size);return _str[pos];}private:char* _str=nullptr;size_t _capacity;size_t _size;};//static void test_string1()//如果文件中有很多个test_string1，静态全局只在当前文件中进行//{//	string s1;//	string s2("hello world");//}void test_string1();}

//string.cpp中

#define _CRT_SECURE_NO_WARNINGS 1
#include"string.h"
namespace  Byte
{
void test_string1()
{
string s1;
string s2("hello world");
cout << s1.c_str() << endl;
cout << s2.c_str() << endl;
//进行遍历
for (size_t i = 0; i < s2.size(); i++)
{
s2[i] += 2;
}
cout << s2.c_str() << endl;
}

// test.cpp中

//模拟实现
#include<string.h>#include "string.h"int main(){Byte::test_string1();return 0;}

单独实现一个范围for的遍历

用到迭代器：屏蔽了底层的实现细节，提供了统一的类似访问容器的方式，不需要关系容器底层的实现细节

所以这里需要迭代器进行函数的封装
//string.h

typedef char* iterator;//定义了一个iterator，属于string类域
typedef const char* const_iterator;//const指针迭代器
iterator begin()//实现第一个位置
{
return _str;
}
iterator end()//实现最后一个位置
{
return _str+_size;
}
const_iterator begin()const//实现第一个位置
{
return _str;
}
const_iterator end()const//实现最后一个位置
{
return _str+_size;
}

string.cpp

for (auto e : s2)//范围for底层就是替换成迭代器
{
cout << e << " ";
}
cout << endl;
string::iterator it = s2.begin();//有一个类型itertor在类域里面
while (it != s2.end())
{
cout << *it << " ";//需要访问数据就解引用
++it;//到下一个位置++
}
cout << endl;
//迭代器是一种封装的体现，首先把数据和方法都放到类里面，可以让别人访问的放在共有
//iterator封装不管什么容器什么数据结构，都让它的第一个位置指向begin，最后一个位置的下一个位置指向end
//要访问数据就解引用，到下一个位置就++
//屏蔽了底层的实现细节，提供了统一的类似访问容器的方式，不需要关系容器底层的实现细节

string的增删查改实现：

//string.h中

void reserve(size_t n);//用于申请空间,预先申请容量为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);//在pos位置之前插入一个字符
void insert(size_t pos, const char* str);//在pos位置之前插入一个字符串
void erase(size_t pos, size_t len = npos);//从pos位置开始,删除len个字符；若len默认值npos，则删除从pos到字符串末尾的所有字符

声明和定义分离，较长而且不会频繁调用的放在string.cpp中
//string.cpp

void string::reserve(size_t n)
{
if (n > _capacity)
{
//实现手动扩容
char* tmp = new char[_capacity + 1];
strcpy(_str, tmp);
delete[]_str;//_str空间内本有数据，释放掉
_str = tmp;//让_str指向tmp这块空间
_capacity = n;
}
}
void string::push_back(char ch)
{
if (_capacity == _size)//如果空间刚好满了
{
reserve(_capacity == 0 ? 4 : 2 * _capacity);//如果空间为空，就赋值给4个字节，扩容为4，空间不为空开始2倍扩容
}
_str[_size] = ch;
_size++;
_str[_size] = '\0';//在插入字符并且更新长度后，添加字符串结束符\0
}
void string::append(const char* str)//插入一个字符串
{
size_t len = strlen(str);
if (_size+len>_capacity)//如果字符串原本的长度加上要新加入的，总长度大于容量就需要扩容
{
reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
//大于2倍的capacity就按照需要的长度开，不大于按照2倍扩容，还是避免频繁扩容
}
strcpy(_str + _size, _str);//_str+_size就是\0的位置
_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)//在pos位置之前插入一个字符
{
assert(pos <= _size);//pos必须是_size内部的位置
//考虑空间不够的情况
if (_capacity == _size)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);//为0赋值4，不为0按照2倍扩容
}
size_t end = _size+1;//往后挪一个位置
while(end>pos)
{
_str[end] = _str[end - 1];
--end;
}
_str[pos] = ch;//将pos的位置赋值ch
++_size;
}
void string::insert(size_t pos, const char* str)//在pos位置之前插入一个字符串
{
size_t len = strlen(str);
assert(pos < _size);
if (_size + len > _capacity)
{
reserve(_size + len > 2 * _capacity ? _size + len : _capacity * 2);
}
size_t end = _size + len;//end更新到_size+len的位置
while (end >= pos + len)
{
_str[end] = _str[end - len];
end --;
}
for(size_t i=0;i<len;i++)
{
_str[pos + i] = _str[i];
}
_size += len;
}
void string::erase(size_t pos, size_t len )//从pos位置开始,删除len个字符；若len默认值npos，则删除从pos到字符串末尾的所有字符
{
assert(pos < _size);
if (len > _size - pos)//_size=11,len=100
{
_str[pos] = '\0';//在pos的位置插入\0表示字符串终止
_size = pos;
}
else
{
//_size=11,pos=3,len=2
for (size_t i = pos + len; i <= _size; i++)
{
_str[i - len] = _str[i];
}
_size -= len;
}
}

查找+字符比对

//string.cpp

size_t string::find( char ch, size_t pos )//从pos开始遍历，找到pos位置的数返回其下标,没找到返回npos
{
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 )//pos从0开始
{
//暴力匹配；字符串匹配的BM算法；KMP
assert(pos < _size);
const char* ptr = strstr(_str + pos, str);//返回对应位置的指针，前者是原串，后者是子串
if (ptr == nullptr)
{
return npos;//如果没有匹配上返回npos
}
else
{
return ptr - _str;//假设匹配上了，两个指针相减就是它的下标
}
}
string string:: substr(size_t pos , size_t len)//从pos位置开始取len个字符,然后构造一个字串
{
assert(pos < _size);
//如果len大于剩余字符的长度，更新一下len//11个字符要从\0后面取100个字符
if (len > _size - pos)
{
len = _size - pos;
}
string sub;//返回子串
sub.reserve(len);
for (size_t i = 0; i < len; i++)
{
sub += _str[pos + i];//从pos位置开始的len个字符加等到sub中
}
return sub;//sub是一个局部对象，传值拷贝这里要调用拷贝构造，但是编译器有可能会优化
//首先用sub拷贝一个临时对象，临时对象作为返回值，再去拷贝suffix对象，但是编译器优化
//会将中间的临时对象优化掉，这里没有写拷贝构造，默认是浅拷贝
//出了作用域，sub会自动销毁，销毁之后会将这临时对象也带走，所以suffix指向的就是一个野指针！！！
}
bool operator>(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) > 0;//strcmp小于0大于0等于0会返回
}
bool operator<=(const string& s1, const string& s2)
{
return !(s1 > s2);
}
bool operator>=(const string& s1, const string& s2)
{
return s1 > s2 || s1 == s2;
}
bool operator==(const string& s1, const string& s2)
{
return  strcmp(s1.c_str(), s2.c_str()) == 0;//strcmp小于0大于0等于0会返回
}
bool operator!=(const string& s1, const string& s2)
{
return !(s1 == s2);
}
//流插入流提取
ostream& operator<<(ostream& out, const string& s)//可以支持内置类型
{
for (auto ch : s)
{
out << ch;//把每一块字符都取出来插入，遍历string
}
return out;
}
istream& operator>>(istream& in, string& s)//不需要访问私有，就没必要写成友元函数，但是必须是全局
{
s.clear();
s.reserve(1024);//插入的时候先扩容1024，防止插入字符的时候频繁扩容
const int N = 254;
char buff[N];
int i = 0;
char ch;
//这样写不对in >> ch;流提取默认提取不到空格和换行的
ch = in.get();//流提取只能gEt一个字符，
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;//输入253个字符在buff里面
if (i == N-1)
{
buff[i] = '\0';//最后一个方\0
s += buff;
i = 0;
}
//in >> ch;//加等之后获取另外一个字符
ch = in.get();
}
if (i > 0)//里面还没有走完，但是遇到空格了
{
buff[i] = '\0';
s += buff;
}
return in;//应该用空格符
}

//string.h

size_t find(char ch, size_t pos = 0);
size_t find(const char* str, size_t pos = 0);
string substr(size_t pos = 0, size_t len = npos);//从pos位置开始取len个字符,然后构造一个字串
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& s);
istream& operator>>( istream& in, string& s);

//test.cpp

void test_string4()
{
string s("test.cpp.zip");
size_t pos = s.find('.');
string suffix = s.substr(pos);
cout << suffix.c_str() << endl;
//sub suffix每个字节都拷贝，同时指向一块空间，这里前面return sub的时候把这块空间就带走了
//此时suffix的时候指向野指针，编译器把三个都优化了，中间都没有拷贝构造，所以这里一定要
//进行深拷贝，所以一定要显示提供拷贝构造
string copy(s);//这里还是浅拷贝
cout << copy.c_str() << endl;
s = suffix;//赋值
cout << suffix.c_str() << endl;
cout << s.c_str() << endl;
}

string模拟实现完整源码