【C++】C++标准模板库STL (一) string类的使用详解(2)

简介: 【C++】C++标准模板库STL (一) string类的使用详解(1)
  1. 我们再来看另一个扩容有关的函数:std::string::resize()函数

    此函数有两个版本,这两个版本构成函数重载。
    第一个参数是:调整后容量的大小,第二个参数是用什么字符来初始化新申请的空间中多余的没有被初始化部分空间,如果不给此参数,就默认用’\0’来初始化。
    如果第一个参数给的没有原来的大,那就是缩容,里面的字符串就变成了只保留原先字符串从0位置开始到n位置的字符串。
//std::string::resize()函数
#include<iostream>
#include<string>
using namespace std;
int main()
{
  string s1("hello world");
  cout << s1.size() << endl;
  cout << s1.capacity() << endl;
  s1.resize(30);  //提前把空间与字符数量扩容到50字节,但不初始化
          //由于string类内部的一些原因(如:对齐等原因),虽然向系统申请的的50字节,
          //但不一定就是50字节,总之系统申请的空间会 >= 你给的指定值
  cout << s1.size() << endl;
  cout << s1.capacity() << endl;
  return 0;
}

注意

  1. size()与length()方法底层实现原理完全相同,引入size()的原因是为了与其他容器的接口保持一致,一般情况下基本都是用size()。
  2. clear()只是将string中有效字符清空,不改变底层空间大小。
  3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个,不同的是当字符个数增多时:resize(n)用’\0’来填充多出的元素空间,resize(size_t n, char c)用字符c来填充多出的元素空间。注意:resize在改变元素个数时,如果是将元素个数增多,可能会改变底层容量的大小,如果是将元素个数减少,底层空间总大小不变。
  4. reserve(size_t n=0):为string预留空间,不改变有效元素个数,当reserve的参数小于string的底层空间总大小时,reserver不会改变容量大小。

3. string类对象的单个元素访问

//string 里面关于单个元素的访问
#include<iostream>
#include<string>
using namespace std;
int main()
{
  string s1("hello world!");
  char ch1 = s1[1];   //operator[]的运算符重载
  char ch2 = s1[2];   //operator[]的运算符重载
  char ch3 = s1.at(6);
  cout << ch1 << endl;
  cout << ch2 << endl;
  cout << ch3 << endl;
  cout << "---------------" << endl;
  cout << s1.front() << endl;
  cout << s1.back() << endl;
  cout << "---------------" << endl;
  //捕获异常
  try
  {
    s1.at(100);
  }
  catch (const std::exception& e)
  {
    //显示异常原因
    cout << e.what() << endl;
  }
  return 0;
}


4. string类对象的元素的遍历

对于string类对象的遍历有以下四种方式:

  • 第一种operator运算符重载我们已经学会了,我们可以利用如下代码进行遍历字符串:
#include<iostream>
#include<string>
using namespace std;
int main()
{
  string s1("hello world");
  for (int i = 0; i < s1.size(); ++i)
  {
    cout << s1[i];
  }
  cout << endl;
  return 0;
}

  • 第二种beginend就需要借助STL里面的迭代器了,iterator是迭代器类型,是一种自定义类型,现在你可以暂时把它理解为类似于指针的类型。
    想要遍历字符串我们就应该这样遍历:
#include<iostream>
#include<string>
using namespace std;
int main()
{
  string s1("hello world");
  string::iterator it = s1.begin();
  while (it != s1.end())
  {
    cout << *it;
    ++it;
  }
  cout << endl;
  return 0;
}

  • 第三种是rbeginrend 它们其实也是迭代器,不同的是,它们是反向迭代器,所以我们应该这样写才能遍历string对象。
#include<iostream>
#include<string>
using namespace std;
int main()
{
  string s1("hello world");
  string::reverse_iterator it = s1.rbegin();
  while (it != s1.rend())
  {
    cout << *it;
    ++it;
  }
  cout << endl;
  return 0;
}

  • 第三种是范围for,在前面的文章中我们也谈论过范围for,利用范围for,也可以遍历string类(范围for的底层实现就是迭代器)。
