C++:string

最新推荐文章于 2024-04-12 03:44:30 发布
最新推荐文章于 2024-04-12 03:44:30 发布
阅读量607 收藏 1
点赞数
分类专栏： C++入门 文章标签： c++ 开发语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JJR_YZ/article/details/128879491
版权

目录

🏆一、constructor

🏆 二、string类对象的访问及遍历操作

👓Ⅰoperator [] && at

👓 Ⅱ范围for

👓Ⅲ迭代器

①正向迭代器 

②反向迭代器

👓Ⅲconst 迭代器

🏆三、string类对象的容量操作

🏆四.string类对象的修改操作

👓Ⅰassign和replace

👓Ⅱfind&&rfind

🏆五、string的模拟实现

👓Ⅰ流插入和流提取的细节

👓Ⅱ赋值和拷贝构造的现代写法

🏆六、string类的一些oj

每日鸡汤：

🚀世上没有绝望的处境，只有对处境绝望的人。

🏆一、constructor

string的构造是比较多的，其中重点是掌握四个基本的构造函数。

 

 

npos是定义在string中的一个无符号类型常量，npos=-1。

🏆 二、string类对象的访问及遍历操作

👓Ⅰoperator [] && at

[]就是简单的下标访问。

 

at功能和operator[]类似，发生越界会抛异常。 

👓 Ⅱ范围for

 范围for需要注意的是auto推演类型，是传引用。范围for是套用了迭代器，只要支持迭代器，就支持范围for。

👓Ⅲ迭代器

迭代器是行为上像指针一样的东西。

string的迭代器有很多：

①正向迭代器 

 

 这里begin()和end()是正向迭代器。其中需要注意的是，end()指向的是最后一个数据的下一个位置。

可能有老铁认为迭代器好像没有下标访问那么便利，迭代器的最大意义是它的通用访问形式。string类的本质是顺序表，采用下标访问当然可以，但是如果对于链表和树，[]访问是不方便的，一句话讲，迭代器是STL通用的访问数据的形式。

②反向迭代器

如果倒着访问数据，就可以使用反向迭代器。

这里之所以报错是因为尽管正向迭代器(begin())和反向迭代器(rbegin())都是迭代器，但是他么的类型是不相同的。如果要使用反向迭代器也只能使用反向迭代器类型！！

👓Ⅲconst 迭代器

 const限制的对象必须使用const迭代器，因为非const迭代器是具有对数据进行修改的权力，而const对象是不能被修改的，所以const限制的对象只能使用const迭代器。

 const迭代器只能读不能写。

 注意const迭代器之所以写法不是const string::iterator，而是string:: const_iterator,是因为const迭代器保护的是it指向的内容，而不是it，it可以++遍历，但是*it不能修改。

const反向迭代器。

 总结一下：

 简单来提一下库中const类型和非const类型在库中实现的准则：根据需求来实现

🏆三、string类对象的容量操作

函数名称                                  功能说明                           

size（重点）                           返回字符串有效字符长度
length                                     返回字符串有效字符长度
capacity                                 返回空间总大小
empty （重点）                      检测字符串释放为空串，是返回true，否则返回false
clear （重点）                       清空有效字符
reserve （重点）            ​​​​​​​       为字符串预留空间* *
resize （重点）           ​​​​​​​        ​​​​​​​    将有效字符的个数设reserve成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, char c)用字符c来填充多出的 元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大 小，如果是将元素个数减少，底层空间总大小不变。 
  4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于 string的底层空间总大小时，reserver不会改变容量大小。

验证：

 这些接口都比较简单，比较有意义的是reserve这个接口：

频繁扩容是比较影响效率的一件事情，如果我们预先大概知道要开辟多大的空间，从而预先开辟好空间避免频繁扩容，是提高效率的一种方式。

我们可以先来观察一下vs和Linux下是如何扩容的。

 ​​​​​​​

 

相同的代码在不同的平台上扩容机制是不同的.

 

🏆四.string类对象的修改操作

函数名称                                功能说明
push_back                             在字符串后尾插字符c
append                                  在字符串后追加一个字符串
operator+= (重点)                  在字符串后追加字符串str
c_str(重点)                            返回C格式字符串
find                  从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置
注意：
  1. 不要轻易使用insert和erase，因为它们涉及到数据搬运，复杂度比较大。

 

 

erase的使用：从pos位置开始删除len个字符，如果字符串过短或者len大于从pos到末尾的长度，那么就从pos位置开始剩余字符串全部删除。

