C++String类使用笔记|详细版

已于 2022-07-25 22:09:06 修改
阅读量763 收藏 9
点赞数 18
分类专栏： C++编程 文章标签： c++ java 开发语言
于 2022-07-19 20:54:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_72486849/article/details/125879461
版权

目录

string类的接口使用

string类的模拟实现

考试当中，很多字符串的题目基本以string类的形式出现，工作当中，为了方便，也基本都使用了string类，熟悉它的使用是很必要的

string类的接口使用

string类对象的构造

//构造函数初始化
void test_string1()
{
  string s1;//无参构造 里面有一个\0

  //string (const char* s);
  string s2("hello,word");//用常量字符串初始化

  //string(const string& s) （重点）拷贝构造
  string s3(s2);//拷贝构造
  string s4 = s2;//拷贝构造

  //string(const char* s, size_t n);//
  string s5("abcdef", 4);//用前四个初始化

  //string (size_t n, char c);
  string s6(10, 'x');//用10个字符x初始化

  //string (const string& str, size_t pos, size_t len = npos);
  string s7(s2, 6, 3);//从第pos位置拷贝n个数据

  cout << s1 << endl;//有一个\0
  cout << s2 << endl;//hello,word
  cout << s3 << endl;//hello,word
  cout << s4 << endl;//hello,word
  cout << s5 << endl;//打印abcd
  cout << s6 << endl;//打印xxxxxxxxxx
  cout << s7 << endl;//打印wor

}

string类对象的访问

//赋值string::operator=
void test_string2()
{
  string s1("hello");
  string s2("word");
  s1 = s2;
  cout << s1 << endl;//word
  s1 = "word";
  cout << s1 << endl;//word
  s1 = 'y';
  cout << s1 << endl;//y
}

//赋值char& operator[] (size_t pos);
//const char& operator[] (size_t pos) const;
void test_string4()
{
  string s1("hello");
  s1[0] = 'H';//此时还能修改
  cout << s1 << endl;//打印Hello
  //s1[6];//越界会自动断言报错误	
}

string类对象的遍历

//数组和范围for遍历
void test_string3()
{
  //遍历string的每一个字符
  //1 下标+方括号string::operator[]
  string s1("hello");
  for (size_t i = 0; i < s1.size(); i++)//s1.size()表示大小
  {
    //s1.operator[](i)
    cout << s1[i] << "";//打印hello	
  }
    cout << endl;

  //2.范围for （c++11）//语法糖 底层替换成迭代器 汇编
  for (auto ch : s1)//自动取字符 自动++
  {
    cout << ch << "";
  }
    cout << endl;	 
}

迭代器的遍历（正反向）

//正反向迭代器
void test_string5()
{
  //正向迭代器，用来访问数据结构的
  string s1("ABCDEF");
  string::iterator it = s1.begin();
  while (it != s1.end())//end指向最后一个数据的下一个位置
  {
   (*it) += 1;//可读可写
   cout << *it << "";//BCDEFG
   ++it;
  }
  cout << endl;
	
  //反向迭代器
  string::reverse_iterator rit = s1.rbegin();
  while (rit != s1.rend())//end指向最后一个数据的下一个位置
  {
   (*rit) -= 1;//可读可写
   cout << *rit << "";//打印FEDCBA
   ++rit;//注意还是++
  }
  cout << endl;

  //const_iterator begin() const;
  //注意还有const的 只能读
  //长可以使用auto
}

string类对象的容量操作（reserve和resize）

//测试尾部插数据空间如何扩容
void test_string6()
{
  string s;
  /*s.reserve(1000);*///可以提前默认开辟1000
  size_t sz = s.capacity();
  cout << "making s grow:\n";
  cout << "capacity changed: " << sz << '\n';
  for (int i = 0; i < 1000; ++i)//扩容有消耗
  {
   s.push_back('c');//尾部插数据
   if (sz != s.capacity())
   {
    sz = s.capacity();//容量大小
    cout << "capacity changed: " << sz << '\n';//结果为1.5倍左右
   }
  }
  /*s.reserve(1000);*///可以提前默认开辟1000
  //s.resize(1000);//可以提前默认开辟1000并默认初始化0
  //s.resize(100，x)//也可以默认初始化其他数据
  //都不会缩容数据
}

string类对象resize的使用

