devbox
酷酷是懒虫
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++的STL简介（一）_c++stl库

作者：酷酷是懒虫 | 2024-08-04 00:00:45

赞

踩

c++stl库

目录

1.什么是STL

2.STL的版本

3.STL的六大组件

 4.string类

4.1为什么学习string类？

4.2string常见接口

4.2.1默认构造

​编辑

4.2.2析构函数

 Element access:

4.2.3 []

4.2.4迭代器

​编辑

 auto

 4.2.4.1 begin和end

 4.2.4.2.regin和rend

Capacity:

 4.2.5.3 size

4.2.6 lenth 

4.2.7 cleart

Modifiers:

4.2.7 apend

4.2.8  +=

4.2.9 erase

4.2.10 replace

 String operations:

 4.2.11 find

4.2.12 substr

4.2.13  find_first_of

4.2.14  find_ last_of

4.2.15 find_first_not_of

 4.2.16 find_last_not_of

1.什么是STL

STL（standarf template libaray-标准模板库）：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。

2.STL的版本

  • 原始版本

Alexander Stepanov MengLee 在惠普实验室完成的原始版本，本着开源精神，他们声明允许任何人任意运用，拷贝，修改，传播，商业使用这些代码，无需付费。唯一的条件就是也需要向原始版本一样做开源使用。HP版本--所有STL实现版本的始祖。

  • P.J.版本

由P.J.Plauger开发，继承自HP版本，被Windows Visual C++采用，不能公开或修改，缺陷：可读性比较低，符号命名比较怪异。

  • RW版本

由Rouge Wage 公司开发，继承自HP版本，被C++ Builder 采用 ，不能公开或修改，缺陷：可读性一般

  • SGL版本

由Silicon Graphics Computer Systems ，Inc公司开发，继承自HP版本。被GCC(Linux)采用，可移植性较好，可公开，修改甚至贩卖，从命名风格和编程风格上看，阅读性非常高。

3.STL的六大组件

 4.string类

4.1为什么学习string类？

C语言中，字符串是以"\0"结尾的一些字符的集合，为了方便操作，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。而且在常规工作中，为了简单，方便，快捷，基本都使用string类，很少有人使用C库中的字符串操作函数

4.2string常见接口


4.2.1默认构造

实例

  1. 	//无参构造
  2.     //string();
  3. 	  string s1;
  4.  
  5. 	 //带参构造
  6. 	string s2("111");
  7. 	//string(const char* s);	
  8. 	 
  9. 	//拷贝构造
  10. 	string s3(s2);
  11.  //string(const string & str);
  12.  
  13. 	string s4("123", 2, 1);
  14. 	 //string(const string & str, size_t pos, size_t len = npos);
  15. 	//复制str中从字符下标位置 pos 开始的len个 字符进行拷贝构造（如果任一 str 太短或 len 为 string::npos，则复制到str 的末尾）。
  16. 	string s5("123",0 ,string:: npos);
  17.  
  18. 	//	string(const char* s, size_t n);
  19. 	string s6("123", 2);
  20. 	//从 s 指向的字符数组中复制前 n 个字符。
  21.  
  22. 	
  23. 	
  24. 		//string(size_t n, char c);
  25. 	//用连续的n个c字符去初始化
  26. 	string s7(3, 'c');
  27.  
  28. 		//template <class InputIterator>
  29. 	//string(InputIterator first, InputIterator last);
4.2.2析构函数

 Element access:

4.2.3 []

获取字符串的字符

 利用[]来进行读写，下标+[]遍历

  1. int main()
  2. {   
  3. 	string s1("abcd");
  4. 	//写
  5. 	s1[0] ='*';
  6. 	 //将下标为0的元素修改为1
  7. 	cout << s1 << endl;
  8. 	//读
  9. 	 for (int i = 0; i < s1.size(); i++)
  10. 	 {
  11. 		 cout << s1[i] ;
  12. 	 }
  13. 	return 0;
  14. }

 