👓Ⅰassign和replace

assign和replace很容易搞混，但是他们的含义是完全不同的。

assign--替代，全部替代，赋值--趋向于赋值 

replace则是替换一部分。

 

assign会先清空原本字符串内的数据，而replace则是在原本字符串的基础上进行修改。它们都很好用，但是不建议使用，涉及到搬运数据的复杂度比较大。

👓Ⅱfind&&rfind

 

find通常用于查找某个字符。比如我们想判断一个文件是什么类型的，往往要先找到'.'后缀以方便判断。

 

 我们这里就取到了test.cpp的后缀。这里我们取字符串用了substr的接口。

 如果我们的文件格式是test.cpp.zip.tar这样有多个用.隔开的，使用find查找就比较麻烦。库里面提供了rfind接口方便我们倒着查找。

 

🏆五、string的模拟实现

#include<string>
#include<iostream>
#include<assert.h>
using namespace std;
//string模拟实现
namespace Gyh
{
	class string
	{

	public:
		typedef char* iterator;

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}
		string(const char* str = "")//给"" 
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];

			strcpy(_str, str);

		}

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

		}
		//现代写法
		string(const string& s)
			:_str(nullptr)
			,_size(0)
			,_capacity(0)
		{
			string tmp(s._str);
			//swap(_str, tmp._str);//指针交换 --_str指向tmp指向
			//swap(_size, tmp._size);
			//swap(_capacity, tmp._capacity);
			swap(tmp);//究极简化
			//析构tmp会有风险--tmp指向野指针--给tmpnullptr
		}
		string& operator=(string s)
		{
			//不要tmp ，现成打工人
			if(this!=&s)
				swap(s);
			return *this;
			//写法简洁

		}
		~string()
		{
			delete[] _str;
			_capacity = _size = 0;
		}

		const char* c_str()
		{
			return _str;
		}

		inline size_t size()const
		{
			return _size;
		}

		inline size_t capacity()const
		{
			return _capacity;
		}
		//普通对象，可读可写
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
		//const对象，只读
		const char& operator[](size_t pos)const
		{
			assert(pos < _size);
			return _str[pos];
		}

		void push_back(char ch)
		{
			if (_size == _capacity)
			{
				size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
				_capacity = newCapacity;
				reserve(_capacity * 2);
			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';//补上\0

		}
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}
		void resize(size_t n, char ch = '\0')
		{
			if (n > _size)
			{
				reserve(n);
				for (size_t i = _size; i < n; ++i)
				{
					_str[i] = ch;
				}
				_size = n;
				_str[_size] = '\0';
			}
			else
			{
				_str[n] = '\0';
				_size = n;
			}
		}
		void append(const char* str)
		{
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			strcpy(_str + _size, str);
			_size += len;
		}

		string & operator +=(char ch)
		{
			push_back(ch);
			return *this;
		}

		string& operator +=(const char* str)
		{
			append(str);
			return *this;
		}
		string& insert(size_t pos, char ch)
		{
			assert(pos <= _size);
			if (_size == _capacity)
			{
				size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newCapacity);
			}

			//挪动数据
			size_t end = _size+1;
			while (end > pos)
			{
				_str[end] = _str[end-1];
				--end;
			}
			_str[pos] = ch;
			++_size;//插入了一个要++
			//头插会死循环
			return *this;
		}
		string& insert(size_t pos, const char* str)
		{
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			//挪动数据
			size_t end = _size+1;
			_size = _size + len;
			while (end > pos)
			{
				_str[end+len-1] = _str[end-1];
				--end;
			}
			strncpy(_str + pos, str, len);
			return *this;
		}


		string& erase(size_t pos,size_t len=npos)
		{
			assert(pos < _size);
			if (len == npos || len >= _size - pos)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size = _size - len;
			}
			return *this;

		}
		size_t find(const char ch, size_t pos = 0)const
		{
			//从某个位置开始找
			assert(pos < _size);
			while (pos < _size)
			{
				if (_str[pos] == ch)
				{
					return pos;
				}
				++pos;
			}
			return npos;
		}
		// kmp 

		size_t find(const char* str, size_t pos = 0)const
		{
			//从某个位置开始找
			assert(pos < _size);
			const char* ptr = strstr(_str + pos, str);
			if (ptr == nullptr)
			{
				return npos;
			}
			else
			{
				return ptr - _str;
			}
		}
		void clear()
		{
			_size = 0;
			_str[0] = '\0';
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity;

		const static size_t npos = -1;//只针对整型

	};

	ostream& operator<<(ostream& out, const string& s)
	{
		for (size_t i = 0; i < s.size(); ++i)
		{
			out << s[i];//不一定要友元
		}
		//要const版本
		return out;
	}
	istream& operator>>(istream& in, string& s)
	{
		s.clear();//先清除
		char buffer[128] = { '\0' };
		char ch = in.get();
		size_t i = 0;
		while (ch != ' ' && ch != '\n')
		{
			if (i == 127)
			{
				s += buffer;
				i = 0;
			}
			buffer[i++] = ch;
			ch = in.get();
		}
		if (i > 0)
		{
			buffer[i] = '\0';
			s += buffer;
		}
		return in;
	}

}

