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=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模拟实现完整源码