string

最新推荐文章于 2024-05-19 16:12:42 发布
最新推荐文章于 2024-05-19 16:12:42 发布
阅读量597 收藏 5
点赞数 12
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81451574/article/details/138366284
版权

文章目录

Ⅰ.string的用法

1.string 对象的创建（构造）

//创建
void test_string1()
{
	// 空串
	string s1;
	
	//拷贝构造
	string s2(s1);
	
	//字符串常量构造
	const char* str = "hello world";
	string s3(str);
	string _s3("hello world");

    //从s3的下标为6的位置连续的三个字符
	string s4(s3, 6, 3);
	
	// 字符串str的前三个字符
	string s5(str, 3);

	// 6个x
	string s6(6, 'x');
	
	// 迭代器区间
	string s7(s3.begin(), s3.end());
	
	//了解即可
	string s8 = { "hello world" };
}

在这里插入图片描述

2.string的销毁（析构）

  声明周期结束时，编译器自动调用

3.string的遍历

第一种：下标方括号访问

void test_string2()
{
	string s("hello world");
	for (int i = 0; i < s.size(); i++)
	{
		cout << s[i];
	}
}

第二种：迭代器区间

void test_string2()
{
	string s("hello world");
	string::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it;
		it++;
	}
}

第三种：范围for

void test_string2()
{
	string s("hello world");
	for (char ch : s)
	{
		cout << ch;
	}
}

4. string的增

第一种：在位追加一个字符

void test_string3()
{
	string s("hello");
	s.push_back('a');
	s.push_back('b');
	s.push_back('c');
}

void test_string3()
{
	string s("hello");
	s += 'a';
	s += 'a';
	s += 'a';
}

第二种：在尾追加一个字符串

void test_string3()
{
	string s("hello ");
	s.append("world");
}

void test_string3()
{
	string s("hello ");
	s += "abcde";
}

第三种：在任意位置插入一个或者多个字符
在这里插入图片描述

void test_string3()
{
	string s0("xxx");
	string s("hello world");
	
	// 从下标为6的地方开始插入一个string
	s.insert(6, s0); 
	cout << s;// hello xxxworld
}

void test_string3()
{
	string s0("xxxyyy");
	string s("hello world");
	
	// 在s下标为0的位置，插入一个s0的字串（从下标为3开始的连续的三个字符）
	s.insert(0, s0, 3, 3);
	cout << s;//xxxhello wrold
}

void test_string3()
{
	string s("hello world");

	string::iterator it = s.begin();
	s.insert(it + 6, 3, 'x');
	cout << s;// hello xxxworld
}

5.string的删

void test_string4()
{
	string s("hello wrold");
	//从下标为6的位置开始，删除一个字符
	s.erase(6, 1);
	cout << s;//hello rold
}

void test_string4()
{
	string s("hello wrold");
	string::iterator it = s.begin();

	s.erase(it + 6);
	cout << s;//hello rold
}

void test_string4()
{
	string s("hello wrold");
	string::iterator it = s.begin();

	s.erase(it,it+s.size());
	cout << s; //空串
}

6.string的查

函数名称功能介绍
find(c,pos)从下标为pos的位置开始，向后查到第一个字符为c，找到就返回其下标
rfind(c,pos)从下标为pos的位置开始，向前查找第一个字符为c，找到就返回其下标
void test_string5()
{
	string s("hello world");
	size_t pos1 = s.find('l', 0);
	if (pos1 != s.npos) cout << pos1 << endl; // 2

	size_t pos2 = s.rfind('l', 11);
	if (pos2 != s.npos) cout << pos2 << endl; // 9
}

7.string的改

函数名称功能介绍
replace(pos,n,s)从pos位置开始替换n个字符为s串
void test_string6()
{
	string s("hello abc");
	s.replace(6, 3, "wrold"); //hello world
}

