本章主要讲解C++string类的相关知识以及使用,还会模拟实现一下string类
C语言中,字符串是以’\0’结尾的一些字符的集合,为了操作方便,C标准库中提供了一些str系列的库函数,但是这些库函数与字符串是分离开的,不太符合OOP的思想,而且底层空间需要用户自己管理,稍不留神可能还会越界访问,由此C++做出改进引入了string类
typedef basic_string<char, char_traits, allocator>string;
注:在使用string类时,必须包含
#include<string>
using namespace std;
注:下面讲解最常用的接口
函数名称 | 功能说明 |
---|---|
string() (重点) | 构造空的string类对象,即空字符串 |
string(const char* s) (重点) | 用C-string来构造string类对象 |
string(size_t n, char c) | string类对象中包含n个字符c |
string(const string&s) (重点) | 拷贝构造函数 |
string (const string& str, size_t pos, size_t len = npos) | 从str对象中由pos位置开始截取len个长度的字符,len > str长度就结束 |
string (const char* s, size_t n) | 从s指向的字符数组中复制前n个字符 |
void Teststring1()
{
// 构造空的string类对象,等同于string s1("");
string s1;
// 用C格式字符串构造string类对象s2
string s2("hello cole");
// 拷贝构造s3
string s3(s2);
// 截取string类部分拷贝
string s4(s3, 6);//从第6个开始拷取到最后
// 截取字符数组部分拷贝
char str[] = "hello cole";
string s5(str, 5);//拷取前5个字符
cout << s1 << endl;
cout << s2 << endl;
cout << s3 << endl;
cout << s4 << endl;
cout << s5 << endl;
}
// 注意:string类对象支持直接用cin和cout进行输入和输出
函数名称 | 功能说明 |
---|---|
size(重点) | 返回字符串有效字符长度 |
length | 返回字符串有效字符长度 |
capacity | 返回空间总大小 |
empty (重点) | 检测字符串释放为空串,是返回true,否则返回false |
clear (重点) | 清空有效字符 |
reserve (重点) | 为字符串预留空间** |
resize (重点) | 将有效字符的个数该成n个,多出的空间用字符c填充 |
// size/clear/resize
void Teststring2()
{
string s("hello cole!");
cout << s.size() << endl;
cout << s.length() << endl;
cout << s.capacity() << endl;
cout << s << endl;
// 将s中的字符串清空,注意清空时只是将size清0,不改变底层空间的大小
s.clear();
cout << s.size() << endl;
cout << s.capacity() << endl;
// 将s中有效字符个数增加到10个,多出位置用'a'进行填充
// “aaaaaaaaaa”
s.resize(10, 'a');
cout << s.size() << endl;
cout << s.capacity() << endl;
// 将s中有效字符个数增加到15个,多出位置用缺省值'\0'进行填充
// "aaaaaaaaaa\0\0\0\0\0"
// 注意此时s中有效字符个数已经增加到15个
s.resize(15);
cout << s.size() << endl;
cout << s.capacity() << endl;
cout << s << endl;
// 将s中有效字符个数缩小到5个
s.resize(5);
cout << s.size() << endl;
cout << s.capacity() << endl;
cout << s << endl;
}
//reserve
void Teststring4()
{
string s;
// 测试reserve是否会改变string中有效元素个数
s.reserve(100);
cout << s.size() << endl;
cout << s.capacity() << endl;
// 测试reserve参数小于string的底层空间大小时,是否会将空间缩小
s.reserve(50);
cout << s.size() << endl;
cout << s.capacity() << endl;
}
// 利用reserve提高插入数据的效率,避免增容带来的开销
void TestPushBack()
{
string s;
size_t sz = s.capacity();
cout << "making s grow:\n";
for (int i = 0; i < 100; ++i)
{
s.push_back('c');
if (sz != s.capacity())
{
sz = s.capacity();
cout << "capacity changed: " << sz << '\n';
}
}
}
void TestPushBackReserve()
{
string s;
s.reserve(100);
size_t sz = s.capacity();
cout << "capacity: " << sz << '\n';
cout << "making s grow:\n";
for (int i = 0; i < 100; ++i)
{
s.push_back('c');
if (sz != s.capacity())
{
sz = s.capacity();
cout << "capacity changed: " << sz << '\n';
}
}
}
函数名称 | 功能说明 |
---|---|
operator[] (重点) | 返回pos位置的字符,普通对象和const对象有相应的版本 |
begin+ end | egin获取第一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器 |
rbegin + rend | begin获取第一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器 |
范围for | C++11支持,最终替换成迭代器 |
void Teststring5()
{
string s1("hello cole");
//使用operator[]+size()遍历字符串
for (size_t i = 0; i < s1.size(); i++)
{
//等同与s1.operator[](i)
cout << s1[i] << " ";
}
cout << endl;
//使用正向迭代器遍历字符串
string::iterator it1 = s1.begin();
while (it1 != s1.end())
{
cout << *it1 << " ";
it1++;
}
cout << endl;
//注意:iterator为普通迭代器,可读可写,const_iterator为const迭代器,只能读取字
string::const_iterator it3 = s1.begin();
while (it3 != s1.end())
{
//*it3+=1; 会报错
cout << *it3 << " ";
it3++;
}
cout << endl;
//使用反向迭代器遍历字符串
string::reverse_iterator it2 = s1.rbegin();
while (it2 != s1.rend())
{
cout << *it2 << " ";
it2++;
}
cout << endl;
//同样的反向迭代器的const迭代器为const_reverse_iterator
//范围for遍历字符串
for (auto e : s1)
{
cout << e << " ";
}
}
函数名称 | 功能说明 |
---|---|
push_back | 在字符串后尾插字符c |
append | 在字符串后追加一个字符串 |
operator+= (重点) | 在字符串后追加字符串str |
c_str(重点) | 返回C格式字符串 |
find + npos(重点) | 从字符串pos位置开始往后找字符c,返回该字符在字符串中的位置 |
rfind | 从字符串pos位置开始往前找字符c,返回该字符在字符串中的位置 |
substr | 在str中从pos位置开始,截取n个字符,然后将其返回 |
void Teststring6()
{
string str;
cout << str << endl;
str.push_back('c'); // 在str后插入字符
cout << str << endl;
str.append("hello"); // 在str后追加一个字符"hello"
cout << str << endl;
str += '\0'; // 在str后追加结束符
str += "cole"; // 在str后追加一个字符串"cole"
cout << str << endl;//即使遇到‘\0’也不会停止,只有把字符串给完全遍历完了才会停止遍历
cout << str.c_str() << endl; // 以C语言的方式打印字符串(遇到\0就停止)
}
void Teststring7()
{
// 获取file的后缀
string file("string.cpp");
size_t pos = file.rfind('.');//从后往前找字符.
string suffix(file.substr(pos, file.size() - pos));//拷贝pos位置之后的字符串
cout << suffix << endl;
// 取出url中的域名
string url("http://www.cplusplus.com/reference/string/string/find/");
cout << url << endl;
size_t start = url.find("://");//从前往后找字符串
if (start == string::npos)//没找到返回npos
{
cout << "invalid url" << endl;
return;
}
start += 3;
size_t finish = url.find('/', start);//再往后找结束位置
string address = url.substr(start, finish - start);//拷贝子串
cout << address << endl;
// 删除url的协议前缀
pos = url.find("://");
url.erase(0, pos + 3);
cout << url << endl;
}
注:npos是string里面的一个静态成员变量
static const size_t npos = -1;
函数 | 功能说明 |
---|---|
operator+ | 尽量少用,因为传值返回,导致深拷贝效率低 |
operator>> (重点) | 输入运算符重载 |
operator<< (重点) | 输出运算符重载 |
getline (重点) | 获取一行字符串 |
relational operators (重点) | 大小比较 |
注:对上述函数只是了解一下,对于其他的操作函数可以查阅文档了解
注:这里我们只是模拟实现string的一些常用接口,并非要完全复刻,学习下string类的底层,让对string类的理解更深一点就行了
注:模拟时为了避免与C++本身提供的string类造成命名冲突,我们选择在命名空间里进行实现
namespace cole
{
class string
{
friend ostream& operator<<(ostream& _cout, const cole::string& s);
friend istream& operator>>(istream& _cin, cole::string& s);
friend istream& getline(istream& _cin, string& s);
public:
typedef char* iterator;
typedef const char* const_iterator;
string(const char* str = "");
string(const string& s);
string& operator=(const string& s);
~string();
void swap(string& s);
// iterator
iterator begin();
iterator end();
const_iterator begin()const;
const_iterator end()const;
// modify
void push_back(char c);
string& operator+=(char c);
void append(const char* str);
string& operator+=(const char* str);
void clear();
const char* c_str()const;
// capacity
size_t size()const;
size_t capacity()const;
bool empty()const;
void resize(size_t n, char c = '\0');
void reserve(size_t n);
// access
char& operator[](size_t index);
const char& operator[](size_t index)const;
//relational operator
bool operator<(const string& s);
bool operator<=(const string& s);
bool operator>(const string& s);
bool operator>=(const string& s);
bool operator==(const string& s);
bool operator!=(const string& s);
// 返回c在string中第一次出现的位置
size_t find(char c, size_t pos = 0) const;
// 返回子串s在string中第一次出现的位置
size_t find(const char* s, size_t pos = 0) const;
// 在pos位置上插入字符c/字符串str,并返回该字符
string& insert(size_t pos, char c);
string& insert(size_t pos, const char* str);
// 删除pos位置上的长度个字符
string& erase(size_t pos, size_t len=npos);
private:
char* _str;
size_t _capacity;
size_t _size;
static const size_t npos;
};
//初始化静态私有成员变量
const size_t string::npos = -1;
}
一般来说对于只有内置类型的成员变量,我们可以选择编译器提供的拷贝构造函数和赋值重载函数(自己不写),编译器提供的这两个函数能够完成浅拷贝(拷贝值),但是对于存在指针成员变量的类,浅拷贝是不行的
namespace cole
{
class string
{
public:
string(const char* str = "")
{
// 断言不为空指针
assert(str);
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
~string()
{
if (_str)
{
delete[] _str;
_str = nullptr;
}
}
private:
char* _str;
};
// 测试
void Teststring()
{
string s1("hello cole");
string s2(s1);
}
}
int main()
{
cole::Teststring();
return 0;
}
即值拷贝(浅拷贝)让s1、s2共用同一块内存空间,在释放时同一块空间被释放多次而引起程序崩溃,由此对于涉及资源的管理,我们需要自己以深拷贝的方式写拷贝构造函数和赋值重载函数
给每个对象独立分配资源,保证多个对象之间不会因为共享资源而造成多种错误以及程序释放崩溃的问题
class string
{
public:
//构造函数
string(const char* str = "")
{
// 构造string类对象时,如果传递nullptr指针,认为程序非法,此处断言下
assert(str);
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
//拷贝构造函数
string(const string& s)
: _str(new char[strlen(s._str) + 1])
{
strcpy(_str, s._str);
}
//赋值
string& operator=(const string& s)
{
if (this != &s)//避免自己赋值自己(没有意义)
{
delete[]_str;
_str = new char[strlen(s._str) + 1];
strcpy(_str, s._str);
}
return *this;
}
//析构函数
~string()
{
delete[]_str;
_str = nullptr;
}
private:
char* _str;
};
class string
{
public:
//构造函数
string(const char* str = "")
{
if (nullptr == str)//处理空指针
str = "";
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
//拷贝构造
string(const string& s)
: _str(nullptr)//将自己赋值为空
{
string strTmp(s._str);//调用构造函数,生成一个具有相同内容的string
swap(_str, strTmp._str);//将string对象的各成员变量相互交换
}//拷贝构造结束strTmp会先析构再销毁
//赋值重载
string& operator=(string s)//传值参数,会调用拷贝构造,生成一个具有相同内容的string
{
swap(_str, s._str);//将string对象的各成员变量相互交换
return *this;
}//赋值重载结束束s会先析构再销毁
//析构函数
~string()
{
delete[] _str;
_str = nullptr;
}
private:
char* _str;
};
ostream& operator<<(ostream& _cout, const string& s)
{
for (auto ch : s)//会替换成string的迭代器
{
_cout << ch;
}
return _cout;
}
istream& operator>>(istream& _cin, string& s)
{
s.clear();//清理
char ch;
ch = _cin.get();//能够接收空格和结束符
while (ch != ' ' && ch != '\n')
{
s += ch;
ch = _cin.get();
}
return _cin;
}
istream& getline(istream& _cin, string& s)
{
s.clear();
char ch;
ch = _cin.get();
while (ch != '\n')
{
s += ch;
ch = _cin.get();
}
return _cin;
}
//构造函数
string::string(const char* str="")
{
if(str==nullptr)
str="";
_str = new char[strlen(str) + 1];
_size = strlen(str);
_capacity = _size;
strcpy(_str, str);
}
//交换string
void string::swap(string& s)
{
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
//拷贝构造
string::string(const string& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
string tmp(s._str);
swap(tmp);
}
//赋值重载
string& string::operator=(const string& s)//传引用
{
//避免自己给自己赋值
if (this != &s)
{
string tmp(s._str);
swap(tmp);
}
return *this;
}
//析构函数
string::~string()
{
delete[] _str;
_str = nullptr;
_size = 0;
_capacity = 0;
}
// iterator(普通对象)
string::iterator string::begin()
{
return _str;
}
string::iterator string::end()
{
return _str + _size;
}
// iterator(const对象)
string::const_iterator string::begin()const
{
return _str;
}
string::const_iterator string::end()const
{
return _str + _size;
}
// modify
//尾插字符
void string::push_back(char c)
{
满空间就扩容
//if (_size == _capacity)
//{
// reserve(_capacity == 0 ? 4 : _capacity * 2);
//}
//_str[_size] = c;
//_size++;
insert(_size, c);
}
string& string::operator+=(char c)
{
push_back(c);
return *this;
}
//追加字符串
void string::append(const char* str)
{
/*size_t len = _size + strlen(str);
if (len > _capacity)
{
reserve(len);
}
strcpy(_str + _size, str);
_size = len;*/
insert(_size, str);
}
string& string::operator+=(const char* str)
{
append(str);
return *this;
}
void string::clear()
{
_str[0] = '\0';
_size = 0;
}
const char* string::c_str()const
{
return _str;
}
size_t string::size()const
{
return _size;
}
size_t string::capacity()const
{
return _capacity;
}
bool string::empty()const
{
return _size == 0;
}
//开空间+初始
void string::resize(size_t n, char c)
{
if (n < _size)
{
_str[n] = '\0';
_size = n;
}
else
{
if (n > _capacity)
{
reserve(n);
}
int pos = _size;
while (pos < n)
_str[pos++] = c;
_str[n] = '\0';
_size = n;
}
}
//开空间
void string::reserve(size_t n)
{
//需要的空间大于容量就开空间
if (n > _capacity)
{
char* tmp = new char[n + 1];
strncpy(tmp, _str, _size + 1);//strcpy不能将\0后的内容也拷贝
delete[] _str;
_str = tmp;
_capacity = n;
}
}
// access
char& string::operator[](size_t index)
{
assert(index < _size);
return _str[index];
}
const char& string::operator[](size_t index)const
{
assert(index < _size);
return _str[index];
}
//relational operator
bool string::operator<(const string& s)
{
return strcmp(_str, s._str) < 0;
}
bool string::operator<=(const string& s)
{
return *this < s || *this == s;
}
bool string::operator>(const string& s)
{
return !(*this <= s);
}
bool string::operator>=(const string& s)
{
return !(*this < s);
}
bool string::operator==(const string& s)
{
return strcmp(_str, s._str);
}
bool string::operator!=(const string& s)
{
return !(*this == s);
}
// 返回c在string中第一次出现的位置
size_t string::find(char c, size_t pos) const
{
//pos的合理性
assert(pos < _size);
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == c)
return i;
}
//没找到
return npos;
}
// 返回子串s在string中第一次出现的位置
size_t string::find(const char* s, size_t pos) const
{
//pos的合理性
assert(pos < _size);
const char* ret = strstr(_str + pos, s);
if (ret)
return ret - _str;
//没找到
return npos;
}
// 在pos位置上插入字符c/字符串str
string& string::insert(size_t pos, char c)
{
assert(pos <= _size);
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
char* end = _str + _size;
while (end >= _str + pos)
{
*(end + 1) = *end;
end--;
}
_str[pos] = c;
_size++;
return *this;
}
string& string::insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t len1 = strlen(str);
size_t len2 = len1 + _size;
if (len2 > _capacity)
{
reserve(len2);
}
char* end = _str + _size;
while (end >= _str + pos)
{
*(end + len1) = *end;
end--;
}
strncpy(_str + pos, str, len1);
_size += len1;
return *this;
}
// 删除pos位置上的长度个字符
string& string::erase(size_t pos, size_t len)
{
assert(pos < _size);
size_t leftlen = _size - pos - 1;
if (len >= leftlen)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
return *this;
}