C++——string的了解和使用

qing_040603 2024-09-30 17:35:11 阅读 76

目录

引言

为什么要学习string

1.C语言中的字符

2.C++中的字符串

auto和范围for

1.auto

1.1 auto的介绍

1.2 注意事项

2.范围for

标准库中的string类

1.string类的迭代器

1.1 begin()与end()函数

1.2 rbegin()与rend()函数

2.string类的初始化和销毁

3.string类的容量操作

3.1 有效长度和容量大小

(1)使用示例

(2)扩容机制

3.2 有效长度和扩容操作

(1)reserve函数

(2)resize函数

(3)clear函数

4.string类的访问操作

4.1 operator[]函数

4.2 at函数

4.3 front 和 back 函数

5.string类的修改操作

5.1 字符串增加操作

5.2 字符串替换操作

5.3 字符串删除操作

5.4 字符串交换操作

5.5 字符串其他操作

结束语


引言

为了简化字符串的处理,C++标准库引入了string类。string类是一个模板类,专门用于表示和操作字符串。今天我们来学习一下string。

为什么要学习string

1.C语言中的字符串

C语言中,字符串是以 '\0' 结尾的一些字符的集合,为了操作方便,C标准库中提供了一些str系列的库函数,但是这些库函数与字符串是分离开的,不太符合OOP的思想,而且底层空间需要用户自己管理,稍不留神可能还会越界访问。 

2.C++中的字符串

为了简化字符串的处理,C++标准库引入了string类。string类是一个模板类,专门用于表示和操作字符串。它不仅封装了字符串的底层细节,如内存分配和释放,还提供了一套丰富而易于使用的成员函数,用于执行各种字符串操作,如拼接、比较、查找、替换、插入和删除等。

下面是一个string的简单使用:

<code>int main()

{

string s1;

string s2("hello world");

string s3(s2);

cout << s1 << endl;

cout << s2 << endl;

cout << s3 << endl;

string s4(s2, 6, 15);

cout << s4 << endl;

string s5(s2, 6);

cout << s5 << endl;

string s6("hello world", 5);

cout << s6 << endl;

string s7(10, 'x');

cout << s7 << endl;

return 0;

}

输出结果为:

下面我们来详细学习一下。

auto和范围for

在学习string类之前,我们先来学习一下auto和范围for,方便我们后面的学习。

1.auto

1.1 auto的介绍

auto 关键字用于自动类型推导。编译器会自动根据初始化表达式来推断变量的类型。这避免了在声明变量时显式指定类型,特别是当类型名称很长或复杂时,auto可以使代码更加简洁。

<code>int main()

{

int i = 0, & ri = i;

auto a = i;//a为int型变量

auto a1 = ri;//a1为int型变量

auto p = &i;// &i 是一个普通int指针,p是一个整型指针int *

auto p1 = &ri;//同上

return 0;

}

1.2 注意事项

(1)使用 auto 声明的变量必须有初始化表达式,否则编译器无法推导其类型

因此,不能这样子:

auto x;

(2)对于模板实例化、复杂表达式等,auto 能够推导出相应的复杂类型

std::vector<int> vec = {1, 2, 3};

auto v = vec; // v 的类型是 std::vector<int>

auto result = Fun(x, y); // result 的类型由函数返回类型决定

(3)auto也有一些缺陷,例如它降低了代码的可读性,导致我们无法一眼看出变量的类型(像上面的代码,我们不能直观的看出 v 的类型)。

(4)用 auto 声明指针类型时,用 auto 和 auto* 没有任何区别,只是 auto* 必须是指针。但是用 auto 声明引用类型时,必须加 & 。

int x = 1;

auto a = &x;

auto* b = &x;

auto& c = x;

2.范围for

范围for(也称为基于范围的for循环)是C++11引入的一种新的循环语法,用于简化对容器(如vector、list、map等)、数组或初始化列表中的元素进行遍历的操作。这种循环语法使得代码更加简洁、清晰,提高了代码的可读性和可维护性。

范围for循环的基本语法如下:

for (元素类型 变量名 : 容器或数组名)

{

// 循环体

}

来看个简单的例子:

int main()

{

int arr[] = { 1,2,3,4,5 };

for (auto i : arr)

{

cout << i << endl;

}

return 0;

}

输出结果为:

