C++篇 String实现避坑指南：搞定构造，拷贝与析构，增删查改，流提取流插入与比对大小 一文全解
🎬 胖咕噜的稞达鸭：个人主页
文章开始之前，string官方文档供大家参考。string官方文档
注意！！！本文注释是重点！！！
string的常用接口说明
- string类对象的常见构造
| 函数名称 | 用途 |
|---|---|
| string() | 构造空的string类对象，即空字符串 |
| string(const char s) | 用C-string来构造string类对象 |
| string(size_t n, char c) | string类对象中包含n个字符c |
| string(const string&s) | 拷贝构造函数 |
- string类对象的容量操作
| 函数名称 | 用途 |
|---|---|
| size | 返回字符串有效字符长度 |
| length | 返回字符串有效字符长度 |
| capacity | 返回空间总大小 |
| empty | 检测字符串释放为空串，是返回true，否则返回false |
| clear | 清空有效字符 |
| reserve | 为字符串预留空间** |
| resize | 将有效字符的个数该成n个，多出的空间用字符c填充 |
- string类对象的访问及遍历操作
| 函数名称 | 用途 |
|---|---|
| operator[] | 返回pos位置的字符，const string类对象调用 |
| begin+ end | **begin获取一个字符的迭代器 + end获取最后一个字符下一个位 |
| 置的迭代器** | |
| rbegin + rend | **begin获取一个字符的迭代器 + end获取最后一个字符下一个位 |
| 置的迭代器** |
- string类对象的修改操作
| 函数名称 | 用途 |
|---|---|
| push_back | 在字符串后尾插字符c |
| append | 在字符串后追加一个字符串 |
| operator+= | 在字符串后追加字符串str |
| c_str | 返回C格式字符串 |
| find+npos | **从字符串pos位置开始往后找字符c，返回该字符在字符串中的 |
| 位置** | |
| rfind | **从字符串pos位置开始往前找字符c，返回该字符在字符串中的 |
| 位置** | |
| substr | 在str中从pos位置开始，截取n个字符，然后将其返回 |
- 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=2for (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算法；KMPassert(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';//最后一个方\0s += 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模拟实现完整源码