//注意resize 分三种考虑 
void test_string8()
{
  //resize再扩容时可以指定初始化
  //分下面三种情况

  string s3("hello world");

  s3.resize(20, 'x');
  cout << s3 << endl;//打印hello worldxxxxxxxxx

  s3.resize(14, 'x');
  cout << s3 << endl;//打印hello worldxxx

  s3.resize(5, 'x');
  cout << s3 << endl;//打印hello 注意容量小 会筛数据

}

string类对象的数据增加操作

//指定位置（头部）插入字符串
void test_string9()
{
  //不高效 连续空间 插入要挪数据 
  string s("hello");
  //头部插入一个字符 迭代器
  //iterator insert (iterator p, char c);
  s.insert(s.begin(), 'x');
  cout << s<< endl;

  //头部位置插入字符串
  // string& insert (size_t pos, const char* s);
  s.insert(0, "word");
  cout << s<< endl;

  //第三个位置插入一个字符 迭代器
  //iterator insert (iterator p, char c);
  s.insert(s.begin()+3, '0');
  cout << s << endl;
}

string类对象的数据删除操作

//删除数据 erase

void test_string10()
{
  //iterator erase(iterator p);
  string s("helloword");
  cout << s << endl;//打印elloword

  s.erase(s.begin());//头删 
  cout << s << endl;//打印elloword

  s.erase(s.begin()+4);//删除第4个
  cout << s << endl;//打印elloord

  s.erase(4, 2);//从第4个位置删除2个
  cout << s << endl;//打印ellod

  s.erase(2);//从第2个位置删除到最后
  cout << s << endl;//打印el
	
}

string类对象的交换操作

void test_string11()
{
  string s1("hello word");
  string s2("string");

  //c++98
  s1.swap(s2);//效率高 直接交换指向位置

  swap(s1, s2);//效率低 用到了拷贝构造和赋值 是深拷贝
}

string类对象的查找操作

//string::c_str   返回C形式的字符串
//string::find    指定位置查找函数
//string::substr  返回字串 从pos位置返回len个字符
void test_string12()
{
  string s1("hello word");
  cout << s1.c_str() << endl;//和C的接口进行兼容

  //查找返回文件后缀
  string file("strng.cpp");
  size_t pos = file.find('.');//还有rfind
  if (pos != string::npos)
  {
   string suffix = file.substr(pos);//有多少取多少
   cout << file << "后缀为" << suffix << endl;
  }
  else
  {
   cout << "没有找到后缀" << endl;
  }
}

操作实践：分别取出网址的协议、域名、资源名

void test_string13() 
{
  //网址：协议、域名、uri(资源名）
  //取出url网址域名
  string url1("https://m.cplusplus.com/reference/string/string/substr/");

  string& ur1 = url1;//有另外的协议可以直接换

  //取协议名
  string protocol;
  size_t pos1 = ur1.find(":");
  if (pos1 != string::npos)
  {
   protocol = ur1.substr(0, pos1);//去字符串
   cout << "协议名protocol为：" << protocol << endl;
  }
  else
  {
   cout << "非法网址" << endl;
  }
  //取域名
  string domin;
  size_t pos2 = ur1.find("/",pos1+3);//从指定位置找
  if (pos1 != string::npos)
  {
   domin = ur1.substr(pos1 + 3, pos2 - (pos1 + 3));
   cout << "域名domin为：" << domin << endl;
  }
  else
  {
   cout << "非法" << endl;
  }
  //取uri
  string uri = ur1.substr(pos2+1);//取到最后
  cout << "资源名uri为：" << uri << endl;

}

string类的模拟实现

模拟实现string类可以帮助我们更好的理解底层是如何实现具体的函数实现

我们分两个文件来写 string.h 头文件中

//string.h 头文件中

namespace mys//自己的命名空间
{
//先实现一个简单的string，
//考虑管理深浅拷贝问题，考虑增删查改
//全考虑增删查改

class string
{
public:

	//迭代器模拟
	typedef char* iterator;//普通迭代器可修改
	typedef char* const_iterator;//const迭代器 前面加const不可修改

	iterator begin()
	{
		return _str;
	}

	iterator end()//最后一个字符的下一个
	{
		return _str+_size;
	}

	const_iterator begin()const//注意前后都要加const
	{
		return _str;
	}

	const_iterator end()const//最后一个字符的下一个
	{
		return _str + _size;
	}
		
	//全缺省构造
	//:_str(nullptr)//标准库不是给空指针，给的空串 
	//  "\0" ""  '\0'
	string(const char* str="")
		:_size(strlen(str))
		,_capacity(_size)
	{
		cout << "调用构造" << endl;
		_str = new char[_capacity + 1];//写到里面先和执行初始化列表的
		strcpy(_str, str);//会拷贝\0过去
	}