由于 i 是临时变量,不能直接修改数组元素的值,我们需要使用引用 & 。

<code>int main()

{

int arr[] = { 1, 2, 3, 4, 5 };

for (auto& i : arr) // 注意这里使用了引用&

{

i *= 2; // 修改数组元素的值

cout << i << endl;

}

return 0;

}

输出结果为:

标准库中的string类

我们可以使用以下文档来辅助我们学习string:

string类的接口详细介绍

1.string类的迭代器

迭代器(Iterator)在C++中是一种抽象化的概念,它提供了一种统一的方法来遍历容器中的元素,而无需了解容器内部的具体实现细节。

迭代器在行为上类似于指针,但它不仅仅局限于原始指针的功能。迭代器封装了对容器元素的访问,并且根据容器的不同,迭代器可以有不同的实现。然而,从用户的角度来看,迭代器提供了一种统一的接口来遍历容器,这使得代码更加通用和可移植。

当我们使用迭代器时,确实可以将其当作指针来使用,但需要注意的是,迭代器并不是指针的替代品,而是对容器遍历操作的一种抽象。

在 string 类中,我们就可以通过迭代器来访问其具体元素,并且也为我们提供了相应的调用函数。

1.1 begin()与end()函数

迭代器提供了 begin() 和 end() 成员函数,用于获取遍历的起始位置和结束位置。

begin()与end()函数的使用方法具体如下:

begin():

函数声明:

对于非const的std::string对象,iterator begin(); 返回指向第一个字符的iterator。

对于const的std::string对象,const_iterator begin() const; 返回指向第一个字符的const_iterator。

作用:返回指向字符串第一个字符的迭代器。

返回值:

对于非const对象,返回iterator,允许通过迭代器修改字符串中的字符。

对于const对象,返回const_iterator,仅允许通过迭代器读取字符串中的字符,不允许修改。

end() :

函数声明(对于std::string):

iterator end(); 返回指向字符串末尾(即最后一个字符之后的位置)的iterator。

const_iterator end() const; 对于const对象,返回指向字符串末尾的const_iterator。

作用:返回指向字符串末尾(即最后一个字符之后的位置)的迭代器。这个迭代器通常用作遍历循环的结束条件。

我们来尝试使用一下这俩玩意,代码如下:

<code>int main()

{

string s1("hello world");

cout << s1 << endl;

string::iterator it = s1.begin();

while (it != s1.end())

{

cout << *it << " ";

++it;

}

cout << endl;

return 0;

}

输出结果为:

<code>int main()

{

const string s2("hello world");

cout << s2 << endl;

// const迭代器,用于遍历const字符串,不能改变字符串中的值

string::const_iterator it = s2.begin();

while (it != s2.end())

{

cout << *it << " ";

++it;

}

cout << endl;

return 0;

}

输出结果为:

1.2 rbegin()与rend()函数

rbegin:

函数声明(对于 std::string 和其他支持反向迭代器的容器): 

reverse_iterator rbegin();    

const_reverse_iterator rbegin() const;

作用

返回指向容器(如 std::string)中最后一个元素(即反向遍历的起始位置)的反向迭代器。这使得可以反向遍历容器中的元素。

返回值

对于非 const 容器,返回 reverse_iterator。对于 const 容器,返回const_reverse_iterator。

rend:

函数声明(对于 std::string 和其他支持反向迭代器的容器):

reverse_iterator rend();

const_reverse_iterator rend() const;

作用:

返回指向容器(如 std::string)中第一个元素前面一个位置的反向迭代器。这实际上是反向遍历的结束位置,它不指向任何有效元素,而是作为反向遍历的结束标志。

返回值

对于非 const 容器,返回 reverse_iterator。 对于 const 容器,返回 const_reverse_iterator。

来简单的使用一下:

<code>int main()

{

string s1("hello world");

cout << s1 << endl;

string::reverse_iterator rit = s1.rbegin();

while (rit != s1.rend())

{

cout << *rit << " ";

++rit;

}

cout << endl;

return 0;

}

输出结果为:

<code>int main()

{

const string s2("hello world");

cout << s2 << endl;

string::const_reverse_iterator rit = s2.rbegin();

while (rit != s2.rend())

{

cout << *rit << " ";

++rit;

}

cout << endl;

return 0;

}

输出结果为:

