string类的基本使用与模拟实现string类
文章目录
- 一. 为什么要学习string类
- 二. string类的基本使用
- 三. string类的常用接口
-
- 1.访问及遍历函数
- 2.容量相关函数
- 3.操作相关函数
- 四. string类中的迭代器
-
- 1.迭代器是什么
- 2.迭代器的使用
- 五. 模拟实现string类
-
- 1.定义string类
- 2.构造函数
- 3.拷贝构造函数
- 4.赋值重载
- 5.析构函数
- 6.[]操作符重载
- 7.比较运算符重载
- 8.c_str、size、capacity
- 9.resize与reserve
- 10.添加数据 - push_back、append、+=重载
- 11.insert
- 12.erase
- 13.find
- 14.substr
- 15.clear
- 16.迭代器
- 17.>> 与 << 重载
- 18.完整源码
一. 为什么要学习string类
在C语言中，字符串是使用字符数组表示的，这种方式比较容易出现错误，如数组越界、缓冲区溢出等。
C++的string类是一个标准库中的类，它是一个容器，可以存储字符串，同时提供了许多方便的方法来操作字符串，如查找、替换、拼接等。
使用string类，可以避免手动处理字符串时出现的错误，如内存泄漏、越界、缓冲区溢出等问题，同时也减少了代码量，提高了代码的可读性和可维护性。string类还支持重载运算符，使得对字符串的操作更加直观和方便。
因此，C++中引入string类是为了更加方便、安全地处理字符串，提高代码的可读性和可维护性。
在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string类，很少有人去使用C库中的字符串操作函数。
二. string类的基本使用
- 使用string类前需要包含头文件
< string >
#include- 创建一个string类对象
string s1;
- 创建并初始化对象
string s2("hello world");
string s3 = "hello world";
- 使用
[]或at()函数来访问字符串中的单个字符。区别是at()函数会进行边界检查，避免越界访问
string str = "hello world";
cout << str[0] << endl;
cout << str.at(1) << endl;
- 可以使用加号运算符
+将两个字符串拼接起来，也可以使用append()函数将一个字符串添加到另一个字符串的末尾
string str1 = "hello";
string str2 = "world";
string str3 = str1 + str2; // 将str1和str2拼接起来
string str4 = str1.append(str2); // 将str2添加到str1的末尾
str+='a'; // 向str末尾添加一个字符'a'
- 使用
cin向string类对象中输入数据（遇到空格读取结束）
string str;
cin >> str;
- 使用
getline函数向string类对象中输入数据（遇到换行符读取结束）
string str;
str.getline();
- 使用
cout输出string类对象的内容
string str;
cout << str << endl;
三. string类的常用接口
1.访问及遍历函数
operator[]：返回当前字符串中指定位置的字符at(size_t pos)：返回当前字符串中指定位置的字符，并进行边界检查
string str = "hello world";
cout << str[0] << endl;
cout << str.at(1) << endl;
front()：返回当前字符串中的第一个字符back()：返回当前字符串中的最后一个字符
string str = "hello world";
cout << str.front() << endl;
cout << str.back() << endl;
c_str()：返回一个指向当前字符串内容的C风格字符串；
string str = "hello world";
cout << str.c_str() << endl;
- 范围
for:
范围for循环是C++11新增的一种语法结构，用于遍历容器类中的元素。它可以遍历数组、容器类等可迭代的对象，使得程序员可以更加简洁地遍历容器中的元素，而不必关心迭代器的细节。
范围for是基于迭代器实现的，也就是说有了迭代器我们就可以使用范围for了。
string str = "hello world";
for (auto c : str)
{
cout << c << ' ';
}
cout << endl;
2.容量相关函数
empty()：判断当前字符串是否为空
string str = "hello world";
cout << str.empty() << endl;
size()：返回当前字符串的字符数，不包含'\0'
string str = "hello world";
cout << str.size() << endl;
length()：返回当前字符串的字符数，不包含'\0'
string str = "hello world";
cout << str.length() << endl;
capacity()：返回当前字符串容量，即可以存储的字符数
string str = "hello world";
cout << str.capacity() << endl;
reserve()：为当前字符串分配指定的容量，即扩容
string str = "hello world";
str.reserve(100);
resize()：扩容并初始化
string str = "hello world";
str.resize(100, 'a');
3.操作相关函数
operator+：将两个字符串拼接起来append()：将一个字符串添加到另一个字符串的末尾
string str1 = "hello";
string str2 = "world";
string str3 = str1 + str2; // 将str1和str2拼接起来
string str4 = str1.append(str2); // 将str2添加到str1的末尾
replace()：用一个字符串替换另一个字符串中的指定部分
//在下标为0处，替换1个字符'a'，长度为1
string str = "hello world";
cout << str.replace(0, 1, 1, 'a');
insert()：在指定位置插入一个字符串
string str = "hello world";
cout << str.insert(0, "aaaa") << endl; //在位置0处插入字符串
cout << str.insert(0, 5, 'a') << endl; //在位置0处插入5个字符'a
erase()：删除指定位置的一个字符或一段字符
string str = "hello world";
cout << str.erase(0,5) << endl; //删除从位置0开始的5个字符
cout << str.erase() << endl; //清空字符串
substr()：返回一个子串，包含从指定位置开始的指定数量的字符
string str = "hello world";
//返回字符串中从位置0处开始的长度为3的字串
string substr = str.substr(0, 3);
find()：在当前字符串中查找指定子串的位置rfind()：在当前字符串中从后往前查找指定子串的位置
string str = "hello world";
//从位置0处开始寻找字串"world"，若找到就返回字串的起始位置
cout << str.find("world",0) << endl;
compare()：将当前字符串与另一个字符串进行比较
string str1 = "hello";
string str2 = "world";
str1.compare(str2);
关于string类中的函数接口我们就简单认识这些。库中string类的接口有一百多个，但是我们平时高平率使用的也就几个到十几个而已。在以后的工作当中，我们应该注重官方文档的使用，多查询文档能使我们对接口的使用更加准确和规范。
四. string类中的迭代器
1.迭代器是什么
迭代器是一种通用的概念，它提供了一种方式来遍历容器中的元素，不必关心容器的具体类型和实现方式。在
C++中，迭代器被广泛地应用于STL（标准模板库）中，包括vector、list、map等容器类，使得程序员可以方便地访问和操作容器中的元素。
迭代器的实现原理是基于指针，它本质上是一个类似于指针的对象，它指向容器中的元素，并提供了一组操作方法，使得程序员可以通过迭代器来遍历容器中的元素。迭代器可以像指针一样进行自增、自减操作，以及支持解引用操作来获取指向的元素值。
在目前阶段，我们不对迭代器做过多的讲解，我们可以粗浅的把它看作指针一样的东西来使用。
2.迭代器的使用
在C++中，字符串类string也支持迭代器的使用，可以使用迭代器来访问字符串中的每一个元素。
string类的迭代器提供了begin()和end()方法，begin()返回一个指向字符串第一个元素的迭代器，end()返回一个指向字符串最后一个元素的下一个位置的迭代器。这样，我们就可以使用迭代器来遍历整个字符串。
string str = "hello world";
// 使用迭代器遍历字符串
for (string::iterator it = str.begin(); it != str.end(); ++it) {
cout << *it << " ";
}
五. 模拟实现string类
1.定义string类
为了区别于标准库中的string类，我们使用自己的命名空间，在自己命名空间中模拟实现string类。
string类包含这三个基本成员：
char* _str 字符数组；
size_t _size 大小；
size_t _capacity 容量；
此外还需声明一个static成员npos，npos为将来实现的某些成员函数的缺省值，值位-1:
namespace dianxia
{
class string
{
public:
//...
private:
char* _str;
size_t _size;
size_t _capacity;
//类中进行声明
static const size_t npos;
}
//类外定义npos
const size_t string::npos = -1;
}
2.构造函数
string类提供两种构造方法：
- 直接构造
string str;
- 传字符串构造
string str("hello world");
- 对于传字符串构造的情况，我们可以实现用
const char* str来接收它 - 对于直接构造的情况，我们可以用缺省值来解决
//构造函数
string(const char* str = "") //使用缺省值
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1]; //+1为'\0'预留空间
//strcpy(_str, str);
memcpy(_str, str, _size+1);
}
3.拷贝构造函数
我们还会遇到用string类对象进行构造的情况：
string s1;
string s2(s1);
拷贝构造虽然不写，编译器会自动实现，但是自动实现的拷贝构造为浅拷贝，对于string类中，成员变量会申请资源的情况，浅拷贝是行不通的，所以需要我们自己实现:
//拷贝构造
string(const string& s)
{
_str = new char[s._capacity + 1];
//strcpy(_str, s._str);
memcpy(_str, s._str, s._size + 1);
_size = s._size;
_capacity = s._capacity;
}
4.赋值重载
string s1;
string s2 = s1;
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
//赋值运算符重载
string& operator=(string tmp)
{
swap(tmp);
return *this;
}
5.析构函数
//析构函数
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
6.[]操作符重载
注意应对const对象与非const对象须实现不同的重载函数。
//用于const对象只读
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
//用于普通对象可读可写
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
7.比较运算符重载
bool operator<(const string& s) const
{
int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
// "hello" "hello" false
// "helloxx" "hello" false
// "hello" "helloxx" true
return ret == 0 ? _size < s._size : ret < 0;
}
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);
}
bool operator!=(const string& s) const
{
return !(*this == s);
}
8.c_str、size、capacity
c_str：返回C底层的字符串size：返回_sizecapacity：返回_capacity
const char* c_str()
{
return _str;
}
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
9.resize与reserve
resize：扩容并初始化reserve：只扩容
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
//strcpy(tmp, _str);
memcpy(tmp, _str, _size+1);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
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';
}
}
10.添加数据 - push_back、append、+=重载
push_back：尾插一个字符append：尾插一个字符串+=：尾插一个字符或字符串
void push_back(char ch)
{
if (_size == _capacity)
{
// 2倍扩容
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
void append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
// 至少扩容到_size + len
reserve(_size+len);
}
//strcpy(_str + _size, str);
memcpy(_str + _size, str, len+1);
_size += len;
}
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
11.insert
insert：在pos位置插入一个字符或字符串
void insert(size_t pos, size_t n, char ch)
{
assert(pos <= _size);
if (_size +n > _capacity)
{
// 至少扩容到_size + len
reserve(_size + n);
}
// 添加注释最好
size_t end = _size;
while (end >= pos && end != npos)
{
_str[end + n] = _str[end];
--end;
}
for (size_t i = 0; i < n; i++)
{
_str[pos + i] = ch;
}
_size += n;
}
void insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t len = strlen(str);
if (_size + len > _capacity)
{
// 至少扩容到_size + len
reserve(_size + len);
}
// 添加注释最好
size_t end = _size;
while (end >= pos && end != npos)
{
_str[end + len] = _str[end];
--end;
}
for (size_t i = 0; i < len; i++)
{
_str[pos + i] = str[i];
}
_size += len;
}
12.erase
erase：删除pos位置向后的n个字符
void erase(size_t pos, size_t len = npos)
{
assert(pos <= _size);
if (len == npos || pos + len >= _size)
{
_str[pos] = '\0';
_size = pos;
_str[_size] = '\0';
}
else
{
size_t end = pos + len;
while (end <= _size)
{
_str[pos++] = _str[end++];
}
_size -= len;
}
}
13.find
find：从pos位置开始向后查找指定字符或字符串，并返回起始位置的下标
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;
}
}
14.substr
substr:从pos位置获取一个长度为n的子串
string substr(size_t pos = 0, 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;
}
15.clear
clear:清理数据
void clear()
{
_str[0] = '\0';
_size = 0;
}
16.迭代器
有了迭代器，我们就能对自己实现的类使用范围for了。
//迭代器
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;
}
17.>> 与 << 重载
注意这两个函数须定义在类外。
ostream& operator<<(ostream& out, const string& str)
{
for (auto ch : str)
{
out << ch;
}
return out;
}
istream& operator>>(istream& in, string& str)
{
str.clean();
char ch = in.get();
char buff[128]; //避免因频繁扩容导致效率过低
size_t i = 0;
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == 127)
{
buff[127] = '\0';
str += buff;
i = 0;
}
ch = in.get();
}
if (i != 0)
{
buff[i] = '\0';
str += buff;
}
return in;
}
18.完整源码
namespace dianxia
{
class string
{
public:
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;
}
string(const char* str = "")
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];
//strcpy(_str, str);
memcpy(_str, str, _size+1);
}
string(const string& s)
{
_str = new char[s._capacity + 1];
//strcpy(_str, s._str);
memcpy(_str, s._str, s._size + 1);
_size = s._size;
_capacity = s._capacity;
}
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
string& operator=(string tmp)
{
swap(tmp);
return *this;
}
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
const char* c_str() const
{
return _str;
}
size_t size() const
{
return _size;
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
void reserve(size_t n)
{
if (n > _capacity)
{
cout << "reserve()->" << n << endl;
char* tmp = new char[n + 1];
//strcpy(tmp, _str);
memcpy(tmp, _str, _size+1);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
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';
}
}
void push_back(char ch)
{
if (_size == _capacity)
{
// 2倍扩容
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
void append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
// 至少扩容到_size + len
reserve(_size+len);
}
//strcpy(_str + _size, str);
memcpy(_str + _size, str, len+1);
_size += len;
}
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
void insert(size_t pos, size_t n, char ch)
{
assert(pos <= _size);
if (_size +n > _capacity)
{
// 至少扩容到_size + len
reserve(_size + n);
}
size_t end = _size;
while (end >= pos && end != npos)
{
_str[end + n] = _str[end];
--end;
}
for (size_t i = 0; i < n; i++)
{
_str[pos + i] = ch;
}
_size += n;
}
void insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t len = strlen(str);
if (_size + len > _capacity)
{
// 至少扩容到_size + len
reserve(_size + len);
}
// 添加注释最好
size_t end = _size;
while (end >= pos && end != npos)
{
_str[end + len] = _str[end];
--end;
}
for (size_t i = 0; i < len; i++)
{
_str[pos + i] = str[i];
}
_size += len;
}
void erase(size_t pos, size_t len = npos)
{
assert(pos <= _size);
if (len == npos || pos + len >= _size)
{
_str[pos] = '\0';
_size = pos;
_str[_size] = '\0';
}
else
{
size_t end = pos + len;
while (end <= _size)
{
_str[pos++] = _str[end++];
}
_size -= len;
}
}
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;
}
}
string substr(size_t pos = 0, 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;
}
void clear()
{
_str[0] = '\0';
_size = 0;
}
bool operator<(const string& s) const
{
int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
// "hello" "hello" false
// "helloxx" "hello" false
// "hello" "helloxx" true
return ret == 0 ? _size < s._size : ret < 0;
}
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);
}
bool operator!=(const string& s) const
{
return !(*this == s);
}
private:
size_t _size;
size_t _capacity;
char* _str;
public:
const static size_t npos;
};
const size_t string::npos = -1;
ostream& operator<<(ostream& out, const string& s)
{
for (auto ch : s)
{
out << ch;
}
return out;
}
istream& operator>>(istream& in, string& s)
{
s.clear();
char ch = in.get();
// 处理前缓冲区前面的空格或者换行
while (ch == ' ' || ch == '\n')
{
ch = in.get();
}
char buff[128];
int i = 0;
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == 127)
{
buff[i] = '\0';
s += buff;
i = 0;
}
//in >> ch;
ch = in.get();
}
if (i != 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}
};
本文到此结束,码文不易,还请多多支持 ! ! !