Ⅱ.string的底层原理

	class string
	{
		typedef char* iterator;
		typedef const char* const_iterator;
	public:
		// 可加可不加，因为并没有使用私有的成员变量
		//friend istream& operator>>(istream& in, string& s);
		//friend ostream& operator<<(ostream& out, const string& s);
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		const_iterator begin() const
		{
			return _str;
		}
		const_iterator end() const
		{
			return _str + _size;
		}

		string(const char* str = "")
			:_size(strlen(str))
		{
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		string(const string& s)
		{
			string tmp(s.c_str());
			swap(tmp);
		}

		string& operator=(string tmp)
		{
			swap(tmp);
			return *this;
		}


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

		char& operator[](size_t pos)
		{
			assert(pos >= 0 && pos < _size);
			return _str[pos];
		}

		const char& operator[](size_t pos) const
		{
			assert(pos >= 0 && pos < _size);
			return _str[pos];
		}

		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)
			{
				_str[n] = '\0';
				_size = n;
			}
			else
			{
				reserve(n);
				for (size_t i = _size; i < n; i++)
				{
					_str[i] = ch;
				}
				_str[n] = '\0';
				_size = n;
			}
		}

		void push_back(char ch)
		{
			/*if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : 2 * _capacity);
			}

			_str[_size++] = ch;
			_str[_size] = 0;*/
			insert(_size, ch);
		}

		void append(const char* str)
		{
			/*size_t len = strlen(str);
			if (len + _size > _capacity)
			{
				reserve(len + _size);
			}

			strcpy(_str + _size, str);
			_size += len;*/
			insert(_size, str);
		}

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

		void clear()
		{
			_str[0] = '\0';
			_size = 0;
		}

		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 size() const 
		{
			return _size;
		}
		size_t capacity() const 
		{
			return _capacity;
		}
		bool empty()
		{
			return _size == 0;
		}

		void insert(size_t pos, char ch)
		{
			assert(pos >= 0 && pos <= _size);
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : 2 * _capacity);
			}

			size_t end = _size + 1;
			while (end > pos)
			{
				_str[end] = _str[end - 1];
				end--;
			}
			_str[pos] = ch;
			_size++;
		}

		void insert(size_t pos, const char* str)
		{
			assert(pos >= 0 && pos <= _size);
			size_t len = strlen(str);
			if (len + _size > _capacity)
			{
				reserve(_size + len);
			}

			size_t end = _size + len;
			while (end > pos + len - 1)
			{
				_str[end] = _str[end - len];
				end--;
			}
			strncpy(_str + pos, str, len);
			_size += len;
		}

		void erase(size_t pos, size_t len = npos) 
		{
			if (len >= _size - pos || len == npos)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
		}

		size_t find(char ch,size_t pos = 0) const
		{
			for (int i = 0; i < _size; i++)
			{
				if (_str[i] == ch); return i;
			}
			return npos;
		}

		size_t find(const char* str,size_t pos = 0) const
		{
			char* p = strstr(_str+pos, str);
			if (p) return p - _str;
			else return npos;
		}

		string substr(size_t pos, size_t len = npos)
		{
			string sub;
			if (len == npos || len >= _size - pos)
			{
				for(int i = pos;i<_size;i++)
				sub += _str[i];
			}
			else
			{
				for (int i = pos; i < pos + len; i++)
					sub += _str[i];
			}

			return sub;
		}


	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;

		static const int npos;
	};

	bool operator==(const string& s1, const string& s2)
	{
		return strcmp(s1.c_str(), s2.c_str()) == 0;
	}
	bool operator!=(const string& s1, const string& s2)
	{
		return !(s1 == s2);
	}
	bool operator<(const string& s1, const string& s2)
	{
		return strcmp(s1.c_str(), s2.c_str()) < 0;
	}
	bool operator<=(const string& s1, const string& s2)
	{
		return s1 < s2 || s1 == s2;
	}
	bool operator>(const string& s1, const string& s2)
	{
		return !(s1 <= s2);
	}
	bool operator>=(const string& s1, const string& s2)
	{
		return !(s1 < s2);
	}
	
	ostream& operator<<(ostream& out, const string& s)
	{
		for (auto e : s)
		{
			cout << e;
		}
		return out;
	}
	
	istream& operator>>(istream& in, string& s)
	{
		s.clear();
		
		char buff[128];
		char ch;
		ch = cin.get();
		int i = 0;
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i == 127)
			{
				buff[127] = '\0';
				s += buff;
				i = 0;
			}
			ch = cin.get();
		}
	
		if (i)
		{
			buff[i] = '\0';
			s += buff;
		}
	
		return in;
	}
	istream& getline(istream& in, string& s)
	{
		s.clear();
		
		char buff[128];
		char ch;
		ch = cin.get();
		int i = 0;
		while (ch != '\n')
		{
			buff[i++] = ch;
			if (i == 127)
			{
				buff[127] = '\0';
				s += buff;
				i = 0;
			}
			ch = cin.get();
		}
	
		if (i)
		{
			buff[i] = '\0';
			s += buff;
		}
	
		return in;
	}
	
	const int string::npos = -1;