这只是string的简单模拟实现。其中比较有诸多细节需要注意。

👓Ⅰ流插入和流提取的细节

对于一个string类对象，如果我们流插入这个类，和流插入这个类的c_str,两者有什么区别呢？

我们看到如果我们在字符中间插入一个'\0',如果是打印C形式字符串，默认会到'\0'终止，而如果我们是流插入类对象就会把它的全部内容打印出来，这就是区别。所以内核代码是这样撰写的。

ostream& operator<<(ostream& out, const string& s)
	{
		for (size_t i = 0; i < s.size(); ++i)
		{
			out << s[i];//不一定要友元
		}
		//要const版本
		return out;
	}

它的结束标识是size的大小。

👓Ⅱ赋值和拷贝构造的现代写法

传统写法：

string(const string& s)
		{
			_str = new char[s._capacity + 1];
			_capacity = s._capacity;
			_size = s._size;

			strcpy(_str, s._str);

		}
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				char* tmp = new char[s._capacity + 1];
				strcpy(tmp, s._str);

				delete[] _str;
				_str = tmp;

				_size = s._size;
				_capacity = s._capacity;
			}
			return *this;
		}

 现代写法：

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

		}
        string(const string& s)
			:_str(nullptr)
			,_size(0)
			,_capacity(0)
		{
			string tmp(s._str);
			swap(tmp);//究极简化
			//析构tmp会有风险--tmp指向野指针--给tmpnullptr
		}
//赋值拷贝写法1
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				string tmp(s._str);

				swap(tmp);
			}
			return *this;

		}
//赋值拷贝写法2
		string& operator=(string s)
		{
			//不要tmp ，现成打工人
			if(this!=&s)
				swap(s);
			return *this;
			//写法简洁

		}

传统和现代写法并无优劣，只是我们为了方便，写出了现代写法。可能现代写法比较奇怪，其中swap函数要特别说明，它和库中通用的swap函数是不同的。

库中的swap函数是通用的，它套用了模板，如果是string类使用库中通用的swap函数，涉及三次深拷贝--代价比较大。所以我们自己设计。

设计的理念在于：

对于拷贝构造，我们可以取巧采用构造函数，构造出一个tmp中间变量。这个tmp对象的内容和数据和我们要拷贝的对象是相同的，只需要把它的内容和我们目的对象交换就可以实现拷贝构造的目的。

 

 需要注意的是，因为交换过后在拷贝构造结束后会自动调用析构函数析构tmp，所以this指向的对象要初始化为nullptr，以免出现野指针析构。

对于赋值拷贝，我们本身就要构造出一个中间变量，所以最简写法就是传值传参，而非传引用传参。

🏆六、string类的一些oj

Ⅰ、387.找字符串中第一个只出现一次的字符

思想：计数排序。

class Solution {
public:
    int firstUniqChar(string s) 
    {
        int ans[26]={0};
        for(auto m:s)
        {
            ans[m-'a']++;
        }
        int i=0;
        for(i=0;i<s.size();++i)
        {
            if(ans[s[i]-'a']==1)
            return i;
        }
        return -1;

    }
};

Ⅱ、HJ1字符串里面最后一个单词的长度

思想：反向迭代器

#include <iostream>
using namespace std;

int main() 
{
    string str;
    getline(cin,str);//重载了流提取和流插入

    size_t pos=str.rfind(' ');
    cout<<str.size()-pos-1<<endl;
    return 0;
   
    
}
// 64 位输出请用 printf("%lld")

Ⅲ415.字符串相加