#include<iostream>
#include<string>
using namespace std;
int main()
{
  string s1("hello world");
  for (auto& e : s1)
  {
    cout << e;
  }
  cout << endl;
  return 0;
}


在前面已经简单的介绍了两种迭代器,(正向迭代器与反向迭代器)下面我们就把另外两种迭代器进行简单介绍补充:

  • const_iterator类型的迭代器
    此类型的迭代器,不能通过迭代器来改变指向的对象里的内容。
#include<iostream>
#include<string>
using namespace std;
int main()
{
  const string s1("hello world");
  string::const_iterator it = s1.begin();
  while (it != s1.end())
  {
    (*it)++;  //此行为非法!
    it++;   //此行为合法!
  }
  return 0;
}
  • const_reverse_iterator类型的迭代器
    此类型的迭代器是反向迭代器,并且不能通过迭代器来改变指向的对象里的内容。
#include<iostream>
#include<string>
using namespace std;
int main()
{
  const string s1("hello world");
  string::const_reverse_iterator it = s1.rbegin();
  while (it != s1.rend())
  {
    (*it)++;  //此行为非法!
    it++;   //此行为合法!
  }
  return 0;
}

5.string类对象的修改操作

#include<iostream>
#include<string>
using namespace std;
int main() 
{
  string s0("hello ");
  string s1("world");
  s0 += s1;
  cout << s0 << endl;
  s0 += " string";
  cout << s0 << endl;
  s0 += '!';
  cout << s0 << endl;
  return 0;
}

#include<iostream>
#include<string>
using namespace std;
int main()
{
  string s0("hello ");
  string s1("world");
  //substring (2)
  s0.append(s1, 0, 3);
  cout << s0 << endl;
  //buffer (4)  
  s0.append("string", 3);
  cout << s0 << endl;
  //fill (5)
  s0.append(5, '!');
  cout << s0 << endl;
  return 0;
}

#include<iostream>
#include<string>
using namespace std;
int main()
{
  string s0("hello ");
  s0.push_back('!');
  cout << s0 << endl;
}

代码与append()函数代码类似,不再演示


注意:

  1. 在string尾部追加字符时,s.push_back( c ) / s.append(1, c) / s += 'c’三种的实现方式差不多,一般
    情况下string类的+=操作用的比较多,+=操作不仅可以连接单个字符,还可以连接字符串。
  2. 对string操作时,如果能够大概预估到放多少字符,可以先通过reserve把空间预留好。

#include<iostream>
#include<string>
using namespace std;
int main()
{
  string s0("hello ");
  string s1("world");
  //string (1)  
  s0.insert(0, s1);
  cout << s0 << endl;
  //c-string (3)  
  s0.insert(3, "!!!!!!");
  cout << s0 << endl;
}

#include<iostream>
#include<string>
using namespace std;
int main()
{
  string s0("hello ");
  s0.erase(2, 2);
  cout << s0 << endl;
}

#include<iostream>
#include<string>
using namespace std;
int main()
{
  string s0("hello ");
  //c-string (3)
  s0.replace(2, 2,"!!!!!");
  cout << s0 << endl;
}

#include<iostream>
#include<string>
using namespace std;
int main()
{
  string s0("hello ");
  string s1("world");
  s0.swap(s1);
  cout << s0 << endl;
  cout << s1 << endl;
  return 0;
}

#include<iostream>
#include<string>
using namespace std;
int main()
{
  string s0("hello");
  s0.pop_back();
  cout << s0 << endl;
  return 0;
}


