c++STL之string类

最新推荐文章于 2025-11-05 22:45:01 发布
原创 最新推荐文章于 2025-11-05 22:45:01 发布 · 195 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文深入探讨了C++中String类的构造、容量操作、访问与遍历、修改方法等核心功能，解析了深拷贝与浅拷贝的区别，以及String类的模拟实现。

1.为何要学习string类
符合面向对象的思想，而且底层空间不需要用户自行控制，不会发生越界访问的情况
2.string类的接口
2.1string类对象的常见构造

函数名称 功能说明
string（） 构造空的string类对象，即空字符串
string（const char*s） 用C-string来构造string类对象
string（size_t n，char c） string类对象包含n个字符cstring（const string&s） 拷贝构造函数

void Test(){    
string s1;    
string s2("hello");    
string s3(s2);
}

2.2string类对象的容量操作

函数名称 功能说明
size 返回字符串有效字符长度
length 返回字符串有效字符长度
capacity 返回空间总大小
empty 检测字符串是否为空串，是返回true，否则返回false
clear 清空有效字符
reserve 扩大容量
resize 将有效元素个数扩大到n个，多出来的空间用字符c填充

//resize:将原有字符串扩增到n个//resize作用：改变string中有效字符的个数//将有效字符增多到n个，多出的位置需要使用ch进行填充，可能需要扩容//将有效字符减少到n个，只修改有效字符的个数，不会缩小空间
int main() {       
string s1("hello");       
for (auto e : s1) {              
cout << e;       
}       
cout << endl;       
cout << s1.size()<<endl;       
cout << s1.capacity()<<endl;       
s1.resize(10, '!');       
for (auto e : s1) {              
cout << e;       
}       
cout << endl;       
cout << s1.size() << endl;       
cout << s1.capacity()<<endl;       
s1.resize(80, '!');       
cout << s1.size() << endl;       
cout << s1.capacity()<<endl;       
s1.resize(1);       
for (auto e : s1) {              
cout << e;       
}       
cout << endl;       
cout << s1.size() << endl;       
cout << s1.capacity() << endl;       
system("pause");       
return 0;
}
//reserve:改变底层容量的大小，有效元素个数不会变
//扩大容量：n<=旧空间大小，不会扩容  n>旧空间大小，扩容
//缩小容量：n>15 不会缩小  n<=15 缩小容量
int main() {       
string s1("hello");       
cout << s1.size() << endl;       
cout << s1.capacity() << endl;       
s1.reserve(10);       
cout << s1.size() << endl;       
cout << s1.capacity() << endl;       
s1.reserve(60);       
cout << s1.size() << endl;       
cout << s1.capacity() << endl;       
s1.reserve(30);       
cout << s1.size() << endl;       
cout << s1.capacity() << endl;       
s1.reserve(6);      
cout << s1.size() << endl;       
cout << s1.capacity() << endl;       
system("pause");       
return 0;
}

注意：
1）.clear（）只是将string中有效字符清空，不改变底层空间的大小2）.resize在啊改变元素个数时，如果将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变3）.reserve为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间大小时，reserve不会改变容量大小

2.3string类对象的访问及遍历操作
string类的三种遍历方式

int main() {       
string s1;       
string s2("hello");       
string s3(10, '$');       
string s4(s3);       
cin >> s1;       
cout << s1 << endl;       
cout << s1.size() << endl;       
cout << s1.capacity() << endl;       
//范围for遍历       
for (auto e : s2) {              
cout << e;       }       
cout << endl;       
cout << s2.size()<<endl;       
cout << s2.capacity() << endl;       
//下标遍历       
for (size_t i = 0;i < s3.size();i++) {              
cout << s3[i];       
}       
cout << endl;       
cout << s3.size() << endl;       
cout << s3.capacity() << endl;       
//迭代器遍历       
//string::iterator it = s4.begin();c++98       
auto it = s4.begin();//c++11       
while (it != s4.end()) {              
cout << *it;              
it++;       
}       
cout << endl;       
cout << s4.size() << endl;       
cout << s4.capacity() << endl;       
s4.clear();       
cout << s4.size() << endl;       
cout << s4.capacity() << endl;       
system("pause");       
return 0;
}