class Solution {
public:
    string addStrings(string num1, string num2) {
        int end1=num1.size()-1,end2=num2.size()-1;
        int carry=0;
        string retStr;
        retStr.reserve(end1+end2+1);
        while(end1>=0 ||end2>=0)
        {
            int val1=end1>=0?num1[end1]-'0':0;
            int val2=end2>=0?num2[end2]-'0':0;
            int ret=val1+val2+carry;
            carry=ret/10;
            ret%=10;

            retStr.push_back(ret+'0');
            --end1;
            --end2;
        }
        if(carry)
         retStr.push_back(carry+'0');
       reverse(retStr.begin(),retStr.end());
        return retStr;
    }
};

Ⅳ541.反转字符串

find的使用

class Solution {
public:
    string reverseWords(string s) 
    {
        size_t st=0,pos=0;
        while(pos<s.size())
        {
            pos=s.find(' ',pos);
            if(pos==string::npos)
            {
                pos=s.size();
            }
            reverse(s.begin()+st,s.begin()+pos);
            ++pos;
            st=pos;
        }
        return s;

    }
};

Ⅴ43.字符串相乘

这道题目比较难，涉及到数学的一些知识和字符串相加的思想。

class Solution {
public:
    string multiply(string num1, string num2) 
    {
        if(num1=="0"||num2=="0")
        {
            return "0";
        }
        int n1=num1.size(),n2=num2.size();
        //tmp数组临时存储
        auto tmp= vector<int>(n1+n2);
        for(int i=n1-1;i>=0;--i)
        {
            int x=num1.at(i)-'0';
            for(int j=n2-1;j>=0;--j)
            {
                int y=num2.at(j)-'0';
                tmp[i+j+1]+=x*y;
                
            }
        }
        string ans;
        ans.reserve(n1+n2);
        for(int i=n1+n2-1;i>0;--i)
        {
            tmp[i-1]+=tmp[i]/10;
            tmp[i]%=10;
        }
        int index=tmp[0]==0?1:0;
        for(int i=index;i<n1+n2;++i)
        {
            ans.push_back(tmp[i]+'0');
        }
        return ans;

    }
};

七天七月七年_J
关注
专栏目录
C++：string的length, size, capacity, resize, reserve
风静如云的博客
08-31 816
主要注意的是扩容后，string对象会分配新的内存空间，然后将原来的字符串拷贝到新的空间，并释放原有的空间，也就是说：字符串的内容还维持不变，但是保存字符串的空间可能已经发生了变化。当count的数量大于当前的size时，string对象保存的字符串长度会增长，如果传递了ch参数，则使用ch的字符来填充，如果没有指定ch，则使用'\0'进行填充。如果new_cap的值大于当前string对象的容量，则对string的容量进行扩容，扩容后的容量大于等于new_cap。可以看到字符串没有受到影响。
C++：stringstream格式化字符串
风静如云的博客
06-10 2957
C语言通过snprintf对字符串进行格式化，格式化前需要首先对字符串的长度预估，如果长度大于了字符数组的大小，格式化字符串会被截断。C++通过stringstream对字符串进行格式化： 可以设置字符串的格式：..................
【C++】string类
holle_world_ldx的博客
08-03 1384
【C++】string类
C/C++编程：std::size_t
OceanStar的博客
03-09 2105
std::size_t 定义于如下头文件 #include<cstddef> #include<cstdio> #include<cstdlib> #include<cstring> #include<ctime> #include<cuchar> #include<cwchar> typedef /*implementation-defined*/ size_t; std::size_t可以存放下理论上可能存
c++ string类型内存分配
MrQueens的博客
12-30 2851
#include <iostream> #include <cstdlib> #include <string> using std::string; using std::cout; using std::endl; //重写string类的new操作符,添加一个可以识别malloc操作的输出 void* operator new(std::size_t n){ cout<<"分配"<<n<<"字节"<<end
String 的内存分配
qq_49644209的博客
04-26 1147
在Java语言中有8种基本数据类型和一种比较特殊的类型String。这些类型为了使它们在运行过程中速度更快、更节省内存，都提供了一种常量池的概念。 常量池就类似一个Java系统级别提供的缓存。8种基本数据类型的常量池都是系统协调的，String类型的常量池比较特殊。它的主要使用方法有两种。1.直接使用双引号声明出来的String对象会直接存储在常量池中。比如：String info=“atguigu.com”; 2.如果不是用双引号声明的String对象，可以使用String提供的intern()方法。 .
string中的 reserve()和 resize()
热门推荐
万里归来少年心
01-12 1万+
 reserve() 为容器预留足够的空间，避免不必要的重复分配。预留空间大于等于字符串的长度。预留空间可以通过capacity()查看。  resize() 调整字符串的大小。如果字符串长度变小，多余的字符会被截掉。若长度变大，可以设置填充的字符。长度可以通过size()查看。 1. reserve() string str = "April"; str.reserve(20);   ...
