网站掉权重是怎么回事,做网站需要服务器查询吗,如何实现,网站建设找美橙互联引言
在c中#xff0c;string类的引用极大地简化了字符串的操作和管理#xff0c;相比 C 风格字符串#xff08;char*或cahr[]#xff09;#xff0c;std::string 提供了更高效和更安全的字符串操作。接下来让我们一起来深入学习string类吧#xff01;
1.string 的构造…引言
在c中string类的引用极大地简化了字符串的操作和管理相比 C 风格字符串char*或cahr[]std::string 提供了更高效和更安全的字符串操作。接下来让我们一起来深入学习string类吧
1.string 的构造与初始化 - 介绍 string类 的几种常见的构造方式 - 默认构造创建空字符串。 - 通过 C 风格字符串初始化std::string s(Hello); - 复制构造从另一个字符串构造。 - 指定字符和长度构造std::string s(5, A);
using namespace std; string s1; // 空字符串string s2(Hello); // 通过 C 风格字符串初始化string s3(s2); // 复制构造string s4(5, A); // 重复字符构造 // AAAAA
2.string的迭代器支持
在 C 中迭代器Iterator是一种抽象概念用来遍历容器中的元素。std::string 作为标准库中的容器类支持迭代器使得我们可以像操作其他 STL 容器如 vector、list 等一样使用迭代器来遍历和操作字符串。
1什么是迭代器
迭代器可以理解为一个指针它指向容器中的某个元素通过迭代器我们可以逐个访问容器中的元素。不同于普通指针迭代器具备更强的泛化性能适用于不同的容器。对 std::string 来说迭代器可以用于遍历字符串中的每个字符。
2std::string 的迭代器类型
string 提供了几种常见的迭代器类型
string::iterator正向迭代器用于从字符串的起始位置向末尾遍历。
string::const_iterator常量正向迭代器和 iterator 类似但它不允许修改迭代器指向的元素。
string::reverse_iterator反向迭代器用于从字符串末尾向前遍历。string::const_reverse_iterator常量反向迭代器反向遍历并且不允许修改元素。
3常用的迭代器操作
begin()返回指向字符串第一个字符的正向迭代器。
end()返回指向字符串末尾之后位置的正向迭代器即超尾迭代器不指向实际元素。rbegin()返回指向字符串最后一个字符的反向迭代器。
rend()返回指向字符串第一个字符之前位置的反向迭代器。
cbegin() 和 cend()常量正向迭代器保证字符串内容不可修改。
crbegin() 和 crend()常量反向迭代器。
#include iostream
#include string
using namespace std;int main() {string str1 Hello World;// 使用正向迭代器遍历字符串string::iterator it1 str1.begin();while ( it1 ! str1.end() ) {cout *it1 ; // 输出每个字符it1;}cout endl;// 通过正向迭代器修改字符串string::iterator it2 str1.begin();while ( it2 ! str1.end()) {(*it2);//所有字符替换为下一个cout *it2 ;// 输出修改后的字符串it2;}cout endl;// 使用常量正向迭代器遍历字符串const string str2(str1);string::const_iterator it3 str2.cbegin();while ( it3 ! str2.cend()) {//*(it3);cout *it3 ; // 输出每个字符但不能修改it3;}cout endl;// 使用反向迭代器遍历字符串string::reverse_iterator rit str1.rbegin();while ( rit ! str1.rend()) {cout *rit ; // 反向输出字符串rit;}cout endl;return 0;
}3.常用成员函数
3.1.获取字符串长度
size()和 length()作用相同都用于返回字符串的长度返回类型都是size_t。
#include iostream
using namespace std;int main()
{string s Hello;cout s.size() endl;//5cout s.length() endl;//5return 0;
} 5
两者没有功能上的区别提供两个概念主要是为了与开发者的习惯保持一致size_t()更符合容器类的术语length()更符合处理字符串的自然语言概念
3.2. 访问和修改字符串
std::string::at() 是 C 标准库中std::string类的成员函数用于安全地访问字符串中的指定字符。它会根据提供的索引返回该索引位置的字符同时会进行越界检查如果索引超出了字符串的范围则会抛出 std::out_of_range 异常。
相比直接使用下标运算符 []at() 的优势在于它提供了边界检查从而避免访问无效位置导致未定义行为。 3.3.1函数原型
char at(size_t pos);
const char at(size_t pos) const;
- pos要访问的字符的索引size_t类型。 - 返回值pos位置处的字符。如果at()被用于常量字符串它返回const char否则返回 char。
3.2.2与 [] 运算符的区别
- at()会检查索引是否超出范围如果超出抛出 std::out_of_range异常程序可以捕获该异常。用于安全地访问和修改字符串中的字符推荐在需要安全性和健壮性时使用。 - []不进行越界检查如果访问超出范围的索引行为是未定义的可能导致程序崩溃或错误。在确定索引合法的情况下使用。
3.2.3示例代码
#include iostream
using namespace std;int main() {string str Hello, World!;// 使用 at() 访问字符串中的字符cout 字符串的第一个字符 str.at(1) endl; // 输出 e// 修改字符串中的字符str.at(7) C; // 将 W 修改为 Ccout 修改后的字符串 str endl;try {// 尝试访问超出范围的字符抛出异常char ch str.at(20);cout ch endl;}catch (const out_of_range e) {// 捕获 out_of_range 异常cout Out of range error e.what() endl;}return 0;
} 3.3. 拼接字符串
在 C 中拼接字符串的方式有很多其中比较常用的方式包括使用 运算符通过 operator 重载实现以及 append() 函数。虽然它们的作用都是拼接字符串但它们有不同的使用场景和性能特点。
3.3.1使用 运算符operator 运算符是 C 中常用的拼接字符串的方法。它通过重载 operator 来实现两个字符串的拼接操作。
int main()
{string str1 Hello;string str2 World;// 使用 运算符拼接字符串string result str1 , str2 !;cout Result: result endl; // 输出 Hello, World!return 0;
} 3.3.2使用append()方法
append()是 std::string 类的成员函数用于将另一个字符串或字符拼接到当前字符串的末尾。相比于 运算符append() 更加灵活允许指定拼接的范围甚至拼接部分字符串。
#include iostream
using namespace std;int main()
{string str1 Hello;string str2 World;// 使用 append() 拼接字符串str1.append(, ).append(str2).append(!);//从str1的“,”开始拼接到str2的“”cout Result: str1 endl; // 输出 Hello, World!return 0;
} 3.3.3 和 append() 的对比
1.可读性 - 运算符更加直观拼接字符串时看起来像数学加法代码简洁、易读尤其是在拼接多个字符串时。 - append() 在一些场景下也很方便尤其是需要逐步对同一个字符串进行修改时。
2 .性能 - 运算符会创建临时字符串对象。在连续使用 运算符时C 可能会创建多个临时对象特别是当涉及多个拼接操作时临时对象会占用额外的内存影响性能。 string result str1 str2 str3; // 可能生成多个临时对象
- append()则直接修改原字符串对象不会生成临时对象因此在多次拼接操作时性能更优。例如如果你需要不断往同一个字符串中追加内容append() 会比 更高效。
3. 灵活性 - 运算符简单直观但只支持完整字符串或字符的拼接不能直接拼接部分字符串。 - append() 则可以指定拼接字符串的子串或部分字符这在需要精细控制拼接内容时非常有用。 示例拼接部分字符串 string str1 Hello;string str2 World!!!;// 拼接 str2 的前 5 个字符str1.append(str2, 0, 5); // 拼接 Worldcout str1 endl; // 输出 HelloWorld
3.3.4append() 的其他用法
1. 拼接字符串
str1.append(str2); // 将 str2 拼接到 str1 后面2. 拼接子串
str1.append(str2, pos, len); // 将 str2 中从位置 pos 开始的 len 个字符拼接到 str13. 拼接字符数组
str1.append(World, 5); // 将 World 的前 5 个字符拼接到 str14. 拼接单个字符
str1.append(1, !); // 将字符 ! 拼接到 str1 后面
3.3.5总结
- 运算符简单易用适合少量字符串的拼接代码更简洁但在大量拼接操作中性能可能不如 append()。 - append()性能更优灵活性更强尤其适用于频繁拼接的场景可指定拼接部分字符串或字符。
在选择使用 还是 append() 时可以根据代码的可读性需求和性能要求做出权衡。如果拼接操作复杂或频繁append()是更好的选择。 3.4.查找、替换与截取
可以通过结合find()、substr()以及replace()函数实现字符串的查找、截取和替换。
3.4.1查找子串
如前面所述使用find()函数可以查找子串的位置。
#include iostream
using namespace std;int main() {string str Hello, World!;string toFind1 Worlda;string toFind2 World;size_t found1 str.find(toFind1);size_t found2 str.find(toFind2);if (found1 ! string::npos) {cout Found at position: found1 endl;}else {cout Not found endl;}if (found2 ! string::npos) {cout Found at position: found2 endl;}else {cout Not found endl;}return 0;
} 3.4.2截取字符串
使用substr()可以从查找到的位置开始截取指定长度的子串。
string substr (size_t pos 0, size_t len npos) const;
#include iostream
using namespace std;int main() {string str Hello, World!;size_t start 7; // 从第7个字符开始size_t length 5; // 截取5个字符string sub str.substr(start, length);cout 截取的字符串 sub endl;return 0;
} 3.4 3.替换字符串
使用replace()函数可以替换子串。replace()的使用方法是
string.replace(position, length, new_string);
其中position是替换的起始位置length是要替换的字符长度new_string是用于替换的字符串。
#include iostream
using namespace std;int main() {string str Hello, World!;string toReplace World;string replacement C;size_t found str.find(toReplace);if (found ! string::npos) {// 在位置 found 替换长度为 toReplace.length() 的子串str.replace(found, toReplace.length(), replacement);}cout 替换后的字符串 str endl;return 0;
} 3.5其他成员函数
string的成员函数太多我们在此就不详细说明了其他还有很多重要的成员函数我们简单介绍一下功能其它还需要小伙伴们自己深入学习。
3.5.1string 类对象的容量操作 3.5.2string类对象的访问及遍历操作 3.5.3string类对象的修改操作 3.5.4string类非成员函数 更多string的成员函数string - C Reference (cplusplus.com)
4.auto和范围for
1.auto
1 auto是c11引入的一种类型推导关键字允许编译器自动推导变量的类型它通过从变量的初始化表达式中推出具体类型。 auto 声明的变量必须由编译器在编译时期 推导而得 。 2用 auto 声明指针类型时用 auto 和 auto* 没有任何区别但用 auto 声明引用类型时则必须加 。 3当在同一行声明多个变量时这些变量必须是相同的类型否则编译器将会报错因为编译器实际 只对第一个类型进行推导然后用推导出来的类型定义其他变量 。 4auto 不能作为函数的参数可以做返回值但是建议谨慎使用 5auto 不能直接用来声明数组 6使用auto声明的变量声明时必须初始化。 #include iostream
using namespace std;int func1()
{return 10;
}
// 不能做参数
//void func2(auto a)
//{}// 可以做返回值但是建议谨慎使用
auto func3()
{return 3;
}
int main()
{int a 10;auto b a;auto c a;auto d func1();// 编译报错必须初始化//auto e;cout typeid(b).name() endl;intcout typeid(c).name() endl;charcout typeid(d).name() endl;intint x 10;auto y x;auto* z x;auto m x;cout typeid(x).name() endl;intcout typeid(y).name() endl;int*cout typeid(z).name() endl;int*cout typeid(m).name() endl;intauto aa 1, bb 2;// 编译报错error C3538: 在声明符列表中“auto”必须始终推导为同一类型//auto cc 3, dd 4.0;// 编译报错error C3318: “auto []”: 数组不能具有其中包含“auto”的元素类型//auto array[] { 4, 5, 6 };string s1(hellow world);//string::reverse_iterator rit s1.begin();auto rit s1.begin();while (rit ! s1.end()){cout *rit ;rit;}cout endl;return 0;
} 2.范围for
范围for是C11引入的一种简化的遍历容器元素的方式它极大地简化了传统的基于索引或迭代器的循环结构是代码更加简洁明了。
基本语法
for ( declaration : range_expression )
{// 循环体
}
declaration表明元素的声明可以是值、引用或常量引用。 range_expression表示一个可遍历的对象。 示例代码 int main()
{//数组三种遍历方式//下标[]迭代返回for//自动取容器的数据赋值给左边的值//自动自动判断结束//原理范围函数底层是迭代器for (auto ch : s1){cout ch ;}cout endl;//修改for (auto ch : s1){ch;}cout endl;//修改后的字符串for (auto ch : s1){cout ch ;}cout endl;int a[] { 1,2,3,4,5,6,7 };for (auto i : a){cout i ;}return 0;
} 5. string内存管理与性能
C 提供了标准库中的 std::string 类来简化字符串操作但其内存管理背后有许多细节值得注意。以下是内存管理与性能优化相关的几个关键点
1. std::string内存管理机制
1动态内存分配std::string是基于动态内存分配的。它会在需要时自动扩展容量。这意味着当字符串增长时可能会重新分配内存并复制已有的内容到新位置。这种操作代价较高特别是在频繁追加内容时。 2内存释放当 string 对象超出作用域或被销毁时其占用的内存会自动被释放。这是通过 C的自动内存管理机制RAIIResource Acquisition Is Initialization实现的。
void someFunction() {std::string localString Local string;// 做一些其他操作
} // localString 在这里被销毁其内存被释放。
3小字符串优化SSO, Small String Optimization为了避免频繁的动态分配开销许多现代的 C 实现采用了小字符串优化机制。当字符串很短通常少于 15-23 个字符取决于实现时std::string 会直接在栈上存储数据而不需要堆内存分配。
4容量管理std::string 通常会分配比实际需要的更多内存以避免频繁的重新分配。开发者可以通过 reserve() 函数预分配足够的内存空间避免多次分配。 2. 性能优化技巧
1预分配内存如果你知道字符串的大致大小可以使用 reserve() 函数预分配内存减少多次动态内存分配。例如在大量 push_back 操作前调用 reserve()。
2避免不必要的复制尽量避免在不必要的情况下拷贝 std::string 对象。可以通过使用引用如 const std::string或 C11 之后的右值引用来减少复制的开销。 void process(const std::string str); // 避免拷贝void process(std::string str); // 接收右值引用支持移动语义
3使用 std::move 优化C11 引入了移动语义可以通过 std::move() 转移字符串的所有权而不再拷贝数据。对于需要返回大字符串的函数移动语义可以显著提高性能。 std::string create_large_string() {std::string str large_string_data;return std::move(str); // 避免拷贝}
4拼接字符串时注意效率在拼接大量字符串时直接使用 可能导致多次内存分配和拷贝。为了提高效率可以考虑使用 std::ostringstream 或 std::string::append() 来减少不必要的开销。 std::ostringstream oss;oss Hello World!;std::string result oss.str();
3. 常见的性能陷阱
1频繁的小字符串拼接频繁的小字符串拼接会导致大量的内存分配和释放操作。可以通过 reserve() 或使用合适的数据结构如 std::ostringstream来减少开销。
2返回大字符串如果一个函数返回一个大字符串对象而没有使用移动语义C11 之前会导致不必要的拷贝。C11 之后编译器会优化返回值但显式使用 std::move 更好地表达意图。
3过度使用std::string的临时对象**在某些场景下频繁生成临时的 std::string 对象会导致性能下降。可以通过优化临时对象的使用或通过 std::string_view 来避免不必要的临时对象生成。
总结 C 的 std::string 提供了许多便捷的功能但在需要处理大量数据或高性能场景下注意其内存管理机制至关重要。通过合理使用预分配、避免不必要的拷贝、利用移动语义等技术开发者可以大幅度提高字符串操作的效率。
