seo查询 站长工具,做跨境电商看国外的哪些网站,关键词有哪些关联词,深圳公司排名榜文章目录 成员变量和查看接口迭代器#xff08;读和读写#xff09;operator[]#xff08;读和读写#xff09;c_str()size() 构造函数用字符串构造用对象构造#xff08;两种方法#xff09;析构 赋值运算符重载扩容和调整reserve()resize()clear() 增删查改push_back()… 文章目录 成员变量和查看接口迭代器读和读写operator[]读和读写c_str()size() 构造函数用字符串构造用对象构造两种方法析构 赋值运算符重载扩容和调整reserve()resize()clear() 增删查改push_back()append()operator()insert()字符和字符串erase()find() 字符和字符串substr() string大小比较operator()operator()复用 IO流operator()operator() 成员变量和查看接口 string类中有三个成员变量分别记录有效元素个数、容量和字符串。而静态变量npos1表示整型的最大值且只能在类外部进行赋值
成员变量
private:size_t _size; //个数size_t _capacity; //容量char* _str; //字符数组
public:const static size_t npos; //表示整形最大值迭代器读和读写
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;
}operator[]读和读写 const成员函数前面的返回值也必须加上constthis-_str 不能被修改而指针是内置类型指针不能被修改但是指针指向区域内容却可以被修改因此返回值前面加上 const
char operator[](size_t pos)
{assert(pos _size);return _str[pos];
}
const char operator[](size_t pos)const
{assert(pos _size);return _str[pos];
}c_str()
const char* c_str() const
{return _str;
}size()
size_t size() const
{return _size;
}构造函数
用字符串构造 注意无参时我们给缺省值给空串里面不能带 空格空格也是有效字符。new 开空间的时候要开字符串长度 1个strlen() 函数只会记录有效字符个数我们需要多卡一个空间给 \0 字符
string(const char* str )
{_size strlen(str);_capacity _size;_str new char[_capacity 1];memcpy(_str, str, _size 1);
} 用对象构造两种方法 方法 1 用 memcpy 库函数而不是 strcpy 对于 “abc \0 def” 这种字符串strcpy没办法处理遇到 \0 就终止了而 memcpy 是按内存中字节拷贝的 方法 2 的话调用了 swap() 库函数且复用了用字符串构造函数这里还需注意必须初始化 _str 它是指针类型的编译器不会自动初始化那么和 tmp 交换后析构 tmp 就会析构一段非法空间而报错
//方法 1
string(const string s)
{_str new char[s._capacity 1];memcpy(_str, s._str, s._size 1);_size s._size;_capacity s._capacity;
}
//方法 2
string(const string s):_size(0),_capacity(0),_str(nullptr)
{string tmp(s._str);swap(tmp);
}析构
~string()
{delete[] _str;_str nullptr;_size _capacity 0;
}
赋值运算符重载 方法一比较原始实现方法和 reserve() 函数一样先开一样大小的空间然后拷贝数据再销毁原来空间更新 _str_capacity_size 方法二调用库里面的 swap() 函数便能轻松解决那么思考为什么我们不直接交换 swap(*this, tmp) 先看库里面 swap() 函数实现不难发现里面的对象交换需要相互赋值而赋值又要调用 operator()而 operator() 里面又会调用 swap() 依次进行就变成了死递归
//方法一
string operator(const string s)
{if (this ! s){char* tmp new char[s._capacity 1];memcpy(tmp, s._str, s._size1);delete[] _str;_str tmp;_size s._size;_capacity s._capacity;}return *this;
}
//方法二
string operator(string tmp)
{//std::swap(*this,tmp);//这样写死递归std::swap(_str, tmp._str);std::swap(_size, tmp._size);std::swap(_capacity, tmp._capacity);return *this;
}扩容和调整 扩容我们采取异地扩容的方式考虑到 reserve() 函数外部也可以用因此加个判断异地扩容后记得把原来空间释放掉
reserve()
void reserve(size_t n)
{ //异地扩容if (n _capacity){char* tmp new char[n 1];memcpy(tmp, _str, _size 1);delete[] _str;_str tmp;_capacity n;}
}resize() 空间变小的话我们还是不改变 _capacity把 _size 改了再赋上 \0 就行空间大了的话我们就异地扩容再给要改变的 ch 加上缺省值 \0
void resize(size_t n, char ch \0)
{if (n _size) {_size n;_str[_size] \0;}else {reserve(n);for (size_t i _size; i n; i){_str[i] ch;}_size n;_str[_size] \0;}
}
clear()
void clear()
{_size 0;_str[_size] \0;
}增删查改
push_back() void push_back(const char ch){//扩容×2if (_size _capacity){//有可能用空串初始化的reserve(_capacity 0 ? 4 : _capacity * 2);}_str[_size] ch;_size;_str[_size] \0;}append() void append(const char* str){size_t len strlen(str);if (_size len _capacity){reserve(_size len);}//strcpy(_str _size, str);memcpy(_str _size, str, len 1);_size len;}operator() 直接复用前面两个函数 push_back() 和 append() 调用这两个函数再考虑空间够不够不够就扩容再尾插 string operator(const char ch){push_back(ch);return *this;}string operator(const char* str){append(str);return *this;}insert()字符和字符串 首先检查一下插入位置的合法性然后这意一下end 是无符号类型考虑 pos为0 时会造成死循环end减为 -1 却是整形最大值因此我们前面设置的静态变量 npos 便发挥了作用。最后注意边界问题是否需要扩容 void insert(size_t pos, size_t n, char ch){assert(pos _size);if (_size n _capacity){reserve(_size n);}size_t end _size;_size n;//end是无符号类型考虑pos为0时 的死循环while (end pos end ! npos){_str[end n] _str[end];end--;}for (size_t i 0; i n; i){_str[pos i] ch;}}void insert(size_t pos, const char* str){assert(pos _size);size_t len strlen(str);if (len _size _capacity){reserve(len _size);}size_t end _size;_size len;while (end pos end ! npos){_str[end len] _str[end];end--;}for (size_t i 0; i len; i){_str[pos i] str[i];}}erase() 删除字符的个数我们给缺省值方便边界判断。考虑 pos 的合法性后再处理边界问题删除工作就是不断从后往前迭代
void erase(size_t pos, size_t len npos)
{assert(pos _size);if (len npos || pos len _size){_str[pos] \0;_size pos;}else {size_t end pos len;while (end _size){_str[end-len] _str[end];end;}_size - len;}
}find() 字符和字符串 没有找到找到就返回 npos 缺省值从 0 开始找找字符串有很多中算法KMPBF … 这里我们直接调用 strstr() 库函数简单实现就行
size_t find(char ch, size_t pos 0)
{assert(pos _size);for (size_t i pos; i _size; i){if (_str[i] ch){return i;}}return npos;
}
size_t find(const char* str, size_t pos 0)
{assert(pos _size);const char* ptr strstr(_str pos, str);if (ptr){return ptr - _str;}else {return npos;}
}substr() 检查 pos 合法性后我需要计算切割字符串的长度。注意我们返回的是一个临时的 string 类开好空间然后调用 operator 函数它会自动处理后面的 \0
string substr(size_t pos0, size_t len npos)
{assert(pos _size);size_t n len;if (len npos || pos len _size){n _size - pos;}string tmp;tmp.reserve(n);for (size_t i pos; i pos n; i){tmp _str[i];}return tmp;
}string大小比较
operator() 由于字符串比较情况种类较多比如 “abc” “abcd” 这种情况 库函数 strcmpmemcmp 便不再适用 它们适用于相同长度的字符串比较长度不同容易出现越界问题这里我们直接自己实现
bool operator(const string s) const
{size_t lt1 0;size_t lt2 0;while (lt1 _size lt2 s._size){if (_str[lt1] s._str[lt2]) {return true;}else if (_str[lt1] s._str[lt2]) {return false;}else {lt1;lt2;}}return _size s._size;
}operator()
bool operator(const string s) const
{return _size s._size memcmp(_str, s._str, _size) 0;
}
复用
bool operator(const string s) const
{return *this s || *this s;
}
bool operator(const string s) const
{return !(*this s);
}
bool operator(const string s) const
{return *this s || *this s;
}
bool operator!(const string s) const
{return !(*this s);
}IO流
operator()
ostream operator(ostream out, const string s)
{for (auto ch : s){out ch;}return out;
}operator() 插入前要处理缓冲区前面的空格和换行用循环解决掉空格和换行字符。进行流插入的时候我们设置一个中将数组让插入数据先放在buff数组中避免调用多次 operator 函数而引起多次扩容判断最后再处理后面的 \0
istream operator(istream in, string s)
{s.clear();char ch in.get();//除去缓冲区的空格和换行while (ch || ch \n){ch in.get();}//用一个中将容器减少扩容次数char buff[128];size_t i 0;while (ch ! ch ! \n){buff[i] ch;if (i 127){//加上\0以免出问题buff[i] \0;s buff;i 0;}ch in.get();}if (i ! 0){buff[i] \0;s buff;}return in;
}