[]原型

  1. class string
  2. {
  3.  
  4. public:
  5. char&	operator[](size_t i)
  6. 	{
  7. 		return _str[i];
  8. 	}
  9. private:
  10. 	char* _str;
  11. 	size_t _size;
  12. 	size_t _capacity;
  13. };
4.2.4迭代器

在 STL 中，迭代器（Iterator）用来访问和检查 STL 容器中元素的对象，它的行为模式和指针类似，但是它封装了一些有效性检查，并且提供了统一的访问格式。他的底层是指针

迭代器遍历

  1. int main()
  2. {   
  3. 	string s1("abcd");
  4. 	string::iterator it = s1.begin();
  5. 	while (it != s1.end())
  6. 	{
  7. 		cout << *it <<" " ;
  8. 		++it;
  9. 	}
  10. 	return 0;
  11. }
 auto

补充一个C++小语法

auto可自动推导类型，极大程度简化代码

  1. const string s3("hello ward!");
  2.  
  3. //string::const_iterator cit=s3.begin(); 可简写成：
  4. auto cit = s3.begin();

 auto声明方式

auto  变量名 ；

auto  函数名 (形参列表)

{

//函数体

}

 auto的实例

  1. int fun()
  2. {
  3. 	return 10;
  4. }
  5. int main()
  6. {
  7. 	int a=10;
  8. 	auto b = a;
  9. 	auto c = 'a';
  10. 	auto d = fun();
  11. 	auto& e = a;
  12. 	auto* f = &a;
  13.  
  14. 	cout << typeid(a).name() << endl;
  15. 	cout << typeid(b).name()<< endl;
  16. 	cout << typeid(c).name() << endl;
  17. 	cout << typeid(d).name() << endl;
  18. 	cout << typeid(e).name() << endl;
  19. 	cout << typeid(f).name() << endl;
  20. 	return 0;
  21. }

  • 在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储的局部变量，后来这个不重要了，C++11中，标准委员会被废为宝赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得
  • 用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时必须加&
  • 当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量
  • auto不能作为函数的参数，可以做返回值，但是谨慎使用
  • aoto不能直接用来声明数组

范围for遍历

 aoto自动推导，字符赋值，自动迭代，自动判断结束，底层上也是迭代器，所有的容器都支持范围for，因为所有的容器都支持迭代器

 4.2.4.1 begin和end

 1.begin

 返回第一个字符的正向迭代器

  1. int main()
  2. {   
  3. 	string s1("abcd");
  4. 	cout<<* s1.begin();
  5. 	return 0;
  6. }

 

2. end 返回最后一个字符的正向迭代器

 可配合起来正向遍历

  1. int main()
  2. {
  3. 	string s1("abcdef");
  4. 	string::const_iterator it = s1.begin();
  5. 	while (it != s1.end())
  6. 	{
  7. 		cout << *it << " ";
  8. 		it++;
  9. 	}
  10. 	return 0;
  11. }

 

 4.2.4.2.regin和rend

regin 返回最后一个的反向迭代器

 rend 返回第一个字符的反向迭代器

配合起来可支持反向遍历

  1. int main()
  2. {
  3. 	string s1("abcdef");
  4. 	string::const_reverse_iterator it = s1.rbegin();
  5. 	while (it != s1.rend())
  6. 	{
  7. 		cout << *it << " ";
  8. 		it++;
  9. 	}
  10. 	return 0;
  11. }

 

Capacity:

 4.2.5.3 size

 返回字符串的长度，不包括'\0'

  1. int main()
  2. {   
  3. 	string s1("abcd");
  4. 	cout << s1.size();
  5. 	return 0;
  6. }

4.2.6 lenth 

  返回以字节为单位的长度，不包括"\0"

  1. int main()
  2. {
  3. 	string s1("abcdef");
  4.  
  5. 	cout << s1.length()<<endl;
  6.  
  7. 	return 0;
  8. }

 

4.2.7capacity

l返回容量大小

 

 4.2.7reserve

