C++——string 类

我是哈哈hh

已于 2024-09-20 00:07:54 修改

阅读量1k

点赞数 16

分类专栏： C++语言文章标签： c++ 开发语言 linux 数据结构算法学习

于 2024-08-13 08:00:00 首次发布

本文链接：https://blog.csdn.net/2301_80636070/article/details/141069380

版权

C++语言专栏收录该内容

10 篇文章 1 订阅

订阅专栏

1. 标准库中的string类
头文件 #include <string>

1. 标准库中的string类头文件 #include

6.3 写时拷贝(了解)写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。

1.1 string类的常用接口说明（注意下面我只讲解最常用的接口）

1. string类对象的常见构造

string() （重点）	构造空的string类对象，即空字符串
string(const char* s) （重点）	用C-string来构造string类对象
string(size_t n, char c)	string类对象中包含n个字符c
string(const string&s) （重点）	拷贝构造函

void Teststring()
{
string s1; // 构造空的string类对象s1
string s2("hello bit"); // 用C格式字符串构造string类对象s2
string s3(s2); // 拷贝构造s3
}

2. string类对象的容量操作

函数名称	功能说明
size（重点）	返回字符串有效字符长度
length	返回字符串有效字符长度
capacity	返回空间总大小
empty （重点）	检测字符串释放为空串，是返回true，否则返回false
clear （重点）	清空有效字符
reserve （重点）	为字符串预留空间**
resize （重点）	将有效字符的个数该成n个，多出的空间用字符c填充

注意:

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, charc)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。

4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。

string s;

//reserve 开空间 为字符串预留空间
//提前开空间，避免扩容，提高效率
//reserve不会改变s.size()的大小，特别是reserve企图把s的大小变小时，最小只能变成s所存的内存大小
//但是capacity会跟着reserve改变
s.reserve(100)；//开内存空间的大小，但会涉及内存对齐

//返回空间总大小
int sz=s.capacity();


//扩容插入
s.resize(n)
//如果n比size小，就会删除数据，如果比size大就会扩容，插入数据

s[i] //可以特别访问i位置的字符

头插和中间插入：s.insert("插入位置"，“插入内容”);

#include <iostream>
using namepace std;
int main()
{
	string s;
	s = "xxxyyy";
	cout << s << endl;

	//头插
	s.insert(0, "hello");
	cout << s << endl;
	//中间插入
	s.insert(3, "bit");
	cout << s << endl;
    
    //插入一个字符
    char ch='t'；
    s.insert(0,1,ch);
    s.insert(s.begin(),ch);
    
	return 0;
}

删除：s.erase(); s.erase("要开始删除的下标位置"，“要删除几个字符”);

//下标为1的位置删除一个字符
s.erase(1, 1);

//下标为0的位置删除3个字符
s.erase(0, 3);

//若只写一个参数，那么就从下标开始全部删除后面的字符
string = "hello world";
s.erase(6);//"hello"

替换：string& replace(size_t pos, size_t len, string& str);

//与s[i]不同，这可能会覆盖数据，但replace就会移动数据
string s="hello world";
s.replace(5,1,"%%"); //"hello%%world"

查找：size_t find(const string& str,size_t pos = 0) const;

查找+替换

string s("hello bit hello world");
cout << s << endl;
int pos = s.find(' ');

//整形的最大下标就是npos，如果没有找到就返回npos ，，string::npos
while (pos != string::npos)
{
	s.replace(pos, 1, "%%");
	pos = s.find(' ');
}
cout << s;  //hello%%bit%%hello%%world


//但上面效率实在太低，每次遇到依次空格，字符串就要整体后移，
//如果构造一个新的字符串，就只要O(n)
string tmp;
for(auto e : s)
{
    if(e==' ') tmp+="%%";
    else tmp+=e;
}

string s.substr():查找到对应下标字母

size_t s.find() + size_t rfind():

string s = "abcdefg";
string str=s.substr(3, 2);
cout << str << endl;  //de

int pos = s.find("d");
string _str = s.substr(pos);
cout << _str<<endl; //defg

string s1 = "test.cpp.zip";
int pos1 = s1.rfind(".");
cout << s1.substr(pos1);  //.zip

输出流：cin 和 getline()