C++：string实现查找网址的协议名和后缀
须知少日拏云志，曾许人间第一流。
03-16 7173
用到string接口如下: substr: 建立一个字串,存放字符。 find: 查找用到所示符号的位置。 代码如下: #include <iostream> using namespace std; //获取协议名 string GetProtocol(const string& url) { size_t pos = url.find("://"); if (pos != string::npos) { return url.substr(0, pos -.
C++ std::string 字符串替换
zhouyuanqwe的博客
08-10 5510
std::string字符串替换
C ++：将MFC CString转换为std :: string
04-06
在UNICODE中：CString str = L“ Test”; std :: wstring ws（str）; std :: string s; s.assign（ws.begin（），ws.end（））;
C++之std::string的resize与reverse
Milu_Jingyu的博客
11-06 1049
在C++中我们经常用std::string 来保存字符串，其中有两个比较常用但是却平时容易被搞混的两个函数，分别是resize和reserve，模糊意识里，这两个方法都是对std::string的容量或元素进行操作，那么这两个函数到底做了什么呢？先声明string中的两个概念，capaticy（容量）和size（大小）
关于C++中 string 定义的变量所占空间的大小
fly_sky_share的博客
08-24 5410
在C++中 使用string 定义变量，当用sizeof（）测string 变量大小时，测得的结果为28。如下图所示： #include <iostream> #include <string> using namespace std; class Test { private: int m_a; float m_b; char *m_str; void show() { cout << "m_a = " << m_a << " m
string的模拟实现（下）
qq_66581313的博客
01-27 874
string的模拟实现下
string.reserve 与 string.resize的区别
FreeCloud_InSky的专栏
07-25 1万+
string中有两个函数：reserve()和resize()，最近细细的看了下这两个函数的使用，记录下来。
C语言如何实现动态扩容的string？_c++ string 扩容
最新发布
2401_84240742的博客
04-12 615
/ 确保内部有足够的空间存储字符串。// 整数转为字符串。// 左移到最后可能会变为0，由于alloced是无符号型，减一则会变成UINT_MAX。// 每次以2倍大小扩容。// 已分配的内存大小。// 初始分配内存大小是32，之后每次以2倍大小扩容。// 字符串的实际长度。
C++---string类的使用和模拟实现
qq_47406941的博客
03-27 477
目录 一、string接口使用 二、重要接口的实现和解释 三、完成代码 + 测试用例 一、深浅拷贝 1.浅拷贝 浅拷贝也称值拷贝。定义两个变量int a = 10;int b = 15; b = a就是一种浅拷贝，即将a的值给b。 2.深拷贝 对于指针类型的变量，使用浅拷贝：int* a = 10; int* b = 20; b = a这是a和b就会指向同一块内存空间，因为采用浅拷贝会将a的值拷贝给b，而a的值是int型变量的地址。 深拷贝：int* a = 10;int* b =..
力扣-键值映射
销夜的博客
10-24 111
显而易见的字典树题目，练习一下字典树的写法。
c++中resize()和reverse()的区别
weixin_44984172的博客
09-20 1140
c++的string的reserve()和resize()的不同之处
10届国赛java B组蓝桥杯： 最长子序列
weixin_46640345的博客
01-10 330
最长子序列 【问题描述】 我们称一个字符串S包含字符串T是指T是S的一个子序列，即可以从字符串S中抽出若干个字符，它们按原来的顺序组合成一个新的字符串与T完全一样。 给定两个字符串S和T，请问最少修改S中的多少个字符，能使S包含T ? 【输入格式】 输入两行，每行一个字符串。第一行的字符串为s，第二行的字符串为T。两个字符串均非空而且只包含大写英文字母。 【输出格式】 输出一个整数，表示答案。 【样例输入】 ABCDEABCD AABZ 【样例输出】 3 思路： 思路很简单，从头到尾遍历串S，遇到与 t[
C++ std::string
08-25
std::string::iterator newend = std::remove_if(name.begin(), name.end(), iswhitespace); 此处的iswhitespace是一个判断字符是否为空格的谓词函数。 总结起来，C++的std::string类提供了多种初始化方式、字符...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值