	//拷贝构造 现代写法
	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)
	{
		cout << "调用拷贝" << endl;
		string tmp(s._str);
		swap(tmp);
	}
		
	//赋值（现代写法）
	//s1=s3
	string& operator=(const string& s)
	{
		if (this != &s)
		{
			cout << "调用赋值" << endl;
			string tmp(s._str);
			swap(tmp);
		}
		return *this;
	}

	//析构
	~string()
	{
		if (_str)
		{
			cout << "调用析构" << endl;
			delete[]_str;
			_str = nullptr;
			_size = _capacity = 0;
		}
	}
	//成员函数c_str
	const char* c_str()const //获取C形式的字符串
	{
		return _str;
	}
		
	//运算符重载 修改pos位置字符 也可以遍历
	char& operator[](size_t pos)//返回字符位置的引用 可读可写
	{
		assert(pos < _size);//底层这里形成string类自动检查
		return _str[pos];
	}
		
	//返回const 字符 不能修改 
	const char& operator[](size_t pos)const//
	{
		assert(pos < _size);//
		return _str[pos];
	}

	//空间大小
	size_t size()const//
	{
		return _size;
	}
	//容量大小
	size_t capcacity()const
	{
		return _capacity;
	}

	//赋值重载(常用
	string& operator+=(char ch)//添加字符使用+=返回值
	{
		cout << "调用赋值重载push_back" << endl;
		push_back(ch);//+=底层复用push_back
		return *this;
	}
	string& operator+=(const char* str)//添加字符使用+=返回值
	{
		cout << "调用赋值重载append" << endl;
		append(str);//+=底层复用push_back
		return *this;
	}

	//注意分三种考虑
	void resize(size_t n,char ch='\0')//扩容同时可以指定初始化 
	{
		if (n < _size)
		{
			_size = n;
			_str[_size] = '\0';
		}
		else 
		{
			if (n > _capacity)
			{
				reserve(n);//先保证空间够
			}
			for (size_t i = _size; i < n; i++)
			{
				_str[i] = ch;//添加指定字符
			}
			_size = n;
			_str[_size] = '\0';
		}
	}

	//扩容函数
	void reserve(size_t n)
	{
		//判断
		if (n > _capacity)
		{
			//1.先开辟新空间
			char* tmp = new char[n+ 1];
			//2.旧空间到新空间
			strcpy(tmp, _str);
			//3.释放旧空间
			delete[]_str;
			//4.让指针指向新空间
			_str = tmp;
			//5.更新容量
			_capacity = n;
		}
	}

	void push_back(char ch)//添加单个字符
	{
		//先看满没满 满了就扩容
		if (_size == _capacity)
		{
			reserve(_capacity==0?4:_capacity*2);//扩容2倍
		}
		//到这里空间足够 尾部(_size位置）添加数据
		_str[_size] = ch;
		++_size;
		_str[_size] = '\0';
		//insert(_size, ch);//还可以复用insert
	}

	//添加字符串
	void append(const char* str)//
	{
		//扩大2倍不一定够 
		//len 表示实际实际需要长度：现在有的数量+新的字符数量
		size_t len = _size + strlen(str);//
		if (len > _capacity)//如果超过容量
		{
			reserve(len);//扩大实际需要的长度
		}
		strcpy(_str + _size, str);
		_size = len;//更新_size

		//insert(_size, str); 还可以复用insert
	}
		
	//指定位置插入字符
	string& insert(size_t pos,  char ch)//字符
	{
		//判断合法性
		assert(pos<_size);
		//从\0开始挪
		if (_size == _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity * 2);//扩容2倍
		}
			
		//size_t end = _size;//这种头插会越界#
		size_t end = _size+1;