2.string类的初始化和销毁

由于 string 是一个类,因此我们在初始化时肯定会调用其构造函数初始化。

(1)默认构造函数:创建一个空的字符串对象。

(2)拷贝构造函数:创建一个新的字符串对象,它是另一个字符串对象的副本。这允许通过现有的字符串来初始化新字符串。

(3)子字符串构造函数:创建一个新的字符串对象,它是另一个字符串对象从pos位置开始、长度为len的子串。如果len是npos(默认情况),则子串从pos开始直到原字符串的末尾。

(4)从C字符串构造函数:使用C风格的字符串(以空字符'\0'结尾的字符数组)来初始化字符串对象。

(5)从C字符串的前n个字符构造函数:使用C风格的字符串的前n个字符来初始化字符串对象。

(6)填充构造函数:创建一个新的字符串对象,其中包含n个重复的字符c。

(7)范围构造函数:这是一个模板构造函数,允许使用任何输入迭代器对(如指针、std::vector的迭代器等)来初始化字符串。它复制从first到last(不包括last)范围内的所有元素到新的字符串对象中。

(1)字符串赋值:这个重载版本允许将一个 std::string 对象的内容赋值给另一个 std::string 对象。这是通过复制 str 的内容到当前对象来实现的。注意,这里使用了引用传递(const string&),这有助于避免不必要的复制,提高效率。

(2)C风格字符串赋值:这个重载版本允许将一个C风格字符串(即以空字符('\0')结尾的字符数组)赋值给 std::string 对象。std::string 会复制 s 指向的C风格字符串的内容(不包括结尾的空字符),并存储在自己的内部表示中。

(3)单个字符赋值:这个重载版本允许你将一个单独的字符赋值给 std::string 对象。这通常会导致 std::string 对象的内容被替换为仅包含该字符的一个新字符串。

下面是代码演示:

<code>int main()

{

// (1)默认构造函数。

string s1;

s1 = "hello world!";

//(2)拷贝构造函数

string s2(s1);

//(3)子字符串构造函数

string s3(s2, 1, 7);

//(4)从C字符串构造函数

string s4("hello world!");

//(5)从C字符串的前n个字符构造函数

string s5("hello world!", 5);

//(6)填充构造函数

string s6(7, 'a');

//(7)范围构造函数

string s7(s1.begin(), s1.end());

// 赋值运算符重载初始化

string s8 = "hello world!";

cout << s1 << endl;

cout << s2 << endl;

cout << s3 << endl;

cout << s4 << endl;

cout << s5 << endl;

cout << s6 << endl;

cout << s7 << endl;

cout << s8 << endl;

return 0;

}

输出结果为:

在C++中,std::string 是一个类模板的实例化,代表了一个可变的字符序列。由于它是一个类,当 std::string 对象的生命周期结束时(即离开其作用域),编译器会自动调用该对象的析构函数来清理其分配的资源。

3.string类的容量操作

在C++中,std::string 类提供了多种与容量(capacity)相关的操作,这些操作允许你查看或修改字符串的内部存储空间的大小。

以下是比较常见的容量操作:

函数名称 功能
size 返回字符串的有效长度
length 返回字符串的有效长度
capacity 返回字符串的容量大小
max size 返回字符串的最大长度
clear 清空字符串
empty 检查是否为空串,是则返回true,否则返回false
reserve 请求改变字符串的容量
resize 重新设置有效字符的数量,超过原来有效长度则用c字符填充
3.1 有效长度和容量大小
(1)使用示例

std::string 的容量(capacity)并不总是等于其当前长度(size)。容量是字符串为了存储更多字符而预先分配的内存量,而长度是当前存储在字符串中的字符数。

我们通过代码来验证一下:

<code>int main()

{

string s("hello world");

cout << s.size() << endl;//有效长度

cout << s.length() << endl;//有效长度

cout << s.capacity() << endl;//容量大小

cout << s.max_size() << endl;//最大大小

return 0;

}

输出结果为:

其中有效长度 size 以及容量大小 capacity 不包括\0。而 max_size 返回字符串最大容量,不同平台下大小可能不一样。

还有一个判空函数empty(),下面是一个简单的使用示例:

<code>int main()

