目录
引言
标准库中的 string 类
功能概述
常见操作示例
自我实现简易 string 类
代码结构概述
1. String11.h 头文件
类的成员变量
迭代器相关
构造函数和析构函数
基本访问和修改方法
赋值运算符重载
内存管理和扩容
以下代码在.cpp文件中解析:
2. String11.cpp 实现文件
字符串修改操作
插入和删除操作
查找和截取操作
比较运算符重载
输入输出运算符重载
3. Teststring.cpp 测试文件
主要功能点
4.特色总结
总结
引言
在 C++ 编程中，string 类是一个非常常用且重要的类，它位于标准库 <string> 中，为我们处理字符串提供了便捷的方式。不过，为了更好地理解 string 类的工作原理，我们可以尝试自己实现一个简易的 string 类。本文将详细解析 C++ 中的 string 类，并结合提供的代码文件，介绍如何自我实现一个简易的 string 类。
标准库中的 string 类
功能概述
C++ 标准库中的 string 类是一个模板类 std::basic_string<char> 的特化版本，它封装了字符数组，提供了一系列操作字符串的方法，如字符串的拼接、查找、替换、插入、删除等。使用 string 类，我们可以避免手动管理内存，减少内存泄漏的风险。
常见操作示例
#include <iostream>
#include <string>int main() {std::string s1 = "Hello";std::string s2 = " World";std::string s3 = s1 + s2; // 字符串拼接std::cout << s3 << std::endl;size_t pos = s3.find("World"); // 查找子字符串if (pos != std::string::npos) {std::cout << "Found at position: " << pos << std::endl;}s3.insert(5, ","); // 插入字符std::cout << s3 << std::endl;return 0;
}自我实现简易 string 类
代码结构概述
提供的代码文件包含了三个主要部分：String11.h 头文件、String11.cpp 实现文件和 Teststring.cpp 测试文件。下面我们将详细分析每个部分。
1. String11.h 头文件
一些短小且常用的函数都可以直接在头文件内实现，调用时直接内联展开。
类的成员变量
private:char* _str = nullptr;size_t _size;size_t _capacity;static const size_t npos;_str：一个指向字符数组的指针，用于存储字符串的实际内容。_size：表示当前字符串的长度，即字符串中字符的个数（不包括字符串结束符'\0'）。_capacity：表示当前分配给字符串的内存容量，即_str指向的字符数组的大小（包括字符串结束符'\0'）。npos：一个静态常量，表示无效的位置，通常用于表示查找操作未找到目标时的返回值。
迭代器相关
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;}- 功能：定义了迭代器类型
iterator和const_iterator，并提供了begin()和end()方法，使得该string类可以像标准容器一样使用迭代器进行遍历。 - 特点：支持范围
for循环和其他基于迭代器的算法，增强了代码的通用性和可维护性。
构造函数和析构函数
string(const char* str = "")
{_size = strlen(str);_capacity = _size;_str = new char[_capacity + 1];strcpy(_str, str);
}string(const string& s)
{_str = new char[s._capacity + 1];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;
}~string()
{delete[] _str;_str = nullptr;_size = _capacity = 0;
}- 默认构造函数：接受一个 C 风格字符串作为参数，若未提供则默认为空字符串。分配足够的内存来存储字符串，并将其复制到
_str中。 - 拷贝构造函数：接受一个
string对象作为参数，创建一个新的string对象，其内容和容量与原对象相同。 - 析构函数：释放
_str指向的动态分配内存，避免内存泄漏，并将_size和_capacity置为 0。
基本访问和修改方法
const char* c_str() const
{return _str;
}void clear()
{_str[0] = '\0';_size = 0;
}const size_t size() const
{return _size;
}const size_t capacity() const
{return _capacity;
}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()：返回指向字符串实际内容的 C 风格字符串指针。clear()：清空字符串，将字符串的第一个字符置为'\0'，并将_size置为 0。size()：返回字符串的当前长度。capacity()：返回字符串当前分配的内存容量。operator[]：重载了下标运算符，允许通过下标访问字符串中的字符。提供了常量和非常量版本，以支持对常量和非常量对象的访问。
赋值运算符重载
string& operator=(const string& s)
{if(this != &s){delete[] _str;_str = new char[s._capacity + 1];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;}return *this;
}- 功能：实现了对象之间的赋值操作。如果目标对象和源对象不是同一个对象，释放目标对象的原有内存，分配新的内存并复制源对象的内容。
- 特点：使用了自我赋值检查，避免了不必要的内存释放和重新分配。
内存管理和扩容
void reserve(size_t n)
{cout << "reserve:" << n << endl;if(n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}
}- 功能：预留至少
n个字符的内存空间。如果n大于当前容量，则分配新的内存，将原字符串复制到新内存中，并释放原内存。 - 特点：避免了频繁的内存重新分配，提高了性能。
以下代码在.cpp文件中解析:
void push_back(char ch);
void append(const char* str);
string& operator+=(char ch);
string& operator+=(const char* str);
void insert(size_t pos, char ch);
void insert(size_t pos, const char* str);
void erase(size_t pos, size_t len = npos);
size_t find(char ch, size_t pos = 0);
size_t find(const char* str, size_t pos = 0);
string substr(size_t pos = 0, size_t len = npos);
bool operator<(const string& s1, const string& s2);
bool operator<=(const string& s1, const string& s2);
bool operator>(const string& s1, const string& s2);
bool operator>=(const string& s1, const string& s2);
bool operator==(const string& s1, const string& s2);
bool operator!=(const string& s1, const string& s2);
istream& getline(istream& in, string& s);
ostream& operator<<(ostream& out, const string& s);
istream& operator>>(istream& in, string& s);2. String11.cpp 实现文件
先给定static变量npos值:
const size_t string::npos = -1;接下来实现剩下的代码:
字符串修改操作
void string::push_back(char ch){if(_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}_str[_size] = ch;_size++;_str[_size] = '\0';}void string::append(const char* str){size_t len = strlen(str);if(len + _size > _capacity){// 大于2倍，需要多少开多少，小于2倍按2倍扩reserve(len + _size > _capacity * 2 ? len + _size : _capacity * 2);}strcpy(_str + _size, str);_size = len;}string& string::operator+=(char ch){push_back(ch);return *this;}string& string::operator+=(const char* str){append(str);return *this;}push_back(char ch)：在字符串末尾添加一个字符。如果当前容量不足，则进行扩容。append(const char* str)：在字符串末尾添加一个 C 风格字符串。如果需要，会进行扩容。operator+=(char ch)和operator+=(const char* str)：重载了+=运算符，分别用于添加单个字符和 C 风格字符串，调用push_back和append方法实现。
插入和删除操作
void string::insert(size_t pos, char ch){assert(pos <= _size);if(_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}size_t end = _size + 1;while(end > pos){_str[end] = _str[end - 1];end--;}_str[pos] = ch;_size++;}void string::insert(size_t pos, const char* str){assert(pos <= _size);size_t len = strlen(str);if(len + _size > _capacity){reserve(len + _size > 2 * _capacity ? len + _size : _capacity * 2);}size_t end = _size + len;while(end > pos + len - 1){_str[end] = _str[end - len];end--;}for(size_t i = 0; i < len; i++){_str[pos + i] = str[i];}_size += len;}void string::erase(size_t pos, size_t len){assert(_size > pos);if(len >= _size - pos) // 不能写pos + len , 因为len == npos时为INT_MAX越界{_size = pos;_str[pos] = '\0';}else{size_t res = pos + len;while(res <= _size){_str[pos++] = _str[res++];}_size -= len;}}insert(size_t pos, char ch)：在指定位置pos插入一个字符。如果容量不足，会进行扩容。insert(size_t pos, const char* str)：在指定位置pos插入一个 C 风格字符串。同样，若需要会进行扩容。erase(size_t pos, size_t len = npos)：从指定位置pos开始删除len个字符。如果len大于等于从pos到字符串末尾的字符数，则删除从pos开始的所有字符。
查找和截取操作
size_t string::find(char ch, size_t pos){assert(pos < _size);for(size_t i = pos; i < _size; i++){if(_str[i] == ch)return i;}return npos;}size_t string::find(const char* str, size_t pos){assert(pos < _size);const char* res = strstr(_str + pos, str);if(res == nullptr){return npos;}return res - _str;}string string::substr(size_t pos, size_t len){assert(pos < _size);//len大于字符串长度，更新一下lenif(len > _size - pos){len = _size - pos;}string sub;sub.reserve(len);for(size_t i = 0; i < len; i++){sub += _str[i + pos];}return sub;}find(char ch, size_t pos = 0)：从指定位置pos开始查找字符ch，返回其第一次出现的位置。如果未找到，则返回npos。find(const char* str, size_t pos = 0)：从指定位置pos开始查找 C 风格字符串str，返回其第一次出现的位置。若未找到，返回npos。substr(size_t pos = 0, size_t len = npos)：从指定位置pos开始截取长度为len的子字符串。如果len大于从pos到字符串末尾的字符数，则截取到字符串末尾。
比较运算符重载
bool operator<(const string& s1, const string& s2){return strcmp(s1.c_str(), s2.c_str()) < 0;}bool operator<=(const string& s1, const string& s2){return strcmp(s1.c_str(), s2.c_str()) <= 0;}bool operator>(const string& s1, const string& s2){return !(s1 <= s2);}bool operator>=(const string& s1, const string& s2){return !(s1 < s2);}bool operator==(const string& s1, const string& s2){return strcmp(s1.c_str(), s2.c_str()) == 0;}bool operator!=(const string& s1, const string& s2){return !(s1 == s2);}- 功能：重载了比较运算符，用于比较两个
string对象的大小。使用strcmp函数进行比较。 - 特点：使得
string对象可以像标准类型一样进行比较，方便进行排序和条件判断。
输入输出运算符重载
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;// ch = in.get();// while(ch != ' ' && ch != '\n')// {// s += ch;// ch = in.get();// }// return in;// }优化istreamistream& operator>>(istream& in, string& s){s.clear();const int N = 256;char buff[N];int i = 0;char ch;ch = in.get();while(ch != ' ' && ch != '\n'){buff[i++] = ch;if(i == N - 1){buff[i] = '\0';s += buff;i = 0;}ch = in.get();}if(i > 0){buff[i] = '\0';s += buff;}return in;}istream& getline(istream& in, string& s){s.clear();const int N = 256;char buff[N];int i = 0;char ch;ch = in.get();while(ch != '\n'){buff[i++] = ch;if(i == N - 1){buff[i] = '\0';s += buff;i = 0;}ch = in.get();}if(i > 0){buff[i] = '\0';s += buff;}return in;}getline(istream& in, string& s)：从输入流中读取一行字符串，直到遇到换行符'\n'，并将其存储到s中。operator<<(ostream& out, const string& s)：重载了输出运算符，将string对象的内容输出到输出流中。operator>>(istream& in, string& s)：重载了输入运算符，从输入流中读取一个单词（以空格或换行符分隔），并将其存储到s中。
3. Teststring.cpp 测试文件
#include "String11.h"namespace lmr
{void string_test(){string s("haha");cout << s.c_str() << endl;s += "sss";s += 's';cout << s.c_str() << endl;cout << s.size() << " " << s.capacity() << endl;s.insert(2, "sss");cout << s.c_str() << endl;s.insert(5, '*');cout << s.c_str() << endl;s.erase(2);cout << s.c_str() << endl;string s1("test.cpp");size_t pos = s1.find('.');string buffix = s1.substr(pos);cout << buffix.c_str() << endl; }void string_test1(){string s("Hello World");string s2(s);bool sign = s2 == s;if(sign == true){// cin >> s;getline(cin, s);cout << s << endl;string s3;cin >> s3;cout << s3 << endl;}cout << endl;}}int main()
{lmr::string_test1();return 0;
}
主要功能点
- 测试用例：提供了多个测试用例，测试了字符串的拼接、插入、删除、查找、截取等操作。
4.特色总结
- 动态内存管理：通过
new和delete运算符动态分配和释放内存，避免了固定大小数组的限制。 - 模拟标准库接口：提供了与
std::string类似的接口，如迭代器、构造函数、赋值运算符等，方便用户使用。 - 内存优化：使用
reserve方法进行内存预分配，减少了频繁的内存重新分配，提高了性能。 - 异常处理：使用
assert进行边界检查，确保操作的安全性。但在实际应用中，建议使用更健壮的异常处理机制。 - 可扩展性：可以方便地添加更多的功能，如替换、大小写转换等。
总结
通过自我实现一个简易的 string 类，我们可以更深入地理解 C++ 中 string 类的工作原理和内存管理机制。同时，我们也学习了如何使用类和对象的概念，以及如何重载运算符和使用迭代器。在实际编程中，建议使用标准库中的 string 类，因为它经过了严格的测试和优化，具有更高的性能和可靠性。
)
 -- Java使用Redis命令)
)
