1.std::string
学习文档：cplusplus.com/reference/string/string/?kw=string
- string是表示字符串的字符串类
- 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
- string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator>string;
- 不能操作多字节或者变长字符的序列。
在使用string类时，必须包含#include头文件以及using namespace std
2. string类的常用接口
-
string() 构造空的string类对象，即空字符串
std::string str;
// str 是一个空字符串 ""-
string(const char* s) 用C-string来构造string类对象
const char* s = "Hello, World!";
std::string str(s);
// str 包含 "Hello, World!"
-
string(size_t n, char c) string类对象中包含n个字符c
std::string str(5, 'a');
// str 包含 "aaaaa"
-
string(const string&s) 拷贝构造函数
std::string original = "Hello";
std::string copy(original);
// copy 包含 "Hello"
-
size length 返回字符串有效字符长度
size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
std::string str = "Hello";
std::cout << str.size() << std::endl; // 输出 5
std::cout << str.length() << std::endl; // 输出 5
-
capacity 返回空间总大小
std::string str = "Hello";
std::cout << str.capacity() << std::endl; // 输出可能大于等于5
-
empty 检测字符串释放为空串，是返回true，否则返回false
std::string str = "";
if (str.empty()) {
std::cout << "The string is empty." << std::endl;
}
-
clear 清空有效字符
clear()只是将string中有效字符清空，不改变底层空间大小。
std::string str = "Hello";
str.clear();
std::cout << str.size() << std::endl; // 输出 0
-
reserve 为字符串预留空间**
reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。
std::string str;
str.reserve(100); // 为字符串预留至少 100 个字符的空间
std::cout << str.capacity() << std::endl; // 输出 >= 100
-
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在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
std::string str = "Hello";
str.resize(10, 'x'); // 将字符串扩展到 10 个字符，新的部分用 'x' 填充
std::cout << str << std::endl; // 输出 "Helloxxxxx"
str.resize(3); // 将字符串截断为 3 个字符
std::cout << str << std::endl; // 输出 "Hel"
-
operator[] 返回pos位置的字符，const string类对象调用
std::string str = "Hello";
char ch = str[1]; // 获取位置1的字符，即 'e'
std::cout << ch << std::endl; // 输出 'e'
str[1] = 'a'; // 修改位置1的字符为 'a'
std::cout << str << std::endl; // 输出 "Hallo"
const std::string& cstr = str;
char c = cstr[1]; // 不能修改，只能读取
std::cout << c << std::endl; // 输出 'a'
-
begin+ end begin获取第一个符的迭代器 + end获取最后一个字符下一个位置的迭代器
std::string str = "Hello";
for (auto it = str.begin(); it != str.end(); ++it) {
std::cout << *it << " "; // 输出 H e l l o
}
std::cout << std::endl;
-
rbegin + rend rbegin获取最后一个字符的迭代器 + end获取第一个字符前一个位置的反向迭代器
反向迭代器主要用于逆序遍历
std::string str = "Hello";
for (auto rit = str.rbegin(); rit != str.rend(); ++rit) {
std::cout << *rit << " "; // 输出 o l l e H
}
std::cout << std::endl;
-
范围for C++11支持更简洁的范围for的新遍历方式
std::string str = "Hello";
for (char ch : str) {
std::cout << ch << " "; // 输出 H e l l o
}
std::cout << std::endl;
// 反向遍历
for (auto rit = str.rbegin(); rit != str.rend(); ++rit) {
std::cout << *rit << " "; // 输出 o l l e H
}
std::cout << std::endl;
-
string的3种遍历方式
string s("hello mumu");
// 3种遍历方式：
// 需要注意的以下三种方式除了遍历string对象，还可以遍历是修改string中的字符，
// 另外以下三种方式对于string而言，第一种使用最多
// 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;
}
string::reverse_iterator rit = s.rbegin();
while(rit != s.rend())
cout<<*rit<<endl;
// 3.范围for
for(auto ch : s)
cout<<ch<<endl;
}-
push_back 在字符串后尾插字符c
std::string str = "Hello";
str.push_back('!');
std::cout << str << std::endl; // 输出 "Hello!"
-
append 在字符串后追加一个字符串
std::string str = "Hello";
str.append(" World");
std::cout << str << std::endl; // 输出 "Hello World"
-
operator+= 在字符串后追加字符串str
std::string str = "Hello";
str += " World";
std::cout << str << std::endl; // 输出 "Hello World"
-
c_str 返回C格式字符串
std::string str = "Hello";
const char* cstr = str.c_str();
std::cout << cstr << std::endl; // 输出 "Hello"
-
find + npos从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置，如果未找到，返回
std::string::npos
npos是string里面的一个静态成员变量 static const size_t npos = -1;
std::string str = "Hello World";
size_t pos = str.find('o');
if (pos != std::string::npos) {
std::cout << "Found at position: " << pos << std::endl; // 输出 "Found at position: 4"
} else {
std::cout << "Character not found" << std::endl;
}
-
rfind 从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置，如果未找到，返回
std::string::npos
npos是string里面的一个静态成员变量 static const size_t npos = -1;
std::string str = "Hello World";
size_t pos = str.rfind('o');
if (pos != std::string::npos) {
std::cout << "Found at position: " << pos << std::endl; // 输出 "Found at position: 7"
} else {
std::cout << "Character not found" << std::endl;
}
-
substr 在str中从pos位置开始，截取n个字符，然后将其返回
std::string str = "Hello World";
std::string sub = str.substr(6, 5);
std::cout << sub << std::endl; // 输出 "World"
-
operator+ 尽量少用，因为传值返回，导致深拷贝效率低
在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般
情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
std::string str1 = "Hello";
std::string str2 = " World";
std::string result = str1 + str2;
std::cout << result << std::endl; // 输出 "Hello World"
-
operator>> 输入运算符重载
operator>> 会在遇到空白字符（如空格、换行符）时停止读取。如果需要读取整行字符串，应使用 std::getline()。
std::string str;
std::cin >> str; // 读取输入直到遇到空白字符
std::cout << "You entered: " << str << std::endl;
-
operator<< 输出运算符重载
std::string str = "Hello World";
std::cout << str << std::endl; // 输出 "Hello World"
-
getline 获取一行字符串
std::getline() 可以读取包含空格的整行输入，而 operator>> 只能读取到第一个空白字符为止。
std::string str;
std::getline(std::cin, str); // 读取整行输入，包括空格
std::cout << "You entered: " << str << std::endl;
-
relational operators 功能：用于比较两个字符串的大小。
std::string支持以下关系运算符：==：检查两个字符串是否相等。!=：检查两个字符串是否不相等。<：检查一个字符串是否小于另一个字符串。>：检查一个字符串是否大于另一个字符串。<=：检查一个字符串是否小于或等于另一个字符串。>=：检查一个字符串是否大于或等于另一个字符串。
std::string str1 = "Hello";
std::string str2 = "World";
if (str1 == str2) {
std::cout << "Strings are equal." << std::endl;
} else if (str1 < str2) {
std::cout << "str1 is less than str2." << std::endl;
} else {
std::cout << "str1 is greater than str2." << std::endl;
}
3.深浅拷贝
class string
{
public:
/*string()
:_str(new char[1])
{*_str = '\0';}
*/
//string(const char* str = "\0") 错误示范
//string(const char* str = nullptr) 错误示范
string(const char* str = "")
{
// 构造string类对象时，如果传递nullptr指针，认为程序非法，此处断言下
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 mumu!!!");
string s2(s1); //程序会出现崩溃，析构时双重释放内存
}浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以 当继续对资源进项操作时，就会发生发生了访问违规。要解决浅拷贝问题，C++中引入了深拷贝。
深拷贝:如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。
对于上述默认的拷贝构造函数,s2与s1同时指向一块内存，当s1析构的时候，会释放该内存，如果再到s2析构，会重复释放该内存，所以要进行深拷贝。
3.1传统的神拷贝写法
class string
{
public:
string(const char* str = "")
{
// 构造string类对象时，如果传递nullptr指针，认为程序非法，此处断言下
if(nullptr == str)
{
assert(false);
return;
}
_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)
{
char* pStr = new char[strlen(s._str) + 1];
strcpy(pStr, s._str);
delete[] _str;
_str = pStr;
}
return *this;
}
~string()
{
if(_str)
{
delete[] _str;
_str = nullptr;
}
}
private:
char* _str;
};if(this != &s) //用于检查赋值操作是否是自赋值。这是为了避免在删除原有内存之前重新分配内存，从而导致内存泄漏或未定义行为。
char* pStr = new char[strlen(s._str) + 1];分配新的内存，并将源字符串复制到新内存中，确保每个
string对象都有自己的独立内存空间。
delete[] _str;释放原有内存，避免内存泄漏。
_str = pStr;将_str指向新分配的内存。
3.2现代版写法的string类
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);
swap(_str, strTmp._str);
}
// 对比下和上面的赋值那个实现比较好？
string& operator=(string s)
{
swap(_str, s._str);
return *this;
}
/*
string& operator=(const string& s)
{
if(this != &s)
{
string strTmp(s);
swap(_str, strTmp._str);
}
return *this;
}
*/
~string()
{
if(_str)
{
delete[] _str;
_str = nullptr;
}
}
private:
char* _str;
};
扫一扫
441
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