string类的访问

char& operator[](size_t index) {              
assert(index < _size);              
return _str[index];       
}       
const char& operator[](size_t index)const {              assert(index < _size);              
return _str[index];       
}       
int main(){           
 string s1("hello");           
 s1[0]='a';           
return 0;             
}

2.4string 类对象的修改操作

函数名称 功能说明
push_back 在字符串后尾插字符c
append 在字符串后支架一个字符串
operator+= 在字符串后追加字符串
strc_str 返回c格式的字符串
find 从字符串pos位置开始往后找字符c，返回该字符在字 符串中的位置
rfind 从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置
substr 在str中从pos位置开始，截取n个字符，然后将其返回

int main() {       
string s1("asdfghj.jk.txt");       cout<<s1.substr(s1.rfind('.')+1)<<endl;       
system("pause");       
return 0;
}

string s1("hello");      
cout << s1 << endl;       
reverse(s1.begin(), s1.end());       
cout << s1 << endl;       
string s2("world");       
s1 += ' ';       
s1 += s2;       
s1 += "!!";       
cout << s1 << endl;       
s1.append("very", 3);       
cout << s1 << endl;       
s1.append(s2, 2, 2);       
cout << s1 << endl;       
s1.push_back('.');       
cout << s1 << endl;       
system("pause");       
return 0;
}

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

3.string类的模拟实现
3.1 浅拷贝浅拷贝也称位拷贝，编译器只是将对象中的值拷贝过来，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进行操作时，就会发生访问违规

int main(){
string s1("hello");
string s2(s1);//未自主定义拷贝构造函数，编译器会默认生成一个拷贝构造函数，即浅拷贝
return 0;
}

浅拷贝解决方式：采用深拷贝

3.2 深拷贝深拷贝：给每个对象独立分配资源，保证多个对象之间不会因共享资源而造成多次释放造成程序崩溃问题
如果一个类中涉及到资源的管理，其拷贝构造函数，赋值运算符重载以及析构函数必须显示给出，一般情况都是按照深拷贝的方式提供

3.2.1传统版写法的string类以及现代版写法的string类