{

string s1("");

string s2("hello world");

if (s1.empty())

{

cout << "s1为空串" << endl;

}

else

{

cout << "s1不为空串" << endl;

}

if (s2.empty())

{

cout << "s2为空串" << endl;

}

else

{

cout << "s2不为空串" << endl;

}

return 0;

}

输出结果为:

(2)扩容机制

我们接下来研究一下string的扩容机制:

来看看这段代码:

<code>int main()

{

string s;

size_t sz = s.capacity();

cout << "making s grow:\n";

for (int i = 0; i < 100; ++i)

{

s.push_back('c');

if (sz != s.capacity())

{

sz = s.capacity();

cout << "capacity changed: " << sz << '\n';

}

}

return 0;

}

输出结果为:

我们可以看到,在vs2022中,string大致以一点五倍进行扩容处理。我们来看看在g++编译器的运行结果:

我们可以看到,在这里是二倍扩容处理。

3.2 有效长度和扩容操作

我们先来学习两个可以改变容量的函数 reserve,resize。

(1)reserve函数

reserve函数用于请求改变字符串的容量(capacity),即为其内部存储空间分配至少能容纳n个字符的空间。

来测试一下:

<code>int main()

{

string s1;

s1.reserve(50);

cout << s1.capacity() << endl;

return 0;

}

输出结果为:

系统开辟的空间往往是大于程序员设定的空间的,且遵循对齐原则。

(2)resize函数

resize函数用于改变字符串的大小(size),即改变其中包含的字符数。

如果 n 小于当前字符串的长度,则 resize 函数会将字符串缩短到前 n 个字符,并删除超出第 n 个字符之后的所有字符。

如果 n 大于当前字符串的长度,则 resize 函数会扩展字符串,以便它能够包含 n 个字符。这通常涉及到在字符串的末尾添加新的字符。

如果调用时提供了第二个参数 c,则这些新添加的字符将被初始化为 c 的副本。

如果没有提供第二个参数 c,则新添加的字符是值初始化的。

n<size:

测试代码:

<code>void test1()

{

string s1 = "hello world";

cout << "字符个数:" << s1.size() << endl;

cout << "空间大小:" << s1.capacity() << endl << endl;

s1.resize(10);

cout << "修改后字符个数:" << s1.size() << endl;

cout << "修改后空间大小:" << s1.capacity() << endl;

}

输出结果:

size < n < capacity:

测试代码:

<code>void test2()

{

string s1 = "hello world";

cout << "字符个数:" << s1.size() << endl;

cout << "空间大小:" << s1.capacity() << endl << endl;

s1.resize(12);

cout << "修改后字符个数:" << s1.size() << endl;

cout << "修改后空间大小:" << s1.capacity() << endl;

}

输出结果为:

n>capacity:

测试代码:

<code>void test3()

{

string s1 = "hello world";

cout << "字符个数:" << s1.size() << endl;

cout << "空间大小:" << s1.capacity() << endl << endl;

s1.resize(20);

cout << "修改后字符个数:" << s1.size() << endl;

cout << "修改后空间大小:" << s1.capacity() << endl;

}

输出结果:

(3)clear函数

string 类提供的 clear 函数用于移除字符串中的所有字符,使其变为空字符串。

下面是个简单的测试:

<code>int main()

{

string str = "Hello, World!";

// 检查字符串是否为空

if (str.empty())

{

cout << "串为空" << endl;

}

else

{

cout << "串不为空" << endl;

}

// 清除字符串

str.clear();

// 检查字符串是否为空

if (str.empty())

{

cout << "串为空" << endl;

}

else

{

cout << "串不为空" << endl;

}

// 输出清空后的字符串

cout << "清空后的字符串: " << str << endl;

return 0;

}

输出结果为:

4.string类的访问操作

string类的访问操作通常有如下几种:

