[ C++ ] STL---string类的使用指南

最新推荐文章于 2024-08-18 21:07:18 发布

小呆瓜历险记

最新推荐文章于 2024-08-18 21:07:18 发布

阅读量937

点赞数 32

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/m0_58963318/article/details/136712380

版权

编辑 const迭代器const_iterator

反向迭代器reverse_iterator

范围for遍历

string类对象的修改操作

string类非成员函数

前言：

STL（standard template libaray-标准模板库）：c++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。

STL的六大组件

容器：各种数据结构，比如顺序表、链表、双端队列、集合、映射等，主要用于存放数据；

算法：主要用于操作容器中数据的模版函数，如 sort(插入排序，快速排序，堆排序)；

迭代器：提供遍历容器中数据的方法，迭代器是一种将operator*、operator->、operator++等指针的相关操作赋予重载的类模版；

仿函数：仿函数是重载了operator()运算符的一个类/结构体，使其可以像函数一样被调用；

适配器：专门用于修饰现有类的接口，提供一种新的接口；

空间配置器：负责空间的配置与管理，配置器是一个实现了动态空间配置，空间管理、空间释放的类模版；

string类简介

string是由类模板basic_string实例化出来的一个类，string本质为动态增长的字符数组；

string类的官方文档：string - C++ Reference

注：使用string类时，必须包含头文件#include<string>以及使用using namespace std；

string类的常用接口

string类对象的构造函数


string();//无参构造(重点掌握)

string (const string& str);//拷贝构造（重点掌握）

string (const string& str, size_t pos, size_t len = npos);
//string类对象str的第pos个位置开始，向后拷贝len个字符初始化对象

string (const char* s);//通过常量字符串s初始化对象（重点掌握）

string (const char* s, size_t n);//字符串s的前n个字符初始化对象

string (size_t n, char c); //n个字符c初始化对象

template <class InputIterator> //迭代器区间构造
  string  (InputIterator first, InputIterator last);

string::npos为静态成员变量，表示size_t的最大值；
该值表示"直到字符串末尾"，作为返回值它通常被用作表明没有匹配；

string类对象的赋值运算符重载

string& operator= (const string& str);//支持string类对象赋值

string& operator= (const char* s);//支持常量字符串赋值

string& operator= (char c);//支持单个字符赋值

string类对象的容量操作

size()与length()底层实现原理相同，皆返回字符串有效字符的长度(不包含'\0')，引入size()原因是为了与其他容器接口保持一致，一般情况下皆使用size()；

capacity()返回空间总大小，capacity()与size()大小可能相同，也有可能比size()更大；

empty()检测字符串是否为空串，是返回true，否则返回false；

clear()将string类对象中的有效字符清空，不改变底层空间的大小；

reserve()为字符串预留空间，当reserve()的参数大于string的底层空间总大小时，reserve()只会改变capacity()的大小，但是具体扩容的容量取决于编译器，当reserve()的参数小于string的底层空间总大小时，reserve()什么都不做；

扩容机制检测

vs平台下移1.5倍进行扩容，linux平台下以2倍进行扩容；

n>capacity()时，扩容+尾插（指明字符c，尾插字符c，不指明字符，插入'\0'）
size()<n<capacity()时，有效数据的个数size()改变为n，容量capacity()不确定，可能会扩容，可能不变；
n<size()时，容量capacity()不变，有效数据的个数size()改变为n，删除数据，保留前n个；

string类对象的访问与遍历

[ ] + 下标遍历

[ ]运算符重载返回字符串中下标为pos位置的字符的引用，重载[ ]运算符意味着string类对象可以像访问数组一样利用下标访问元素；

  char& operator[] (size_t pos); //可读可写
const char& operator[] (size_t pos) const //只读

若只实现const char& operator[] (size_t pos) const，则const对象可以调用此const成员函数，非const对象也可以调用此const成员函数，因为权限可以缩小；但是非const对象无法修改返回值，诞生函数重载形式 char& operator[] (size_t pos)；

迭代器遍历

普通迭代器iterator

//string的底层物理结构
class string
{
public:
    //迭代器的本质为重命名过的指针变量
	typedef char* iterator;
	//成员函数
private:
	char* _str;
	size_t _size;
	size_t _capacity;
};

