前言
string不属于stl，string比stl出现的早的多，所以string属于标准库，不属于stl
大家可以在cplusplus网站看string的内容
string的六个构造函数
构造函数
在写构造函数的时候不管传的字符串里面有没有字符，都必须至少要new char[1]，跟后面配对上，否则你在构造函数里面new char，而析构函数必须用delete[ ]就会报错，初始化列表不能互相初始化，比如说_capacity(_size)，因为初始化列表初始化的顺序不是看初始化写的顺序，而是成员变量的顺序。
string(const char* str = "")
:_str(nullptr)
,_size(strlen(str))
,_capacity(strlen(str)+1)
{
_str = new char[_capacity];
memcpy(_str, str, _size);
_str[_size] = '\0';
}
析构函数
~string()
{
delete[] _str;
_size = _capacity = 0;//可有可无
}
拷贝构造
记得拷贝构造传参必须传引用，不能传值，不然会造成无限传参递归，最后把程序搞崩
string(const string& str)
{
_str = new char[str.capacity()];
memcpy(_str, str._str, str.size());
_size = str.size();
_capacity = str.capacity();
_str[_size] = '\0';
}
赋值重载
返回值和传参最好都用传引用，减少拷贝要用的资源消耗
string& operator=(const string& str)
{
delete[] _str;
_str = new char[str.capacity()];
memcpy(_str, str._str, str._size);
_size = str._size;
_capacity = str._capacity;
_str[_size] = '\0';
return *this;
}
取地址运算符重载
由于这两个一般不自己实现，所以就放在一起写了
string* operator&()
{
return this;
}
const string* operator&()
{
return this;
}
迭代器
string的迭代器是可以用原生指针的，可以把string的迭代器iterator理解为char*，const_iterator理解为const char*,const迭代器是可以变化的，但迭代器指向的类的内容是不能变化的
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
const_iterator begin() const
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator end() const
{
return _str + _size;
}
流插入流提取
流插入的时候不要用scanf或者cin，因为scanf和cin都接收不到’\n’和空格，我们可以用重载的cin.get()函数，如果你需要一个有空格的字符串，你可以用string库函数getline()函数，getline函数只有遇到换行时才会终止。
friend ostream& operator<<(ostream& out, const string& st)
{
out << st._str << endl;
return out;
}
friend istream& operator>>(istream& in, string& st)
{
st.clear();
char ch = '\0';
in.get(ch);
while (ch != ' ' && ch != '\n')
{
st += ch;
in.get(ch);
}
return in;
}
容量
包括扩容等函数，注意，平时一般不会缩容，因为缩容也需要先释放空间，再重新开一块空间，所以我们平时遇到缩容一般不做任何处理，只有需要扩容的时候才会重新释放然后开空间
size_t capacity() const
{
return _capacity;
}
size_t capacity()
{
return _capacity;
}
size_t size()
{
return _size;
}
size_t size() const
{
return _size;
}
void clear()
{
_size = 0;
}
void resize(size_t sz,char ch='\0')
{
if (sz > _size)
{
for (size_t i = _size; i < sz; i++)
{
(*this) += ch;
}
}
else
{
_size = sz;
}
}
void reserve(int newcapacity)
{
if (newcapacity > _capacity)
{
char* tmp = new char[newcapacity];
memcpy(tmp, _str, _size);
delete[] _str;
_str = tmp;
_capacity = newcapacity;
}
}
access
const成员会调用下面那个重载的函数
char& operator[](size_t index)
{
assert(index >= 0 && index < _size);
return _str[index];
}
const char& operator[](size_t index) const
{
assert(index >= 0 && index < _size);
return _str[index];
}
compare
可以先写一个大于和等于，然后其他的像我下面一样复用即可
bool operator>(const string& str)
{
size_t i = 0;
while (i < _size && i < str._size)
{
if (_str[i] <= str._str[i])
{
return false;
}
i++;
}
if (i < _size)
{
return true;
}
return false;
}
bool operator==(const string& str)
{
size_t i = 0;
while (i < str._size && i < _size)
{
if (_str[i] != str._str[i])
return false;
i++;
}
if (i < str._size)
return false;
if (i < _size)
return false;
return true;
}
bool operator>=(const string& str)
{
if (*this > str || *this == str)
return true;
return false;
}
bool operator<(const string& str)
{
if (*this >= str)
return false;
return true;
}
bool operator!=(const string& str)
{
if (*this == str)
return false;
return true;
}
bool operator<=(const string& str)
{
if (*this > str)
return false;
return true;
}
查
string库是不需要包string.h就可以使用strlen和strcmp等函数的，下面重载了在string里找第一个字符和在string类中找一个字符串的
size_t find(char ch) const
{
for (int i = 0; i < _size; i++)
{
if (_str[i] == ch)
return i;
}
return npos;
}
size_t find(const char* str) const
{
size_t i = 0;
size_t sz = strlen(str);
while (i < _size)
{
if (str[0] == _str[i])
{
int tmp = memcmp(str, _str + i, sz);
if (tmp == 0)
{
return i;
}
}
i++;
}
return npos;
}
增
下面实现了在某个位置插入一个字符和一串字符串两个函数，复用在尾插字符和字符串两个函数，然后运算符重载了两个+=，便于读写代码
void insert(char ch, size_t pos)
{
if (_size + 1 >= _capacity)
{
reserve(_size + 2);
}
size_t i = _size;
while (i >= pos + 1)
{
_str[i] = _str[i - 1];
i--;
}
_str[_size] = ch;
_size++;
_str[_size] = '\0';
}
void insert(const char* str,size_t pos)
{
assert(pos <= _size);
size_t sz = strlen(str);
if (_size + sz + 1 > _capacity)
{
reserve(_size + sz + 1);
}
size_t i = _size + sz - 1;
while (i >=pos+sz)
{
_str[i] = _str[i - sz];
i--;
}
memcpy(_str + pos, str, sz);
_str[_size + sz] = '\0';
_size = _size + sz;
}
void append(const char* str)
{
insert(str, _size);
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
void push_back(char ch)
{
if (_size + 1 == _capacity)
{
reserve(_capacity * 2 + 1);
}
_str[_size] = ch;
_size++;
_str[_size] = '\0';
}
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
删
len表示在pos位置处要删除多少个字符
string& erase(size_t pos,size_t len)
{
size_t i = pos + len;
while (i < _size)
{
_str[i - len] = _str[i];
i++;
}
resize(_size - len);
return *this;
}
改
这里就不实现了，改就是复用查和增就可以实现了。
npos
string库里有一个值为npos，可以看到下图len的值是npos，npos是无符号整型的-1，由于它是无符号整型，补码为最大，最后这个值会变成整型的最大值
npos有一个特殊的点需要注意
static const size_t npos = -1;//特殊处理
//static const double npos = -1;//报错
这里只有整型是特殊的，其他的类型都不能在这里初始化
string类的完整代码
#include<iostream>
#include<assert.h>
using namespace std;
namespace vientiane
{
class string
{
friend ostream& operator<<(ostream& out, const string& st)
{
out << st._str << endl;
return out;
}
friend istream& operator>>(istream& in, string& st)
{
st.clear();
char ch = '\0';
in.get(ch);
while (ch != ' ' && ch != '\n')
{
st += ch;
in.get(ch);
}
return in;
}
public:
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
const_iterator begin() const
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator end() const
{
return _str + _size;
}
string(const char* str = "")
:_str(nullptr)
,_size(strlen(str))
,_capacity(strlen(str)+1)
{
_str = new char[_capacity];
memcpy(_str, str, _size);
_str[_size] = '\0';
}
string(const string& str)
{
_str = new char[str.capacity()];
memcpy(_str, str._str, str.size());
_size = str.size();
_capacity = str.capacity();
_str[_size] = '\0';
}
string& operator=(const string& str)
{
delete[] _str;
_str = new char[str.capacity()];
memcpy(_str, str._str, str._size);
_size = str._size;
_capacity = str._capacity;
_str[_size] = '\0';
return *this;
}
size_t capacity() const
{
return _capacity;
}
size_t capacity()
{
return _capacity;
}
size_t size()
{
return _size;
}
size_t size() const
{
return _size;
}
void clear()
{
_size = 0;
}
void resize(size_t sz,char ch='\0')
{
if (sz > _size)
{
for (size_t i = _size; i < sz; i++)
{
(*this) += ch;
}
}
else
{
_size = sz;
}
}
void reserve(int newcapacity)
{
if (newcapacity > _capacity)
{
char* tmp = new char[newcapacity];
memcpy(tmp, _str, _size);
delete[] _str;
_str = tmp;
_capacity = newcapacity;
}
}
void push_back(char ch)
{
if (_size + 1 == _capacity)
{
reserve(_capacity * 2 + 1);
}
_str[_size] = ch;
_size++;
_str[_size] = '\0';
}
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
void insert(char ch, size_t pos)
{
if (_size + 1 >= _capacity)
{
reserve(_size + 2);
}
size_t i = _size;
while (i >= pos + 1)
{
_str[i] = _str[i - 1];
i--;
}
_str[_size] = ch;
_size++;
_str[_size] = '\0';
}
void insert(const char* str,size_t pos)
{
assert(pos <= _size);
size_t sz = strlen(str);
if (_size + sz + 1 > _capacity)
{
reserve(_size + sz + 1);
}
size_t i = _size + sz - 1;
while (i >=pos+sz)
{
_str[i] = _str[i - sz];
i--;
}
memcpy(_str + pos, str, sz);
_str[_size + sz] = '\0';
_size = _size + sz;
}
void append(const char* str)
{
insert(str, _size);
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
void swap(string& str)
{
std::swap(_str, str._str);
std::swap(_size, str._size);
std::swap(_capacity, str._capacity);
}
const char* c_str() const
{
return _str;
}
bool empty()
{
return _size == 0;
}
char& operator[](size_t index)
{
assert(index >= 0 && index < _size);
return _str[index];
}
const char& operator[](size_t index) const
{
assert(index >= 0 && index < _size);
return _str[index];
}
bool operator>(const string& str)
{
size_t i = 0;
while (i < _size && i < str._size)
{
if (_str[i] <= str._str[i])
{
return false;
}
i++;
}
if (i < _size)
{
return true;
}
return false;
}
bool operator==(const string& str)
{
size_t i = 0;
while (i < str._size && i < _size)
{
if (_str[i] != str._str[i])
return false;
i++;
}
if (i < str._size)
return false;
if (i < _size)
return false;
return true;
}
bool operator>=(const string& str)
{
if (*this > str || *this == str)
return true;
return false;
}
bool operator<(const string& str)
{
if (*this >= str)
return false;
return true;
}
bool operator!=(const string& str)
{
if (*this == str)
return false;
return true;
}
bool operator<=(const string& str)
{
if (*this > str)
return false;
return true;
}
size_t find(char ch) const
{
for (int i = 0; i < _size; i++)
{
if (_str[i] == ch)
return i;
}
return npos;
}
size_t find(const char* str) const
{
size_t i = 0;
size_t sz = strlen(str);
while (i < _size)
{
if (str[0] == _str[i])
{
int tmp = memcmp(str, _str + i, sz);
if (tmp == 0)
{
return i;
}
}
i++;
}
return npos;
}
string& erase(size_t pos,size_t len)
{
size_t i = pos + len;
while (i < _size)
{
_str[i - len] = _str[i];
i++;
}
resize(_size - len);
return *this;
}
~string()
{
delete[] _str;
_size = _capacity = 0;
}
static const size_t npos = -1;//特殊处理
//static const double npos = -1;//报错
private:
char* _str;
size_t _size;
size_t _capacity;
};
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