cin:（遇到换行和空格都分割）
string str1, str2;
cin >> str1 >> str2;   //asd jkl
cout << str1 << endl << str2 << endl;  //自动遇到空格分隔  str1="asd"  str2="jkl"

getline:(默认只遇到换行才分割)
string s;   
getline(cin,s);   //asd jkl
cout<<s<<endl;    //s="asd jkl";

getline(cin,s,delim)   //三个参数，第三个参数delim可以自己定义终止符
eg:getline(cin,s,'*');

2.1 auto和范围for

auto关键字

1)在这里补充2个C++11的小语法，方便我们后面的学习。

2)在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，后来这个不重要了。C++11中，标准委员会变废为宝赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

3)用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

4)auto不能作为函数的参数，可以做返回值，但是建议谨慎使用

5)auto不能直接用来声明数组

在迭代器里面：

#include<iostream>
#include <string>
#include <map>
using namespace std;

int main()
{
std::map<std::string, std::string> dict = { { "apple", "苹果" },{ "orange",
"橙子" }, {"pear","梨"} };
// auto的用武之地
//std::map<std::string, std::string>::iterator it = dict.begin();
auto it = dict.begin();
while (it != dict.end())
{
cout << it->first << ":" << it->second << endl;
++it;
}
  return 0;
}

范围for

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此

C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围，自动迭代，自动取数据，自动判断结束。范围for可以作用到数组和容器对象上进行遍历

范围for的底层很简单，容器遍历实际就是替换为迭代器，这个从汇编层也可以看到。

范围for使用aotu

string s1="asdfg";

for(auto ch : s1) cout<<ch<<" ";

3. string类对象的访问及遍历操作

函数名称	功能说明
operator[] （重点）	返回pos位置的字符，const string类对象调用
begin+ end	begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器
rbegin + rend	begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器
范围for	C++11支持更简洁的范围for的新遍历方式

4. string类对象的修改操作

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

注意：

1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。

2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。

5. string类非成员函数

函数	功能说明
operator+	尽量少用，因为传值返回，导致深拷贝效率低
operator>> （重点）	输入运算符重载
operator<< （重点）	输出运算符重载
getline （重点）	获取一行字符串
relational operators （重点）	大小比较

上面的几个接口大家了解一下，下面的OJ题目中会有一些体现他们的使用。string类中还有一些其他的操作，这里不一一列举，大家在需要用到时不明白了查文档即可。

6. string类的模拟实现

6.1 经典的string类问题

上面已经对string类进行了简单的介绍，大家只要能够正常使用即可。在面试中，面试官总喜欢让学生自己来模拟实现string类，最主要是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数。大家看下以下string类的实现是否有问题？

6.2 浅拷贝

浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。

就像一个家庭中有两个孩子，但父母只买了一份玩具，两个孩子愿意一块玩，则万事大吉，万一不想分享就你争我夺，玩具损坏。

可以采用深拷贝解决浅拷贝问题，即：每个对象都有一份独立的资源，不要和其他对象共享。父母给每个孩子都买一份玩具，各自玩各自的就不会有问题了。

6.3 深拷贝

如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。

6.3.1 传统版写法的String类

class String
{ p
ublic:
String(const char* str = "")
{
// 构造String类对象时，如果传递nullptr指针，可以认为程序非
if (nullptr == str)
{
assert(false);
return;
}

 _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* pStr = new char[strlen(s._str) + 1];
strcpy(pStr, s._str);
delete[] _str;
_str = pStr;
}
 return *this;
} 

~String()
{
  if (_str)
 {
  delete[] _str;
  _str = nullptr;
 }
}
private:
char* _str;
};

6.3.2 现代版写法的String类

class String
{
 public:
String(const char* str = "")
{
if (nullptr == str)
{
assert(false);
return;
}

 _str = new char[strlen(str) + 1];
strcpy(_str, str);
}
 String(const String& s)
: _str(nullptr)
{
String strTmp(s._str);
swap(_str, strTmp._str);
}

 // 对比下和上面的赋值那个实现比较好？
String& operator=(String s)
{
swap(_str, s._str);
return *this;
} 

/*
String& operator=(const String& s)
{
if(this != &s)
{
String strTmp(s);
swap(_str, strTmp._str);
}

 return *this;
} */

~String()
{
if (_str)
{
delete[] _str;
_str = nullptr;
}
}
private:
char* _str;
};