本文详细介绍了C++标准库中的string类，包括其常用接口、构造函数、容量管理、访问遍历、修改操作，以及浅拷贝与深拷贝的区别，并提供了string类的模拟实现代码。
目录
1.标准库中的string类
1.1string类
string类是表示字符串的字符串类，string类的接口与其他常规容器的接口大致相同，string类增加了一些专门用来处理string的操作。string在底层实际是：basic_string模板类的别名，typedef basic_string string;。string类不能操作多字节或者变长字符的序列。
注意：使用string类时，必须包含#include头文件以及std命名空间。
1.2string类常用接口介绍
1.2.1常用构造函数
(constructor) 函数名称 功能说明
string() 构造空的string类对象 即空字符串
string(const char* s) 用C-string来构造string类对象
string(size_t n, char c) string类对象中包含n个字符c
string(const string&s) 拷贝构造函数
void test()
{
string s1;
string s2("abcd");
string s3(s2);
}1.2.2. string类对象的容量操作
函数名称与功能
size： 返回字符串有效字符长度
length ：返回字符串有效字符长度，size()与length()方法底层实现原理完全相同
capacity ：返回空间总大小
empty： 检测字符串释放为空串，是返回true，否则返回false
clear ：清空有效字符，clear()只是将string中有效字符清空，不改变底层空间大小。
reserve ： 为字符串预留空间**，reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于 string的底层空间总大小时，reserver不会改变容量大小。
resize ： 将有效字符的个数该成n个，多出的空间用字符c填充，resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字 符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的 元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大 小，如果是将元素个数减少，底层空间总大小不变。
void Test()
{
string s("hello, world!");
cout << s.size() << endl;
cout << s.length() << endl;
cout << s.capacity() << endl;
cout << s << endl;
s.clear();
cout << s.size() << endl;
cout << s.capacity() << endl;
s.resize(10, 'a');
cout << s.size() << endl;
cout << s.capacity() << endl;
s.resize(15);
cout << s.size() << endl;
cout << s.capacity() << endl;
cout << s << endl;
s.resize(5);
cout << s.size() << endl;
cout << s.capacity() << endl;
cout << s << endl;
}
1.2.3 string类对象的访问及遍历操作
operator[] ：返回pos位置的字符，const string类对象调用
begin+ end ：begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器
rbegin + rend ：begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器
范围for： C++11支持更简洁的范围for的新遍历方式
3种访问遍历方式：
string s("hello world");
// 1. for+operator[]
for (size_t i = 0; i < s.size(); ++i)
cout << s[i] << endl;
// 2.迭代器
string::iterator it = s.begin();
while (it != s.end())
{
cout << *it << endl;
++it;
}
auto rit = s.rbegin();
while (rit != s.rend())
cout << *rit << endl;
// 3.范围for
for (auto ch : s)
cout << ch << endl;1.2.4. string类对象的修改操作
push_back ：在字符串后尾插字符c
append： 在字符串后追加一个字符串
operator+= ：在字符串后追加字符串str
c_str：返回C格式字符串
find + npos： 从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置
rfind ：从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置
substr ：在str中从pos位置开始，截取n个字符，然后将其返回
void test()
{
string s("hello world");
s.push_back('!');
s.push_back('!');
s.append(" hello");
s += " hello";
cout << s << endl;
cout << s.c_str() << endl; // 以C语言的方式打印字符串
string file("string.cpp");
size_t pos = file.rfind('.');
string suffix(file.substr(pos, file.size() - pos));
cout << suffix << endl;
}
1.2.5. string类非成员函数
operator+ ：尽量少用，因为传值返回，导致深拷贝效率低
operator>> ： 输入运算符重载
operator<< ： 输出运算符重载
getline ： 获取一行字符串
relational operators： 大小比较
2.string类的模拟实现
2.1构造函数与析构函数
class string
{
public:
string(const char* str = "")
{
if (nullptr == str)
{
assert(false);
return;
}
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
~string()
{
if (_str)
{
delete[] _str;
_str = nullptr;
}
}
private:
char* _str;
};
void TestString()
{
String s1("hello world");
String s2(s1);
}以上代码没有写拷贝构造与赋值重载，编译器会自动生成，但是编译器自动生成的拷贝构造与赋值重载有很大的问题。编译器实现的是浅拷贝这样就会发生以下问题：
s1、s2共用同一块内存空间，调用析构时在释放时同一块空间被释放多次而引起程序崩溃。
2.2浅拷贝
浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共 享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。
2.3深拷贝
如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。
在拷贝构造和复制重载时new一块空间给新的对象再把数据拷贝过去。
2.4string类的模拟实现代码
namespace crin
{
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
public:
string(const char* str = "")
:_size(strlen(str))
,_capacity(_size)
{
if (str == nullptr)
{
assert(false);
return;
}
_str = new char[_capacity+1];
strcpy(_str, str);
}
//现代写法
string(const string& s)
:_str(nullptr)
,_size(0)
,_capacity(0)
{
string tmp(s._str);
swap(tmp);
}
/*string(const string& s)
{
_str = new char[s._capacity + 1];
strcpy(_str, s._str);
_size = s._size;
_capacity = s._capacity;
}*/
//现代写法
string& operator=(string s)
{
swap(s);
return *this;
}
/* string& operator=(const string& s)
{
if (_capacity < s._capacity)
{
reserve(s._capacity);
}
strcpy(_str, s._str);
_size = s._size;
return *this;
}*/
~string()
{
if (_str)
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
}
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n+1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void push_back(char c)
{
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = c;
_size++;
_str[_size] = '\0';
}
void append(const char* str)
{
size_t sz = strlen(str);
if (_size + sz > _capacity)
{
reserve(_size + sz);
}
strcpy(_str + _size, str);
_size += sz;
}
string& operator+=(char c)
{
push_back(c);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return* this;
}
void clear()
{
_str[0] = '\0';
_size =0;
}
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
const char* c_str()const
{
return _str;
}
size_t size()const
{
return _size;
}
size_t capacity()const
{
return _capacity;
}
bool empty()const
{
return _size == 0;
}
void resize(size_t n, char c = '\0')
{
if (n <= _size)
{
_size = n;
_str[_size] = '\0';
}
else
{
reserve(n);
for (size_t i = _size; i < n; i++)
{
_str[_size] = c;
++_size;
}
_str[_size] = '\0';
}
}
char& operator[](size_t index)
{
assert(index < _size);
return _str[index];
}
const char& operator[](size_t index)const
{
assert(index < _size);
return _str[index];
}
bool operator<(const string& s)
{
return strcmp(_str, s._str) < 0;
}
bool operator==(const string& s)
{
return strcmp(_str, s._str) == 0;
}
bool operator<=(const string& s)
{
return _str < s._str || _str == s._str;
}
bool operator>(const string& s)
{
return !(_str <= s._str);
}
bool operator>=(const string& s)
{
return !(_str < s._str);
}
bool operator!=(const string& s)
{
return !(_str == s._str);
}
// 返回c在string中第一次出现的位置
size_t find(char c, size_t pos = 0) const
{
assert(pos < _size);
for (size_t i = pos; i < _size; i++)
{
if(_str[i] == c)
{
return i;
}
}
return npos;
}
// 返回子串s在string中第一次出现的位置
size_t find(const char* s, size_t pos = 0) const
{
assert(pos < _size);
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == s[0])
{
size_t j = i, k = 0;
while (_str[j] == s[k])
{
if (_str[j] == '\0' || s[k] == '\0')
{
break;
}
j++;
k++;
}
if (s[k] == '\0')
{
return i;
}
}
}
return npos;
}
string substr(size_t pos, size_t len = npos)
{
string s;
size_t end = pos + len;
if (len == npos || pos + len > _size)
{
len = _size - pos;
end = _size;
}
s.reserve(len);
for (size_t i = pos; i < end; i++)
{
s += _str[i];
}
return s;
}
// 在pos位置上插入字符c/字符串str，并返回该字符的位置
string& insert(size_t pos, char c)
{
assert(pos < _size);
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
for (size_t i = _size+1; i > pos; i--)
{
_str[i] = _str[i - 1];
}
_str[pos] = c;
_size++;
return *this;
}
string& insert(size_t pos, const char* str)
{
assert(pos < _size);
size_t len = strlen(str);
if (len + _size > _capacity)
{
reserve(len + _size);
}
for (size_t end = _size+1; end > pos ; end--)
{
_str[end+len-1] = _str[end-1];
}
_size += len;
//_str[_size] = '\0';
strncpy(_str + pos, str, len);
return *this;
}
// 删除pos位置上的元素，并返回该元素的下一个位置
string& erase(size_t pos, size_t len)
{
assert(pos < _size);
for (size_t i = pos + len; i <= _size; i++)
{
_str[pos++] = _str[i];
}
_size -= len;
return *this;
}
private:
char* _str;
size_t _size;
size_t _capacity;
const static size_t npos;
};
const size_t string::npos = -1;
};
ostream& operator<<(ostream& _cout, const crin::string& s)
{
for (auto c : s)
{
_cout << c;
}
return _cout;
}
istream& operator>>(istream& _cin, crin::string& s)
{
char ch = _cin.get();
while (ch != ' ' && ch != '\n')
{
s += ch;
ch = _cin.get();
}
return _cin;
}
扫一扫
9万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