保留预留，提前开空间，避免扩容，提高效率

  1. int main()
  2. {
  3. 	string s1("abcdef");
  4. 	cout << s1.capacity() << endl;
  5.  
  6. 	s1.reserve(100);
  7. 	cout << s1.capacity()<<endl;
  8. 	//可以扩容，>=100
  9. 	s1.reserve(50);
  10. 	cout << s1.capacity() << endl;
  11. 	//一般不会缩容
  12. 	return 0;
  13. }

4.2.7 cleart

清除数据，一般不清除容量

  1. int main()
  2. {
  3. 	string s1("abcdef");
  4. 	
  5. 	cout << s1.capacity() << endl;
  6. 	cout << s1.size() << endl;
  7.  
  8. 	s1.clear();
  9. 	cout << s1.capacity() << endl;
  10. 	cout << s1.size() << endl;
  11. 	//一般不会缩容
  12. 	return 0;
  13. }

 

Modifiers:

4.2.7 apend

字符串追加

  1.  
  2. int main()
  3. {
  4. 	string s1("abcdef");
  5. 	//string& append(const string & str);
  6.  
  7. 	s1.append("yyy");
  8. 	cout << s1 << endl;
  9. 		
  10. 	//	string& append(const string & str, size_t subpos, size_t sublen);
  11. //追加 str 子字符串的副本。子字符串是 str 中从字符位置 subpos 开始并跨越 sublen 字符的部分（或者直到 str 的末尾，如果任一 str 太短或 sublen 是 string：：npos）。
  12. 	s1.append("aaaa", 2, 1);
  13. 	cout << s1 << endl;
  14. 		
  15. 	return 0;
  16. }

 

4.2.8  +=

字符串拼接，尾插

  1. int main()
  2. {
  3. 	string s1("abcdef");
  4. 	string s2("123");
  5. 	
  6. 	//string& operator+= (const string & str);
  7. 	s1 += s2;
  8.  
  9. 	s1 += 'a';
  10. //string& operator+= (char c);
  11.  
  12. 	s1 += "aaa";
  13. //string & operator+= (const char* s);
  14. 	
  15. 	return 0;
  16. }
  1. int main()
  2. {
  3. 	string s1("abcdef");
  4. 	string s2("123");
  5. 	
  6. 	//string& insert(size_t pos, const string & str);
  7. 	// 在pos之前插入str
  8. 	s1.insert(0, "abc");
  9. 	
  10. 		//string& insert(size_t pos, const string & str, size_t subpos, size_t sublen);
  11. 	//在下标pos位置之前插入str下表中subpos到下标sublen位置的元素
  12. 	s2.insert(0, "abcdd", 0, 4);
  13. 	cout << s2 << endl;
  14. 		//string & insert(size_t pos, const char* s);
  15. 	//在pos位置之前插入s
  16. 	
  17. 		//string& insert(size_t pos, const char* s, size_t n);
  18. 	//从在下标为pos的位置插入s的n个字符
  19.  
  20. 		//string& insert(size_t pos, size_t n, char c);
  21. 		//在pos位置之前插入n个c字符
  22. 		 
  23. 	//void insert(iterator p, size_t n, char c);
  24. 	//在迭代器的位置之前插入n个字符c
  25. 	 
  26. 		//iterator insert(iterator p, char c);
  27. 	//在迭代器的位置之前插入字符c
  28. 	s1.insert(s1.begin(), '*');
  29.  
  30.  
  31. 	cout << s1 << endl;
  32. 	return 0;
  33. }
4.2.9 erase