		//while (end >= pos)#
		while (end > pos)//这时等于0就停止 
		{
			//_str[end + 1] = _str[end];#
			_str[end] = _str[end-1];
			--end;
		}
		_str[pos] = ch;
		_size++;
		return *this;

	}

	//指定位置插入字符串
	//void insert(size_t pos, const char* str)
	string& insert(size_t pos, const char* str)
	{
		assert(pos <= _size);
		size_t len = strlen(str);
			
		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}

		//strcpy(_str + _size, str);//尽量不用 会拷贝\0 就停了
		size_t end = _size + len;//往后挪动len个位置

		while (end > pos+len-1)//这时等于pos+len就停止 
		{
			//_str[end + 1] = _str[end];
			_str[end] = _str[end-len];//避开
			--end;
		}
		strncpy(_str + pos, str, len);
		_size+=len;
		return *this;
	}

	//指定位置删除
	string& earse(size_t pos,size_t len=npos)//
	{
		assert(pos < _size);
		//
		if (len == npos || pos + len >= _size)
		{
			_str[pos] = '\0';
			_size = pos;
		}
		//挪数据覆盖
		else
		{
			size_t begin = pos + len;
			while (begin <= _size)
			{
				_str[begin - len] = _str[begin];
				++begin;
			}
			_size -= len;
		}
		return *this;
	}

	//查找字符
	size_t find(char ch,size_t pos=0)
	{
		for (; pos < _size; ++pos)
		{
			if (_str[pos] == ch)
				return pos;
		}
	}

	//查找字符串
	size_t find(const char* str,size_t pos=0)
	{
		const char* p=strstr(_str + pos, str);
		if (p == nullptr)
		{
			return npos;
		}
		//返回下标
		return p - _str;
	}

private:
	char* _str;//字符串的指针 
	size_t _size;//有效字符 增删查改 要扩容
	size_t _capacity;//有效字符空间 不含\0
	const static size_t npos;//
};
	
const size_t string:: npos = -1;

//流插入 输出
ostream& operator<<(ostream& out,const string& s)
{
	cout << "调用流（输出）" << endl;
	for (auto ch : s)//有多少打印多少
	{
		out << ch;
	}
	return out;//连续流输出
}

//流提取 输入
istream& operator>>(istream& in, string& s)
{
	cout << "调用流提取（输入）" << endl;
	char ch;
	ch=in.get();
	while (ch != ' ' && ch != '\n')
	{
		s += ch;//存在连续扩容 
		ch = in.get();
	}
	return in;//连续流输入
}

//运算符重载 
//放在类外 在类内考虑this
//在外面复用c语言库
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 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);
}

}

test.cpp实现文件中

//模拟实现 
void test_string11()
{
  mys::string s1("hello word");
  cout << s1.c_str() << endl;//打印hello word
  s1[0] = 'x';//char& operator[](size_t pos)
  cout << s1.c_str() << endl;//打印xello word

  //遍历
  for (size_t i = 0; i < s1.size(); i++)
  {
   cout << s1[i] << "";打印xello word
  }
  cout << endl;
  }

//拷贝构造
void test_string22()
{
  //此时没有写拷贝构造
  //析构两次 赋值会相互改 
  mys::string s1("hello word");
  mys::string s2(s1);
  cout << s1.c_str() << endl;
  cout << s2.c_str() << endl;
  s1[0] = 'x';
  cout << s1.c_str() << endl;//深拷贝其中一个修改不影响另一个
  cout << s2.c_str() << endl;
}

//赋值
void test_string33()
{
  //s1 s3是两个存在的对象 
  mys::string s1("hello word");
  mys::string s2(s1);//拷贝
  mys::string s3("1111111");
  s1 = s3;//两个存在的对象赋值 不写赋值也会报错 
  cout << s1.c_str() << endl;
  cout << s2.c_str() << endl;
  cout << s3.c_str() << endl;

  s1 = s1;//考虑自己给自己赋值 
  cout << s1.c_str() << endl;
}

//尾部添加单个字符
void test_string55()
{
  mys::string s1("hello word");
  s1.push_back('!');
  s1.push_back('!');
  cout << s1.c_str() << endl;//打印hello word！！

  s1 += '@';//
  s1 += '@';
  s1 += '@';
  cout << s1.c_str() << endl;

  s1 += "myfriend";
  cout << s1.c_str() << endl;
}

//遍历字符
//调用const版本的遍历 
void func(const mys::string& s)//传参不改变 尽量加const 注意权限
{

  for (size_t i = 0; i < s.size(); ++i)
  {
   cout << s[i] << "";
  }
  mys::string::const_iterator it = s.begin();
  while (it != s.end())
  {
   cout << *it << "";
   ++it;
  }
  cout << endl;

}

//普通遍历
void test_string66()
{
  mys::string s1("hello world");
  // 下标遍历 char& operator[](size_t pos)
  for (size_t i = 0; i < s1.size(); ++i)
  {
    cout << s1[i] << "";
  }
  cout << endl;

  //迭代器遍历
  mys::string::iterator it = s1.begin();
  while (it != s1.end())
  {
    cout << *it << "";
    ++it;
  }
  cout << endl;

  //范围for
  for (auto& ch : s1)//底层就是被替换成迭代器
  {
   //ch -= 1;//传引用还可以修改
   cout << ch << "";
  }
  cout << endl;

  func(s1);
}

