【STL】string的常用函数用法总结

于 2024-08-18 12:44:46 发布
阅读量398 收藏 3
点赞数 13
分类专栏： c++ 文章标签： c++ 开发语言 学习 算法 stl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74116463/article/details/141297385
版权

目录

string常见构造

string容量操作

 string遍历操作

 string对象的修改操作

 string查找操作

string常见构造

string()构造空的string类对象，即空指针string s1;
string(const char* s)用c_string构造string类对象string s1("hello world");
string(const string&s)拷贝构造函数string s2(s1);
string(size_t n,char c)strring类对象中包含n个字符cstring s1(5,'1');
//构造函数
string::string(const char* str) 
	:_str(new char(strlen(str)+1))
	,_size(strlen(str))
	,_capacity(strlen(str))
{
	strcpy(_str, str);
}
//析构函数
string::~string()
{
	delete[]_str;
	_str = nullptr;
	_size = 0;
	_capacity = 0;
}

//拷贝构造函数
string::string(const string& s)
{
	_str = new char(s._capacity + 1);
	strcpy(_str, s._str);
	_size = s._size;
	_capacity = s._capacity;
}

string容量操作

size返回字符串有效字符长度
length返回字符串有效字符长度
capacity返回空间总大小

注：在string类中size和length是等效的；

string s1("hello world");
cout << s1.size() << endl;
cout << s1.length() << endl;
cout << s1.capacity() << endl;

运行结果：

 

reserve为字符串预留空间（扩容）
resize将有效字符的个数为n个，多出的空间用字符c填充（扩容+尾插）

 reserve:

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

	string s1("hello world");

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

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

 运行结果：

resize:

resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字
符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的
元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大
小，如果是将元素个数减少，底层空间总大小不变。

	string s1("hello world");

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

	s1.resize(20, 'x');
	cout << s1 << endl;
	cout << s1.capacity() << endl;

运行结果：

 string遍历操作

 

operator[]返回pos位置的字符
begin,endbegin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器
范围forauto
//operator[]
for (size_t i = 0; i < s1.size(); i++) {
	cout << s1[i] << " ";
	}
	cout << endl;
//迭代器
string::iterator it = s1.begin();
	while (it != s1.end()) {
		cout << *it << " ";
		it++;
	}
	cout << endl;
//返回for
for (auto e : s1) {
	cout << e << " ";
	}
	cout << endl;

 运行结果：

 string对象的修改操作

push_back尾插一个字符
append尾插一个字符串
insert选择位置插入
operator+=在字符串后加字符串str
	string s1("hello world");
	cout << s1 << endl;

	s1.push_back('x');
	cout << s1 << endl;

	s1.append("aaaa");
	cout << s1 << endl;

	s1.insert(3, "X");
	cout << s1 << endl;

	s1.insert(1, "WWW");
	cout << s1 << endl;

	s1 += "QQ";
	cout << s1 << endl;

运行结果：

 string查找操作

find+npos从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置
rfind从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置
substr从str中pos位置开始，截取n个字符，然后将其返回

 find:

	string s1("hello world AXC AA IS da");
	cout << s1 << endl;

	size_t t = s1.find("o");
	cout << t << endl;

	t = s1.find("o",6);
	cout << t << endl;

 运行结果：

 rfind:

	string s1("hello world AXC AA IS da o");
	cout << s1 << endl;

	size_t t = s1.rfind("o",5);
	cout << t << endl;

	t = s1.rfind("o", 10);
	cout << t << endl;

	t = s1.rfind("o");
	cout << t << endl;

 运行结果：

 substr:

	string s1("hello world AXC AA IS da o");
	cout << s1 << endl;

	string s2 = s1.substr(3, 6);
	cout << s2 << endl;

运行结果：

 手动实现一个简单的string类：

string.h:

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<iostream>
#include<assert.h>
using namespace std;

namespace bit {
	class string {
	public:
		string(const char* str="");
		~string();
		const char* c_str() const;
		
		size_t size() const;
		char& operator[](size_t pos);

		typedef char* iterator;
		iterator begin();
		iterator end();

		void reserve(size_t n);
		void push_back(char ch);
		void append(const char* str);

		string& operator+=(char ch);
		string& operator+=(const char* str);

		void insert(size_t pos, char ch);
		void insert(size_t pos, const char* str);

		void erase(size_t pos,size_t len=npos);
		const static size_t npos = -1;

		size_t find(char ch, size_t pos = 0);
		size_t find(const char* str, size_t pos = 0);