头删

  1. int main()
  2. {
  3. 	string s1("abcdef");
  4. 	string s2("123");
  5. 	
  6. 	//string& erase(size_t pos = 0, size_t len = npos);
  7. 	//擦除字符串值中从字符位置 pos 开始并到 len 字符的部分不包括len（如果内容太短或 len 为 string：：npos，则擦除字符串值的末尾。
  8. 	s1.erase(0, 2);
  9. 	
  10.  
  11. 		//iterator erase(iterator p);
  12. 	//擦除 p 指向的字符。
  13. 	s1.erase(s1.begin());
  14.   
  15. 		//iterator erase(iterator first, iterator last);
  16. //擦除[first，last] 范围内的字符序列
  17. 	s1.erase(s1.begin(), s2.end());
  18. 	
  19. 	cout << s1 << endl;
  20.  
  21. 	return 0;
  22. }
4.2.10 replace

替换

  1. int main()
  2. {
  3. 	string s1("abcdef");
  4. 	string s2("123");
  5.  
  6. 			//string & replace(size_t pos, size_t len, const char* s);
  7. 	//string& replace(size_t pos, size_t len, const string & str);
  8. 	//把pos位置到len位置替换成str
  9. 	
  10. //string& replace(iterator i1, iterator i2, const char* s);
  11. 	//string& replace(iterator i1, iterator i2, const string & str);
  12. 	//把i1到i2之间的迭代器换成str
  13. 		
  14. 	//string& replace(size_t pos, size_t len, size_t n, char c);
  15. 		//string& replace(size_t pos, size_t len, const char* s, size_t n);
  16. 	//把pos位置到len位置替换成str中的前n个
  17.  
  18. 	
  19. 		//string& replace(iterator i1, iterator i2, const char* s, size_t n);
  20. 	//把i1到i2之间的迭代器换成str中的前n个
  21.  
  22. 	
  23. 		
  24. 	//string& replace(iterator i1, iterator i2, size_t n, char c);
  25. 	 //把i1到i2之间的迭代器换成n个字符c
  26. 		
  27. 		 
  28. 	//string& replace(iterator i1, iterator i2,
  29. 		//InputIterator first, InputIterator last);
  30. 	//将迭代器输入到范围内的初始位置和最终位置。使用的范围是 [first，last），它包括 first 和 last 之间的所有字符，包括 first 指向的字符，但不包括 last 指向的字符
  31.  
  32.  
  33. 	return 0;
  34. }

 String operations:

 4.2.11 find

查找

返回第一个匹配的第一个字符的位置。
如果未找到匹配项，该函数将返回 string：：npos。（整型最大值）

  1. int main()
  2. {
  3. 	string s1("abcdef");
  4. 	string s2("123");
  5.  
  6. 	//size_t find(const string & str, size_t pos = 0) const;
  7. 	 s1.find("bce");
  8.  
  9. 	//	size_t find(const char* s, size_t pos = 0) const;
  10. 	 //在pos位置找s
  11. 	 s1.find('a');
  12. 	//	size_t find(const char* s, size_t pos, size_t n) const;
  13. 	 //从pos位置找s的前n个
  14. 	cout<< s1.find("aaa", 1, 2);
  15. 	 
  16. 	//	size_t find(char c, size_t pos = 0) const;
  17. 	//从pos位置开始搜索字符c
  18. 	return 0;
  19. }
4.2.12 substr

获得对于位置以后的子串然后重新构成string类返回

  1. int main()
  2. {
  3. 	string s1("abcdef");
  4.  
  5. 	//tring substr(size_t pos = 0, size_t len = npos) const;
  6. 	//从pos位置开始的len个字符重新构建成string再返回
  7. 	s1.substr(3, 4);
  8.  
  9. 	
  10. 	return 0;
  11. }

实例

  1. int main()
  2. {
  3. 	string s("text.cpp");
  4.  
  5. 	size_t pos = s.rfind('.');
  6. 	string suffix = s.substr(pos);
  7. 	cout << suffix << endl;;
  8.  
  9. 	return 0;
  10. }

 

4.2.13  find_first_of