//指定位置插入和删除
void test_string77()
{
  mys::string s1("hello world");
  s1.insert(6, '@');
  cout << s1.c_str() << endl;//打印hello @world
  s1.insert(0, '@');
  cout << s1.c_str() << endl;//打印@hello @world
  s1.insert(0, "xxxx");
  cout << s1.c_str() << endl;//打印xxxx@hello @world
  s1.earse(0, 4);//删除
  cout << s1.c_str() << endl;//打印@hello @world
  s1.earse(5);
  cout << s1.c_str() << endl;//打印@hell
}

//流插入
void test_string88()
{
  /*mys::string s1("hello world");
  cout << s1 << endl;*/
  mys::string s2;
  cin >> s2;
  cout << s2 << endl;
}

//注意resize的使用 
void test_string99()
{
  mys::string s3("hello word");
  s3.resize(20, 'x');
  cout << s3.c_str() << endl;//打印hello worldxxxxxxxxx

  s3.resize(14, 'x');
  cout << s3.c_str() << endl;//打印hello worldxxx

  s3.resize(5, 'x');
  cout << s3.c_str() << endl;//打印hello 注意容量小 会筛数据
}

总结：

1. string是表示字符串的字符串类

2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作

3. string在底层实际是：basic_string模板类的别名，typedef basic_string string;

4. 不能操作多字节或者变长字符的序列

5.string类，本质是一个模板，是管理动态增长的字符数组，以 \0 结尾

希望这篇文章大家有所收获，我们下篇见

小圣编程
关注
  • 18
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 16
    评论