class string {
public:
string(const char* str = " ") {
if (str == nullptr) {
   str = " ";
}
  _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*str = new char[strlen(s._str) + 1];
//  strcpy(str, s._str);
//  delete[]_str;
//  _str = str;
// }
// return *this;
//}
//简介版--现代版
string(const string& s)
:_str(nullptr)
{
  string strTemp(s._str);
swap(_str, strTemp._str);
}
 string& operator=(string s) {
swap(_str, s._str);
return *this;
}
~string() {
if (_str) {
   delete[]_str;
   _str = nullptr;
}
}
private:
char* _str;
};
int main() {
 std::string s1;
 std::string s2("hello");
//系统提供的默认拷贝构造函数： 会造成浅拷贝
 std::string s3(s2);
//系统提供的默认赋值运算符重载：1.浅拷贝 2.资源泄露
 std::string s4("world");
 s4 = s3;
return 0;
}

3.3写时拷贝

class string {
public:
string(const char* str = " ") {
if (str == nullptr) {
   str = " ";
}
  _str = new char[strlen(str) + 1];
strcpy(_str, str);
  _pCount = new int(1);
}
string(const string& s)
:_str(s._str)
,_pCount(s._pCount)
{
++(*_pCount);
}
 string& operator=(const string& s) {
if (this != &s) {
if (0 == -- * _pCount) {
    delete[]_str;
    delete[]_pCount;
}
   _str = s._str;
   _pCount = s._pCount;
++* _pCount;
}
return *this;
}
~string() {
if (_str&&0==--*_pCount) {
   delete[]_str;
   _str = nullptr;
   delete _pCount;
   _pCount = nullptr;
}
}
private:
char* _str;
int* _pCount;
};
int main() {
 std::string s1;
 std::string s2("hello");
 std::string s3(s2);
return 0;
}

模拟实现string类

#include<assert.h>
class string {
public:
 typedef char* iterator;
public:
 string(const char* str = " ") {
  if (str == nullptr) {
   str = " ";
  }
  _size = strlen(str);
  _str = new char[_size+ 1];
  strcpy(_str, str);
  _capacity = _size;
 }
 string(size_t n, char ch)
  :_str(new char[n + 1])
  , _size(n)
  , _capacity(n)
 {
  memset(_str, ch, _size);
  _str[_size] = '\0';
 }
 string(const string& s)
  :_size(s._size)
  , _capacity(s._size)
 {
  _str = new char[_size + 1];
  strcpy(_str, s._str);
 }
 string& operator=(const string& s) {
  if (this != &s) {
   char* str = new char[s._size + 1];
   strcpy(str, s._str);
   delete[]_str;
   _str = str;
   _size = s._size;
   _capacity = _size;
  }
  return *this;
 }
 ~string() {
  if (_str) {
   delete[]_str;
   _str = nullptr;
  }
 }
 char& operator[](size_t index) {
  assert(index < _size);
  return _str[index];
 }
 const char& operator[](size_t index)const {
  assert(index < _size);
  return _str[index];
 }
 size_t size()const {
  return _size;
 }
 size_t capacity()const {
  return _capacity;
 }
 void resize(size_t newsize, char ch=char()) {
  size_t oldsize = _size;
 if(newsize>oldsize) {
   if (newsize > _capacity) {
    reserve(_capacity);
   }
   memset(_str + _size, ch, newsize - oldsize);
  }
  _size = newsize;
  _str[_size] = '\0';
 }
 void reserve(size_t newcapacity) {
  if (newcapacity > _capacity) {
   char* str = new char[newcapacity + 1];
   strcpy(str, _str);
   delete[]_str;
   _str = str;
   _capacity = newcapacity;
  }
 }
 string& operator+=(char ch) {
  if (_size = _capacity) {
   reserve(2 * _capacity);
  }
  _str[_size++] = ch;
  _str[_size] = '\0';
  return *this;
 }
 string& operator+=(char* str) {
  size_t len = strlen(str);
  size_t newsize = size() + len;
  if (capacity() < newsize) {
   reserve(newsize);
  }
  strcat(_str, str);
  _size = newsize;
  return *this;
 }
 string& operator+=(const string& s) {
  *this += s._str;
  return *this;
 }
 void swap(string& s) {
  std::swap(_str, s._str);
  std::swap(_size, s._size);
  std::swap(_capacity, s._capacity);
 }
 const char* c_str()const {
  return _str;
 }
 size_t find(char ch) {
  for (size_t i = 0;i < size();i++) {
   if (_str[i] == ch) {
    return i;
   }
  }
  return -1;
 }
 iterator begin() {
  return _str;
 }
 iterator end() {
  return _str + _size;
 }
private:
 char* _str;
 size_t _capacity;
 size_t _size;
};
int main() {
 std::string s1;
 std::string s2("hello");
 std::string s3(10, '!');
 std::string s4(s2);
 s3 = s4;
 s4[0] = 'a';
 s4.swap(s2);
 return 0;
}
c++项目，制作GIF动态图
Lchilde的博客
08-29 6661
项目目录项目背景项目简介项目可行性分析第三方库以及项目工具介绍项目总体设计流程图项目详细设计项目测试项目结果项目源代码 项目背景 在很多时候，人们所说的一句话在不同的的环境和状态下回有不同的含义，但是，我们有时候并不能表达出的信息并不是自己想要的结果，尤其是在我们在虚拟网络上聊天时，仅仅依靠文字我们并不能很好地看出对方的情况，而随着互联网的不断发展与进步，有时候一个简简单单的表情也许能比很长一段文字能更好地表现出来对方想让我们知道的信息，这样就更加方便彼此之间的交流。在我们上网聊天时，“一言不合就斗图”的情
【C++STL详解 —— string类】
jokr_的博客
03-06 2623
string s();//构造一个空字符串//复制s所指向的字符序列//复制s所指向的字符序列的前n个字符//生成n个c字符的字符串//生成str的复制//复制str中字符位置pos开始并且跨越len个字符的部分。
【C++】简述STL——string类的使用
f_2789889770的博客
09-05 1414
string类的使用
C++STL——String类
最新发布
达瓦打不过来学习
11-05 1578
C++String类的常用接口
【C++入门到精通】C++入门 —— string类(STL)
Yawesh的博客
08-04 1329
本文以STL（Standard Template Library）和string类为主题，介绍了STL的概念、内容和使用前提。针对string类，详细探讨了它的定义、特点和常见操作，包括构造和初始化、字符串大小和容量、字符访问和修改、字符串连接和拼接、子串操作、字符串比较、字符串修改、获取字符的ASCII码，以及字符串大小写转换等。通过这些内容，读者将了解STL和string类的基本概念并掌握其常用操作，从而更有效地处理和操作字符串。
LeetCode 486 预测赢家
Lchilde的博客
09-01 713
题目描述： 给定一个表示分数的非负整数数组。 玩家 1 从数组任意一端拿取一个分数，随后玩家 2 继续从剩余数组任意一端拿取分数，然后玩家 1 拿，…… 。每次一个玩家只能拿取一个分数，分数被拿取之后不再可取。直到没有剩余分数可取时游戏结束。最终获得分数总和最多的玩家获胜。 给定一个表示分数的数组，预测玩家1是否会成为赢家。你可以假设每个玩家的玩法都会使他的分数最大化。 示例 1： 输入：[1, 5, 2] 输出：False 解释：一开始，玩家1可以从1和2中进行选择。 如果他选择 2（或者 1 ），那么玩
类与对象-----中篇
Lchilde的博客
07-31 582
类与对象-----中篇 1：类的6个默认成员函数 2：构造函数 1）：概念 一个特殊的成员函数，名字与类名相同，创建类类型对象的时候，由编译器自己调用，在对象的生命周期中且调用一次，以保证每个数据成员都有一个合适的初始值 2）：构造函数的特性： 函数名与类名相同 没有返回值 有初始化列表（可以不用） 对象实例化时编译器自动调用对应的构造函数 构造函数可以重载 test.h class Dat...
c++之AVL树
Lchilde的博客
10-29 539
AVL树及其基本操作 1.AVL树概念 二叉搜索树岁可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于顺序表中搜元素，效率低下。AVL树是一颗平衡二叉搜索树，在AVL树中，任何结点的两个子树的高度差的绝对值不超过1（需对树中的结点进行调整），即可降低树的高度，从而减少平均搜索长度。 2.AVL树的性质 它的左右子树都是AVL树 左右子树的高度差（简称平衡因子）的绝...
c++面经2
Lchilde的博客
10-19 495
11.什么是inline内联函数，使用内联函数有什么优缺点，什么是宏，宏和inline函数有什么区别 内联函数是用inline关键字修饰的，定义在类体外的成员函数，内联函数会在函数编译阶段进行展开，少了函数调用的开销以提高代码运行的效率 内联函数的优点： 它通过避免函数调用开销来加速程序的运行 当函数调用发生时，它可以节省堆栈上变量push/pop的开销 它节省了函数调用返回的开销 内联函数的缺点： 由于代码扩展，它增加了可执行文件的大小 可能到时内存崩溃 宏的优缺点：宏包括宏常量和宏函数 宏常量优点：一改
红黑树的概念及其基本操作
Lchilde的博客
10-30 484
1.红黑树的概念 红黑树，是一种二叉搜索树，但在每个节点上增加一个存储位表示结点的颜色，可以是Red或Black，通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而是接近平衡的 2.红黑树的性质 每个节点不是红色就是黑色 根结点是黑色的 如果一个节点是红色的，则它的两个孩子都是黑色的 每条路径上的黑色结点数目相同 每个叶子结点都是黑色的（这里...
c++之继承
Lchilde的博客
10-19 417
1.子类对象可以直接赋值给父类对象 #include<iostream> using namespace std; class Parent { private: int a; public: }; class Child :public Parent { private: int b; public: }; int main() { Child c; Parent p; p = c; //子类对象可以直接赋值给父类对象 return
c++内联函数
Lchilde的博客
12-06 388
内联函数 1.什么是内联函数 在C语言中，如果一些函数被频繁调用，不断的有函数入栈，即函数栈，会造成栈空间和栈内存的大量消耗，为了解决这一问题，特别引入了inline修饰符，表示为内联函数。 2.为什么要引入内联函数 引入内联函数是为了解决程序中函数调用的效率问题，因为函数的调用有一定时间和空间方面的开销，将会影响其效率，特别是对于一些函数代码不是很大， 但又频繁调用的函数来讲，解决其效率更加重要...
C++之多态
Lchilde的博客
10-02 318
1.多态的概念 同一件事物，在不同场景下表现出的不同的状态 举例：买票行为，学生半价，普通人全价，军人优先 分类：静态多态和动态多态 静态多态：编译器在编译时确定具体调用哪个函数。体现：函数重载，模板动态多态：编译时无违法确定调用哪个函数，只有在代码运行时才知道具体应该调用哪个函数 体现：虚函数+重写 动态多态的实现 2.1C++中实现多态的条件>>在继承体系中，基类中必须有虚...
c++之二叉搜索树
Lchilde的博客
10-26 302
二叉搜索树及其基本操作 1.二叉搜索树的概念 二叉搜索树又称为二叉排序树，它或者是一颗空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则其左子树上所有节点的值都小于其根结点的值 若它的右子树不为空，则其右子树上所有节点的值都大于其根结点的值 它的左右子树也都是二叉搜索树 2.二叉搜索树的基本操作 2.1二叉搜索树的查找 原理： 若根结点不为空： 如果根结点key==查找key 返回t...
c++之异常
Lchilde的博客
10-14 269
1.什么是异常 异常一般指的是程序运行期发生的非正常情况，异常一般是不可预测的，如：内存不足：打开文件失败，范围溢出等 异常处理的核心思想是，把功能模块代码与系统中可能出现错误的处理代码分离开来，以此来达到使我们的代码组织起来更美观，逻辑更清晰，并且从根本上上来提高我们软件系统长时间稳定运行的可靠性。 2.C语言处理异常的传统方法 2.1基于goto语句的异常处理 goto语句有非常多的...
c++面经1
Lchilde的博客
10-17 265
1.数组和链表的区别 二者都属于一种数据结构 从逻辑上看： 1）：数组是一种线性表数据结构。他用一组连续的内存空间，来存储一组具有想同类型的数据，最大的特点是支持随机访问，但数组必须事先定义固定的长度（元素个数），不能适应数据动态增加的情况，当数据增加时，可能超过原先定义的元素个数；当数据减少时，造成内存浪费；数组可以根据下标直接存取 2）：链表是一种物理存储单元上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的，链表由一系列节点组成，链表动态地进行存储分配，可以适应数据动态地增
c++之初识模板
Lchilde的博客
09-02 254
初识模板 模板：函数模板和类模板 一：函数模板 1：概念 函数模板代表了一个家族，在使用时被参数化，根据实参类型产生函数的特定类型模板。 2：函数模板格式： template<typename T1,typename T2,...,typename Tn> 返回值类型 函数名（参数列表）{} template<typename T> void Swap(T& ...
c/c++内存分配方式
Lchilde的博客
08-24 243
数据段：数据段通常是指用来存放程序中已初始化的全局变量和静态变量的一块内存区域。数据段属于静态内存分配，可以分为只读数据段和读写数据段。 字符串常量等，但一般都是放在只读数据段中 。 代码段：代码段通常是指用来存放程序执行代码的一块内存区域。这部分区域的大小在程序运行前就已经确定，并且内存区域通常属于只读, 某些架构也允许代码段为可写，即允许修改程序。在代码段中，也有可能包含一些只读的常数变量，例如字符串常量等，但一般都是放在只读数据段中 。 栈区：由系统自动分配，当函数执行结束时由系统自动释放。存放局部.
LeetCode 349
Lchilde的博客
10-17 218
LeetCode:349 https://leetcode-cn.com/problems/intersection-of-two-arrays/ 题目 给定两个数组，编写一个函数来计算它们的交集。 示例 1： 输入：nums1 = [1,2,2,1], nums2 = [2,2] 输出：[2] 示例 2： 输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4] 输出：[9,4] 说明： 输出结果中的每个元素一定是唯一的。 我们可以不考虑输出结果的顺序。 题解： class So
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值