		string(const string& s);

		string& operator=(const string& s);

		void swap(string& s);

		string substr(size_t pos = 0, size_t len=npos);

		bool operator<(const string& s)const;
		bool operator>(const string& s)const;
		bool operator==(const string& s)const;
		bool operator<=(const string& s)const;
		bool operator>=(const string& s)const;
		bool operator!=(const string& s)const;
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};
}
istream& operator >>(istream& is, string& str);
ostream& operator<<(ostream& os, const string& str);

 string.cpp:

#include"string.h"

namespace bit {
	string::string(const char* str) 
		:_str(new char[strlen(str)+1])
		,_size(strlen(str))
		,_capacity(strlen(str))
	{
		strcpy(_str, str);
	}
	string::~string() {
		delete[] _str;
		_str = nullptr;
		_size = 0;
		_capacity = 0;
	}
	const char* string::c_str() const
	{
		return _str;
	}
	size_t string::size() const
	{
		return _size;
	}
	char& string::operator[](size_t pos)
	{
		assert(pos < _size);
		return _str[pos];
	}


	string::iterator string::begin()
	{
		return _str;
	}
	string::iterator string::end()
	{
		return _str + _size;
	}


	void string::reserve(size_t n)
	{
		if (n > _capacity) {
			//扩容
			char* tmp = new char[n + 1];
			strcpy(tmp, _str);
			delete[]_str;
			_str = tmp;
			_capacity = n;
		}
	}

	void string::push_back(char ch)
	{
		size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newcapacity);
		_str[_size] = ch;
		_str[_size + 1] = '\0';
		++_size;
	}
	void string::append(const char* str)
	{
		size_t len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}
		//strcat(_str, str);
		strcpy(_str + _size, str);
		_size += len;
	}

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

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

	void string::insert(size_t pos, char ch)
	{
		if (_size == _capacity) {
			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newcapacity);
		}
		//int end = _size;
		//while (end >= (int)pos) {
		//	_str[end+1] = _str[end];
		//	end--;
		//}
		size_t end = _size+1;
		while (end > pos) {
			_str[end] = _str[end-1];
			end--;
		}
		_str[pos] = ch;
		++_size;
	}

	void string::insert(size_t pos, const char* str)
	{
		size_t len = strlen(str);
		if (_size + len > _capacity) {
			reserve(_size + len);
		}
		int end = _size;
		while (end >=(int)pos) {
			_str[end+len] = _str[end];
			end--;
		}
		memcpy(_str + pos, str, len);
		_size += len;
	}

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

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

	size_t string::find(const char* str, size_t pos)
	{
		char*p=strstr(_str + pos, str);
		return p-_str;
	}

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

	string& string::operator=(const string& 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 string::swap(string& s)
	{
		std::swap(_str, s._str);
		std::swap(_size, s._size);
		std::swap(_capacity, s._capacity);
	}

	string string::substr(size_t pos, size_t len)
	{
		//大于后面字符串的长度，有多少取多少；
		if (len + pos > _size)
		{
			string s1(_str + pos);
			return s1;
		}
		else {
			string s1;
			s1.reserve(len);
			for (size_t i = pos; i < pos + len; i++)
			{
				s1 += _str[i];
			}
			return s1;
		}
	}

	bool string::operator<(const string& s) const
	{
		return strcmp(_str, s._str)<0;
	}

	bool string::operator>(const string& s) const
	{
		return !(*this<=s);
	}

	bool string::operator==(const string& s) const
	{
		return strcmp(_str, s._str)==0;
	}

	bool string::operator<=(const string& s) const
	{
		return (*this < s || *this == s);
	}

	bool string::operator>=(const string& s) const
	{
		return !(*this<s);
	}

	bool string::operator!=(const string& s) const
	{
		return !(*this == s);
	}


}

 

以上就是string类的内容！！

 