山水未央
关注
  • 12
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
String.txt
07-15
String a="abc";//创建字符串方式1 String b =new String("abc"); //创建字符串方式2 System.out.println(a==b); //false，内存地址不相等 String c =new String("abc"); String d =new String...
Python string.html
02-05
Python string类型，字符串转化成整数，转化成浮点数，了解常见的转义字符，什么是切片?如何使用切片截取字符串，做好小练习
C++中的string类用法简介
热门推荐
liitdar的博客
08-21 30万+
string是C++标准库的一个重要的部分，主要用于字符串处理。可以使用输入输出流方式直接进行string操作，也可以通过文件等手段进行string操作。同时，C++的算法库对string类也有着很好的支持，并且string类还和c语言的字符串之间有着良好的接口。
String用法详解
manonghouyiming的博客
04-05 17万+
string类声明string类本不是STL的容器，但是它与STL容器有着很多相似的操作，因此，把string放在这里一起进行介绍。 之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下的需要。我们尽可以把它看成是C++的基本数据类型。 首先，为了在我们的程序...
String、StringBuffer和StringBuilder的区别
幸遇三杯酒好，况逢一朵花新
06-16 25万+
String、StringBuffer和StringBuilder的区别： 文章目录StringStringBufferStringBuilderStringBuffer是如何实现线程安全的呢？Java9的改进 String   String类是不可变类，即一旦一个String对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁。   这个是String类的解释，之前小咸儿看...
C++string类常用方法
Goallegoal的博客
10-09 9万+
C++string类常用方法 1、string(const char *s) ：将 string 对象初始化为 s 指向的字符串 string str("hello"); 2、string(size_type n,char c) ：创建一个包含 n 个元素的 string 对象，其中每个元素都被初始化为字符 c string str(10, 'a'); 3、string(const string &str) ：将一个 string 对象初始化为 string 对象 str（复制构造函数） str
C++ stringstream
Sakuya__的博客
01-30 1万+
简介 在做LeetCode算法题的时候看到有使用stringstream类处理字符串，自己对这个类不是很了解，查了资料在这里记录一下。 首先，需要包含头文件<sstream>，在标准库中： #include <sstream> <sstream> 定义了三个类：istringstream、ostringstream 和 stringstream，分别用来进行流的输入、输出和输入输出操作。本文以 stringstre...
String.format()的详细用法
星海IT学习之路
10-21 5万+
String.format() 的用法
深入理解String、StringBuffer和StringBuilder
Mr_wxc的博客
07-12 5万+
本文主要针对面试中经常被问到的String的热点、难点进行深入分析，祝你备战秋招，直通BAT
String类详解
weixin_43502661的博客
04-03 2万+
一、基本内容： 1.String类：即字符串类，其主要构造方法为： 　String(String Original)，把字符串封装成字符串对象； 　举例：String s1 = new String(“hello”); 　String(char[] value),把字符数组的数据封装成字符串对象； 　举例：char[] chs = {‘h’,‘e’,‘l’,‘l’,‘o’};　　　 　　　　Str...
String的replace方法
weixin_45816407的博客
09-29 6338
String 和 StringBuilder中都有replace方法。 String： String replace(char oldChar, char newChar) 用新字符newChar 替换所有的 旧字符oldChar 。 String replace(CharSequence target, CharSequence replacement) 用新字符串replacement替换所有的 旧字符串target。 String replaceAll(String regex, St
c++ string字符串详解
m0_62870588的博客
03-25 3万+
string字符串 ；string的创建和初始化 ； string的读写 ；string的基本操作； string的比较大小 ； string的连接。
String实例
10-24
使用c库，手动自定义String原型，实现String类实现与相关成员函数
string xmind
04-24
string xmind
Android String
01-09
Android String字符通过textview呈现，字符通过textview呈现
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 625
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
C语言.动态内存管理
Joseit的博客
05-16 592
栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS(操作系统)回收。分配方式类似于链表。数据段（静态区）：（static）存放全局变量、静态数据。程序结束后由系统释放。
【C++风云录】打破边界：心理学与情绪识别
记录我的学习历程
05-16 707
本文主要探讨了六种开发软件工具包，包括但不限于面部表情分析、心理学实验设计、图像处理、数据挖掘、情绪识别以及生物识别技术等各类关键功能，同时也涵盖了其在各自领域的应用。
文件操作（C语言）
最新发布
2303_76654613的博客
05-19 633
文件 = 文件内容 + 文件属性在程序设计中，文件分为程序文件和数据文件。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值