顺着找字符串中的字符，找到返回第一个出现的下标

  1.  
  2. int main()
  3. {
  4. 	string s1("abcdef");
  5. 	//ze_t find_first_of(const string & str, size_t pos = 0) const;
  6. 	//ize_t find_first_of(const char* s, size_t pos = 0) const;
  7. 	//ize_t find_first_of(char c, size_t pos = 0) const;
  8. 	//在pos位置开始找str中的字符
  9. 	
  10. 	s1.find_first_of("abc");
  11. 	//ize_t find_first_of(const char* s, size_t pos, size_t n) const;
  12. 	//在pos位置找s的前n个
  13. 	
  14. 	
  15. 	return 0;
  16. }
4.2.14  find_ last_of

倒着找字符串中的字符，找到返回第一个出现的下标

  1. int main()
  2. {
  3. 	string s1("abcdef");
  4. 	//size_t find_last_of(const string & str, size_t pos = npos) const;
  5. 	// //size_t find_last_of(char c, size_t pos = npos) const；
  6. 	// size_t find_last_of(const char* s, size_t pos = npos) const;
  7. 	//从最后一个位置向前找str中的字符
  8. 	 
  9. 	s1.find_last_of("Abc",2,4);
  10. 		//size_t find_last_of(const char* s, size_t pos, size_t n) const;
  11. 	//从最后一个位置向前找str中的n个字符
  12. 		
  13. 	
  14. 	return 0;
  15. }

 分割文件

  1. void SplitFilename(const std::string & str)
  2. 	{
  3. 		std::cout << "Splitting:" << str << endl;
  4. 		std::size_t found = str.find_last_of(" / \\");
  5.  
  6. 		std::cout << "path:" << str.substr(0, found) << endl;
  7. 		std::cout << "file:" << str.substr(found + 1) << endl;
  8. 	}
  9. int main()
  10. {
  11. 	
  12. 	string str1("windows\\winhelp.exe");
  13. 	string str2("/url/bin/man");
  14.  
  15. 	SplitFilename(str1);
  16. 	cout << endl;
  17. 	SplitFilename(str2);
  18. 	return 0;
  19. }

4.2.15 find_first_not_of

没找到就返回，顺着找返回第一个不匹配的对应下标

  1. int main()
  2. {
  3. 	string s1("abcdef");
  4. 	//size_t find_first_not_of(const string & str, size_t pos = 0) const;
  5. 		//size_t find_first_not_of(const char* s, size_t pos = 0) const;	
  6. 		// //size_t find_first_not_of(char c, size_t pos = 0) const;
  7. 	//从第一个位置向前找str中的n个字符找到第一个不匹配的元素下标，找不到就返回
  8. 	// 
  9. 		//size_t find_first_not_of(const char* s, size_t pos, size_t n) const;
  10. 	//从第一个位置向后找中第一个不匹配的字符str中的前n个的字符
  11. 	
  12. 	
  13. 	return 0;
  14. }

实例

  1. int main()
  2. {//
  3. 	string str("Please, replace the vowels in this sentence by asterisks.");
  4. 	//除了"abcdef"以外全部替换成*
  5. 	std::size_t found = str.find_first_not_of("abcdef");
  6. 	while (found != std::string::npos)
  7. 	{
  8. 		str[found] = '*' ;
  9. 		found = str.find_first_not_of("abcdef", found + 1);
  10. 	}
  11. 	std::cout << str;
  12. 	return 0;
  13. }

 

 4.2.16 find_last_not_of

倒着找，找到第一个不匹配返回下标

  1. int main()
  2. {
  3. 	//ize_t find_first_not_of(const string & str, size_t pos = 0) const;
  4. 	//	size_t find_first_not_of(const char* s, size_t pos = 0) const;
  5. 	//size_t find_first_not_of(char c, size_t pos = 0) const;
  6. 	// 从最后一个位置向前找第一个不匹配str中的字符的下标
  7. 	
  8. 		//size_t find_first_not_of(const char* s, size_t pos, size_t n) const;
  9. 	//从最后一个位置向前找第一个不匹配str中的前n个字符的下标,找不到就返回
  10. 		
  11. 	return 0;
  12. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/酷酷是懒虫/article/detail/925419
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号