begin()函数返回string类对象的首位置；

end()函数返回string类对象的最后一个有效数据的下一个位置；

const迭代器const_iterator

const_iterator begin() const;

const_iterator end() const;

const_iterator 本质为保护迭代器指向的内容不允许被修改；
const iterator 本质为保护迭代器本身不允许被修改；

反向迭代器reverse_iterator

范围for遍历

string类对象的修改操作

string类的修改接口设计的十分冗余，其中可以使用 operator += 替代append()与push_back()，因此只需重点学习 operator +=；

int main()
{
	string tmp("hello Linux!");
	string s1;
	// 在pos位置插入string类字符串
	// string& insert (size_t pos, const string& str);
	s1.insert(0, tmp);
	cout << s1 << endl;
	// 在pos位置插入str的子串（subpos位置开始的sublen个字符）
	// string& insert (size_t pos, const string& str, size_t subpos, size_t sublen);
	s1.insert(7, tmp, 0, 6);
	cout << s1 << endl;
	// 在pos位置插入字符指针指向的字符串
	// string& insert (size_t pos, constchar* s);
	s1.insert(2, "xxx");
	cout << s1 << endl;
	// 在pos位置插入字符指针指向的字符串的前n个字符
	// string& insert (size_t pos, const char* s, size_t n);
	s1.insert(7, "hello naiths", 8);
	cout << s1 << endl;
	// 在pos位置插入n个c字符
	// string& insert (size_t pos, size_t n, char c);
	s1.insert(0, 5, 'y');
	cout << s1 << endl;
	// 指定迭代器的位置插入n个字符c
	// void insert (iterator p, size_t n, char c);
	string::iterator it = s1.begin() + 10;
	s1.insert(it, 10, 'z');
	cout << s1 << endl;
	// 指定迭代器的位置插入字符c
	// iterator insert (iterator p, char c);
	s1.insert(s1.begin(), 'A');
	cout << s1 << endl;
	// 指定p位置插入迭代器区间的字符
	// template <class InputIterator>
	// void insert(iterator p, InputIterator first, InputIterator last);
	s1.insert(s1.begin(), tmp.begin() + 3, tmp.begin() + 8);
	cout << s1 << endl;
	// 删除pos位置开始的len个字符
	// string& erase (size_t pos = 0, size_t len = npos);
	s1.erase(2, 5);
	cout << s1 << endl;
	// 删除迭代器位置的那个字符
	// iterator erase (iterator p);
	s1.erase(s1.begin());
	cout << s1 << endl;
	// 删除迭代器区间的字符
	// iterator erase (iterator first, iterator last);
	s1.erase(s1.begin() + 2, s1.begin() + 5);
	cout << s1 << endl;
    return 0;
}

//算法库algorithm
template <class T> 
void swap ( T& a, T& b )
{
  T c(a); 
  a = b; 
  b = c;
}

void swap(string& s)
{
	std::swap(_str, s._str);
	std::swap(_capacity, s._capacity);
	std::swap(_size, s._size);
}

算法库提供了swap()函数，为什么string类要单独提供一个呢？

使用string类中的swap只需要拷贝一个字符指针类型的数据，而使用算法库中的swap()需要拷贝整个string()类对象，消耗大；

c_str()返回string类中存储字符串的字符指针，cpp需要兼容c语言，因为c语言没有string类，

设计c_str()将string类转化为常量字符串；

find() 正向查找

//从string类对象的pos位置开始,查找另一个string类对象str，
//若查找到，则返回第一次匹配的第一个字符的下标,若查找不到，返回string::npos
size_t find (const string& str, size_t pos = 0) const;

//从string类对象的pos位置开始,查找常量字符串s
//若查找到，则返回第一次匹配的第一个字符的下标,若查找不到，返回string::npos
size_t find (const char* s, size_t pos = 0) const;

//从string类对象的pos位置开始,查找常量字符串s的前n个字符组成的子字符串
//若查找到，则返回第一次匹配的第一个字符的下标,若查找不到，返回string::npos
size_t find (const char* s, size_t pos, size_t n) const;

//从string类对象的pos位置开始,查找字符c
//若查找到，则返回第一次匹配的第一个字符的下标,若查找不到，返回string::npos
size_t find (char c, size_t pos = 0) const