专栏目录
C++学习笔记(十)——String类
m0_58367586的博客
04-20 1356
前言 今天我们来学习string类,读完本文不仅可以掌握string类的用法，还可以很轻松的解决下面问题: 917. 仅仅反转字母 - 力扣（LeetCode） (leetcode-cn.com) 387. 字符串中的第一个唯一字符 - 力扣（LeetCode） (leetcode-cn.com) 字符串最后一个单词的长度_牛客题霸_牛客网 (nowcoder.com) 125. 验证回文串 - 力扣（LeetCode） ..
c++ string操作总结
清舞 点滴
07-11 290
1、初始化2、赋值3、字符串处理4、查找5、比较6、转换
erase函数的用法
C20190733_ZT的博客
09-21 1784
许多童鞋在做题的时候，为了让后面的字符前进一位，所以把后面的字符依次向前提一位，每次都要写一个循环，有没有更简单的方法呢？ 当然有啦。就是STL中(只能string用)的erase函数。 erase函数的用法就是a(字符串名).erase(x(开始删除的字符下标),y(删除的字符串长度)) 这个erase适用于去掉前导零: while(s[0]=='0'&&s[1]) s.erase(0
c++：insert函数和erase函数的简介
qq_62718027的博客
07-07 3435
原型： 好吧，是不是看不明白，我们举例说明，一般insert有如下三个使用情况在指定位置it前“插入”值为val的元素,返回指向这个元素的迭代器, 结果如下： 在指定位置it前“插入”num个值为val的元素 结果如下 在指定位置it前“插入”区间[first, last)的所有元素.first，last，it都是迭代器 结果如下 也是三种用法删除从下标pos开始的n个字符 结果如下删除postion处的一个字符，postion是迭代器 结果如下：删除从first到last
C++ STL学习笔记
moutain9426的博客
07-26 218
STL常用函数vectorstringsetmapstackarraydequealgorithm vector string set 头文件 #include<set> 常用函数： 函数 功能 insert() 插入元素 s.count(x) 对set，若集合 s 包含 x 则返回 true；对multiset，返回set中x的个数 s.erase(x) 删除所有元素x s.erase(iter) 删除iter指向的元素x s.find(x) 返回一个指针，表
C++常用笔记 （升级版）
最新发布
02-25
根据给定的文件信息，以下是对C++常用知识点的详细解析： ### 1. 头文件 #### #include - **功能**: `stdio.h` 是标准输入输出库，提供基本的输入输出功能。 - **示例**: `printf`, `scanf` #### #include - **...
《C++ Primer》学习笔记（24）类
07-21
### 《C++ Primer》学习笔记（24）：深入理解类 #### 7.4 类的作用域(Class Scope) 在C++中，类定义了自己的作用域。类成员（包括数据成员和成员函数）只能在该类的作用域内访问。下面通过具体的示例来解释这一...
C++整理笔记word版——01 C++学习笔记
12-05
- 字符串：使用字符数组`char str[] = "string"`或`std::string`类 - 布尔型：`bool`，占1字节，代表真（true，1）或假（false，0） 7. **运算符**： - 算术运算符：`+`、`-`、`*`、`/`、`%` - 赋值运算符：`=`...
C++primer 笔记章节版.docx
12-31
- **字符串**：在C++中，字符串可以用字符数组表示，也可以使用标准库中的`std::string`类来处理。 - **string类简介**：`std::string`提供了许多便利的方法，如拼接、查找、替换等，简化了字符串操作。 - **结构...
c++面向对象设计笔记
06-14
本笔记涵盖了C++面向对象设计的基本概念和技术，包括面向对象程序设计的基本原则、类和对象、继承和多态、运算符重载、C++语言的基本语法元素等。 1.1 主要内容 本节介绍了C++语言的基本概念，包括课程简介、C++...
C++中erase函数的用法
贾作真时真亦贾的博客
07-31 6196
erase函数是一个删除容器中元素的函数，包括顺序容器和关联容器。 基本用法如下： container.erase(p)-----从container中删除迭代器p指定的元素，p必须指向c中的一个真实元素，不能等于container.end() container.erase(b,d)------从container中删除迭代器对b和d所表示的范围中的元素，返回d所在下标。 具...
string的erase用法
永远鲜红の幼月的博客
04-18 6904
对于string，erase是一个很重要的一个用法，现在总结一下，以便日后查阅：1.首先是删除该位置的字符：s.erase（string：：iterator it）；删除it的下一个元素；例如删除最后的一位的字符：int main() { string s; s="abcdefg"; s.erase(s.end()-1);//运行结果：abcdef cout&lt;&lt;s&lt;&lt...
使用stl::string去除字符串前后的空白
weixin_30823833的博客
12-16 607
erase函数的原型如下：（1）string& erase ( size_t pos = 0, size_t n = npos );（2）iterator erase ( iterator position );（3）iterator erase ( iterator first, iterator last );也就是说有三种用法：（1）erase(pos,n); 删除从po...
C++ string erase //适用于所有C++ 容器
ChenLI's blog
06-21 546
erase函数的原型如下： （1）string& erase ( size_t pos = 0, size_t n = npos ); （2）iterator erase ( iterator position); （3）iterator erase ( iterator first, iterator last); 也就是说有三种用法： （1）erase(pos,n); 删除从
erase()函数
热门推荐
如梦山河的博客
08-28 5万+
前面的文章中提到过如何向容器中添加元素，这里介绍一个如何删除容器中元素的函数，包括顺序容器和关联容器。 就是这个erase函数，基本用法如下： c.erase( p)------------------------------从c中删除迭代器p指定的元素，p必须指向c中的一个真实元素，不能等于c.end() c.erase(b,e)----------------------------从c中删除...
信息学奥赛第二节 —— 字符串2(s.find() + s.substr() + s.erase() + s.insert() + s.replace())
smallrain6的博客
04-04 1796
前言 接上次文章，以一道例题开始本文。本题需要读者自行了解一下什么是字典序。在这里简单介绍一下字典序的比较：hello > hell 、 hello < hellp 练习1 原题链接 题目描述 编写程序，针对输入的N个不同的字符串，输出其中字典码最小的字符串。 输入 输入第一行给出正整数N；随后N行，每行给出一个长度小于80的非空字符串，其中不会出现换行符，空格，制表符。 输出 输出字典码最小的字符串 样例输入 5 Li Wang Zha Jin Xian 样例输出 Jin
如何运用C++ set 附例题（set中erase函数、iterator迭代器）
Zhengyangxinn的博客
04-22 2236
set在解决算法题上是十分实用的！
C++ erase的用法
我不会编程，但不是完全不会，我会一点点
11-09 5407
STL中list的erase用法 erase的作用是，使作为参数的迭代器失效，并返回指向该迭代器下一参数的迭代器。 如下： listParticleSystem; list::iteratorpointer; if(pointer->dead == true) {    pointer =ParticleSystem.erase(pointer); }   有一段关于错误使用e
删除C++ string中的所有空格------我爱用erase方法（有坑）
sjhfkhsf的博客
01-28 643
删除C++ string中的所有空格------我爱用erase方法（有坑）
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值