相关文章
|
9月前
|
缓存 算法 程序员
C++STL底层原理:探秘标准模板库的内部机制
🌟蒋星熠Jaxonic带你深入STL底层:从容器内存管理到红黑树、哈希表,剖析迭代器、算法与分配器核心机制,揭秘C++标准库的高效设计哲学与性能优化实践。
C++STL底层原理:探秘标准模板库的内部机制
|
编译器 C++ 容器
【c++11】c++11新特性(上)(列表初始化、右值引用和移动语义、类的新默认成员函数、lambda表达式)
C++11为C++带来了革命性变化,引入了列表初始化、右值引用、移动语义、类的新默认成员函数和lambda表达式等特性。列表初始化统一了对象初始化方式,initializer_list简化了容器多元素初始化;右值引用和移动语义优化了资源管理,减少拷贝开销;类新增移动构造和移动赋值函数提升性能;lambda表达式提供匿名函数对象,增强代码简洁性和灵活性。这些特性共同推动了现代C++编程的发展,提升了开发效率与程序性能。
578 12
|
人工智能 机器人 编译器
c++模板初阶----函数模板与类模板
class 类模板名private://类内成员声明class Apublic:A(T val):a(val){}private:T a;return 0;运行结果:注意:类模板中的成员函数若是放在类外定义时,需要加模板参数列表。return 0;
306 0
|
存储 编译器 程序员
c++的类(附含explicit关键字,友元,内部类)
本文介绍了C++中类的核心概念与用法,涵盖封装、继承、多态三大特性。重点讲解了类的定义(`class`与`struct`)、访问限定符(`private`、`public`、`protected`)、类的作用域及成员函数的声明与定义分离。同时深入探讨了类的大小计算、`this`指针、默认成员函数(构造函数、析构函数、拷贝构造、赋值重载)以及运算符重载等内容。 文章还详细分析了`explicit`关键字的作用、静态成员(变量与函数)、友元(友元函数与友元类)的概念及其使用场景,并简要介绍了内部类的特性。
484 0
|
编译器 C++
类和对象(下)C++
本内容主要讲解C++中的初始化列表、类型转换、静态成员、友元、内部类、匿名对象及对象拷贝时的编译器优化。初始化列表用于成员变量定义初始化,尤其对引用、const及无默认构造函数的类类型变量至关重要。类型转换中,`explicit`可禁用隐式转换。静态成员属类而非对象,受访问限定符约束。内部类是独立类,可增强封装性。匿名对象生命周期短,常用于临时场景。编译器会优化对象拷贝以提高效率。最后,鼓励大家通过重复练习提升技能!
|
9月前
|
编解码 Java 开发者
Java String类的关键方法总结
以上总结了Java `String` 类最常见和重要功能性方法。每种操作都对应着日常编程任务,并且理解每种操作如何影响及处理 `Strings` 对于任何使用 Java 的开发者来说都至关重要。
504 5
|
存储 编译器 C语言
关于string的‘\0‘与string,vector构造特点,反迭代器与迭代器类等的讨论
你真的了解string的'\0'么?你知道创建一个string a("abcddddddddddddddddddddddddd", 16);这样的string对象要创建多少个对象么?你知道string与vector进行扩容时进行了怎么的操作么?你知道怎么求Vector 最大 最小值 索引 位置么?
310 0
|
缓存 安全 Java
《从头开始学java,一天一个知识点》之:字符串处理:String类的核心API
🌱 **《字符串处理:String类的核心API》一分钟速通!** 本文快速介绍Java中String类的3个高频API:`substring`、`indexOf`和`split`,并通过代码示例展示其用法。重点提示:`substring`的结束索引不包含该位置,`split`支持正则表达式。进一步探讨了String不可变性的高效设计原理及企业级编码规范,如避免使用`new String()`、拼接时使用`StringBuilder`等。最后通过互动解密游戏帮助读者巩固知识。 (上一篇:《多维数组与常见操作》 | 下一篇预告:《输入与输出:Scanner与System类》)
422 11
课时14:Java数据类型划分(初见String类)
课时14介绍Java数据类型,重点初见String类。通过三个范例讲解:观察String型变量、&quot;+&quot;操作符的使用问题及转义字符的应用。String不是基本数据类型而是引用类型,但使用方式类似基本类型。课程涵盖字符串连接、数学运算与字符串混合使用时的注意事项以及常用转义字符的用法。
457 9
|
存储 JavaScript Java
课时44:String类对象两种实例化方式比较
本次课程的主要讨论了两种处理模式在Java程序中的应用,直接赋值和构造方法实例化。此外,还讨论了字符串池的概念,指出在Java程序的底层,DOM提供了专门的字符串池,用于存储和查找字符串。 1.直接赋值的对象化模式 2.字符串池的概念 3.构造方法实例化
311 1