函数名称 功能
operator[] 返回指定位置的字符,越界则报错
at 返回指定位置的字符,越界则抛异常
back 返回字符串最后一个字符(不是"0”)
front 返回字符串第一个字符
4.1 operator[]函数

string类的operator[]函数是一个重载的下标操作符,它允许通过索引来访问字符串中的单个字符。

string 类重载了两个operator[],一个是普通版的,一个是 const ,即字符串不可修改的。

简单的测试:

<code>int main()

{

string s1 = "hello world";

cout << s1[0] << endl;

cout << s1[2] << endl;

cout << s1[4] << endl;

return 0;

}

输出结果为:

普通版的话我们可以对字符串进行修改。

<code>int main()

{

string s1 = "hello world";

s1[0] = 'x';

s1[1] = 'x';

s1[2] = 'x';

cout << s1 << endl;

return 0;

}

输出结果为:

4.2 at函数

at函数提供了一种安全的方式来访问字符串中的字符。与operator[]不同,at函数会执行范围检查,以确保提供的索引没有超出字符串的当前长度。

<code>int main()

{

string s1("hello world");

cout << s1.at(0) << endl;

cout << s1.at(2) << endl;

return 0;

}

输出结果为:

4.3 front 和 back 函数

这两个用的比较少,了解即可。

<code>int main()

{

string s1("hello world");

cout << s1.front() << endl;

cout << s1.back() << endl;

return 0;

}

输出结果如下:

5.string类的修改操作

关于string类的操作修改的接口比较多,由于篇幅有限,实在不能详细一个个讲解,我们就先学习一些比较重要的,其他的有需要再去了解。

函数名称 功能说明
push_back 字符串后尾插字符c
append 在字符串后追加一个字符串
operator+= 在字符串后追加字符串str
assign 使用指定字符串替换原字符串
replace 用新字符串替换原字符串指定区间
pop_back 删除字符串最后一个字符
erase 删除字符串指定部分
swap 交换两个字符串
5.1 字符串增加操作

字符串的增加操作,在末尾添加字符可以使用push_back,在末尾添加字符串可以使用append,而operator+=既可以在末尾添加字符,也可以添加字符串。

<code>int main()

{

string str("hello world");

// 追加一个!

str.push_back('!');

cout << str << endl;

str += '!';

cout << str << endl;

// 在字符串开头插入一个'!'

str.insert(0, 1, '!');

cout << str << endl;

// 追加一个字符串

str.append("hello ");

cout << str << endl;

str += "world!";

cout << str << endl;

return 0;

}

输出结果为:

5.2 字符串替换操作

字符串替换操作我们用到的是assign和replace。

assign是直接替换掉原字符串,而replace是替换原字符串的某段区间。

示例如下:

<code>int main()

{

std::string s1("hello world");

std::string s2;

s2.assign(s1);

std::cout << s2 << std::endl;

s2.assign(s1, 6);

std::cout << s2 << std::endl;

// 用s1替换掉下标为2,长度为2的区间

std::string s3("ciallo");

s3.replace(2, 2, s1);

std::cout << s3 << endl;

}

输出结果:

这俩函数接口比较多,可以自行查看文档进行学习。

5.3 字符串删除操作

pop_back支持删除最后一个字符,erase支持删除任意区间。

<code>int main()

{

string str("hello world");

str.pop_back();

cout << str << endl;

str.erase(str.begin());

cout << str << endl;

str.erase(0, 2);

cout << str << endl;

return 0;

}

输出结果为:

5.4 字符串交换操作

swap 函数用于交换两个字符串对象的内容。

<code>int main()

{

string s1("hello world");

string s2("C++");

cout << s1 << endl;

cout << s2 << endl;

s1.swap(s2);

cout << s1 << endl;

cout << s2 << endl;

return 0;

}

输出结果为:

5.5 字符串其他操作

除了以上这些,string类还有很多可以使用的操作。

函数名称 功能
c_str 返回C格式的字符
substr 从字符串pos位置开始,截取n个字符,然后将其返回
find 从字符串pos位置开始往后找字符c,返回该字符在字符串中的位置
rfind 从字符串pos位置开始往前找字符c,返回该字符在字串中的位置
find_first_ of 在原字符串中,从前往后找匹配串中第一个匹配的字符
find_last_of 在原字符串中,从后往前找匹配串中第一个匹配的字符
find_first_not of 在原字符串中,从前往后找匹配串中第一个不四配的字符
find_last_not_ of 在原字符串中,从后往前找匹配串中第一个不匹配的字符
getline 获取一行字符串
operator+ 尽量少用,因为传值返回,导致深拷贝效率低
operator<< 流提取重载
operator>> 流插入重载

下面就不展开说了,可以通过查看文档来进行学习。

结束语

本篇博客写的有点长了。。。

希望能对各位大佬有所帮助!!!

求点赞收藏评论关注!!!

感谢各位!!!



声明

本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。