S hh
关注
  • 13
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言中string函数的作用是,c++中的string常用函数用法总结
weixin_36372610的博客
05-16 2005
c++中的string常用函数用法总结引导语：string常用函数是C语言中常用的一种函数表达方式，以下是小编整理的c++中的string常用函数用法总结，欢迎参考阅读!注意不是CString之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必 担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100...
c语言string 用法,C++中的String的常用函数用法总结
weixin_35240068的博客
05-24 4146
一. string的构造函数的形式：string str：生成空字符串string s(str)：生成字符串为str的复制品string s(str, strbegin,strlen)：将字符串str中从下标strbegin开始、长度为strlen的部分作为字符串初值string s(cstr, char_len)：以C_string类型cstr的前char_len个字符串作为字符串s的初值str...
C++中的String的常用函数用法总结
热门推荐
qq_37941471的博客
08-27 36万+
一. string的构造函数的形式： string str：生成空字符串 string s(str)：生成字符串为str的复制品 string s(str, strbegin,strlen)：将字符串str中从下标strbegin开始、长度为strlen的部分作为字符串初值 string s(cstr, char_len)：以C_string类型cstr的前char_len个字...
【C++STL】String类的常用函数用法总结
Zfox的博客
05-01 1183
对C++的string进行了简要介绍
【C++入门】C++ STL中string常用函数用法总结
2202_75605090的博客
01-17 1021
STL(standard template libaray-标准模板库)：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架，主要包含：算法、仿函数、迭代器、空间适配器、容器、适配器；六大组件，本无主要介绍的是STL容器中string常用函数的用法。
【C++ STL】-- string学习以及常用函数用法总结
weixin_64609308的博客
08-26 1547
【C++ STL】-- string学习以及常用函数用法总结 （string的日常基础使用）
C++ STL常用函数总结
fucheng的博客
01-09 1004
C++ STL常用用法总结
C++STL常用函数
博客
04-06 1064
注：总结C++STL常用函数，方便即时查询
C++string类常用函数 c++中的string常用函数用法总结
Jack的博客
06-02 3万+
string类的构造函数： string(const char *s); //用c字符串s初始化 string(int n,char c); //用n个字符c初始化 此外，string类还支持默认构造函数和复制构造函数，如string s1；string s2="hello"；都是正确的写法。当构造的string太长而无法表达时会抛出length_error异常 string类的字符...
C++ string常用函数
qq_66290838的博客
06-14 469
STL 是 C++ 标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。
c++中的string常用函数用法总结
09-05
本文将对C++中的`std::string`常用函数进行详细讲解。 首先，要使用`std::string`，需要包含`<string>`头文件，并可选择性地使用`using namespace std;`来简化代码。例如： ```cpp #include <string> using ...
C++ STL string常用函数
09-04
以上是C++ STL `string`类中常用的函数概览，这些函数的使用大大提升了字符串处理的效率和代码的可读性。在实际编程中，熟练掌握并运用这些函数能够帮助开发者更加高效地完成字符串相关的任务。
ACM比赛STL 基本的函数大全STL.docx
06-06
根据给定文件的信息，我们可以总结出以下关于STL在ACM比赛中常用的基本函数与操作的知识点： ### 一、String 类型详解 #### A. 创建 `string` 类型变量 - **直接创建**：`string s;` 直接创建一个空的 `string` ...
C语言 | Leetcode C语言题解之第337题打家劫舍III
m0_59237910的博客
08-15 273
C语言 | Leetcode C语言题解之第337题打家劫舍III
C++(11)类语法分析(2)
最新发布
Once_day的回忆
08-17 710
Author：Once Day Date：2024年8月17日漫漫长路，才刚刚开始…全系列文章请查看专栏: 源码分析_Once-Day的博客-CSDN博客参考文档:基础类的介绍请参考文章：C++(10)类语法分析(1)-CSDN博客运算符重载是C++的一个强大特性，它允许为用户定义的类型自定义运算符的行为。通过运算符重载，我们可以使自定义类型的对象支持各种运算符，如算术运算符、比较运算符、输入输出运算符等，从而提高代码的可读性和表现力。运算符重载的语法，运算符重载的实现方式是定义一个特殊的成员函数或全局函数
c++编程（22）——STL（6）set
2301_77239666的博客
08-16 878
欢迎来到博主的专栏——c++编程博主ID：代码小豪。
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 292
C++ | Leetcode C++题解之第337题打家劫舍III
【C语言】字符串操作函数详解
EleganceJiaBao的博客
08-14 997
这些头文件提供了字符串操作所需的函数声明。以下是常用字符串操作函数的详细讲解，包括每个函数的参数、返回值说明以及示例代码。每个函数的使用说明还包括了适当的表格以帮助理解其功能和用法。
C++_基本语法笔记_模板
qq_45629864的博客
08-14 415
思想是Java里的泛型（不确定用什么类型的数据）这里template这一句，意思是声明T是泛型，后面写用到泛型T的函数。建议都用应用场景：不同数据类型的交换函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值