C++面向对象程序设计(八)——标准模板库STL(一)

举报
陈沧夜 发表于 2022/04/29 22:28:55 2022/04/29
【摘要】 C++面向对象程序设计(八)——标准模板库STL(一) 文章目录 C++面向对象程序设计(八)——标准模板库STL(一)string类字符串流处理标准模板库STL概述(一)基本概念顺序容器`ve...

C++面向对象程序设计(八)——标准模板库STL(一)


程序设计与算法C++面向对象程序设计 github仓库

string类

来自模板类typedef basic_string<char> string

在使用前要包含头文件<string>

#include<iostream>
#include<string>
using namespace std;

int main()
{
    string s1("hello");
    cout << s1 <<endl;
    string s2(8,'x');
    cout << s2 <<endl;
    string month = "March";
    cout << month << endl;
    string s;
    s = 'n';
    cout << s<<endl;
    return 0;
}
//输出:
//Hello
//xxxxxxxx
//March
//n    

  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

可以使用成员函数length()读取长度,支持cingetline(cin,s)

可以使用=赋值,使用assign成员函数复制

string s1("cat"),s2;
s2 = s1;

  
 
  • 1
  • 2
string s1("cat"),s3;
s3.assign(s1);

  
 
  • 1
  • 2
string s1("catpig"),s3;
s3.assign(s1,1,3);

  
 
  • 1
  • 2

单个字符的复制

s2[5] = s1[3] ='a';

  
 
  • 1

逐个访问对象中字符

string s1("Hello");
for(int i = 0;i<s1.length();i++)
    cout<<s1.at(i)<<endl;
//成员函数at会做范围检查,如果超出范围会出现out_of_range异常,而[]不会检查

  
 
  • 1
  • 2
  • 3
  • 4

可以使用+运算符连接字符串

string s1("good"),s2("morning");
s1 += s2;
cout << s1;

  
 
  • 1
  • 2
  • 3

用成员函数append连接字符串

string s1("good"),s2("morning");
s1.append(s2);
cout << s1;
s2.append(s1,3,s1.size());
cout << s2;

  
 
  • 1
  • 2
  • 3
  • 4
  • 5

string间可以比较大小>=

还可以使用compare比较string大小

求子串substr

string s1("hello world"),s2;
s2 = s1.substr(4,5)//下标4开始长度5个字符
cout << s2 << endl; 

  
 
  • 1
  • 2
  • 3

交换swap

s1.swap(s2);//两个字符串内容交换

  
 
  • 1

正着查找find

s1.find("lo");
s1.find("lo",2);//下标2开始找

  
 
  • 1
  • 2

倒着查找rfind

s1.rfind("lo");

  
 
  • 1

find_first_of

s1.find_first_of("abcd");//从前向后查找abcd中任意一个第一次出现的地方

  
 
  • 1

find_last_of

s1.find_last_of("abcd")//查找最后一次出现的地方

  
 
  • 1

find_first_not_of

s1.find_first_not_of("abcd");//从前向后查找不在abcd中的字符任意一个第一次出现的地方

  
 
  • 1

删除string中的字符使用成员函数erase()

s1.erase(5);//去掉下标5及之后的字符

  
 
  • 1

替换string中的字符

成员函数replace()

s1.replace(2,3,"haha");//将下标2开始的3个字符换成"haha"

  
 
  • 1

成员函数insert()

s1.insert(5,s2)//s2插入到下标5的位置

  
 
  • 1

成员函数c_str()

转换成C语言式的char *字符串

s1.c_str();	//返回const char  *

  
 
  • 1

成员函数data

返回char *字符串,不带const

字符串流处理

我们可以使用istringstreamostringstream进行字符串上的输入输出,也称为内存输入输出

#include<string>
#include<iostream>
#include<sstream>

string input("Input test 123 4.7 A");
istringstream inputString(input);
string string1,string2;
int i;
double d;
char c;
inputString >> string1 >> string2 >> i >>d >>c;
cout << string1 << endl <<string2 <<endl;
cout << i <<endl <<d <<endl <<c <<endl;
long L;
if(inputString >> L) cout <<"long\n";
else cout << "empty\n";

/*输出
Input
test
123
4.7
A
empty
*/

  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
ostringstream outputString;
int a =10;
outputString << "This" << a << "ok" << endl;
cout << outputString.str();
/*
输出
This 10ok
*/

  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

标准模板库STL概述(一)

C++语言的核心优势之一就是软件的重用

主要体现在:面向对象的思想:继承,多态,标准类库

泛型程序设计思想 :模板机制,STL

基本概念

容器:可容纳各种数据类型的通用数据结构,是类模板

容器分为三种

顺序容器vector,deque,list

vector 动态数组

头文件<vector>

元素在内存中连续存放,随机存取任何元素都能在常数时间完成。在尾端增删元素具有较佳性能

deque 双向队列

元素在内存连续存放。随机存取任何元素都能在常数时间完成。在两端增删元素具有较佳性能

list 双向链表

元素在内存不连续存放。在任何位置增删元素都能在常数时间完成,不支持随机存取

关联容器set,multiset,map,multimap

元素是排序的,插入任何元素都按相应的排序规则来确定其位置。

在查找时具有良好的性能

通常以平衡二叉树方式实现,插入和检索时间都是logN

set/multiset 集合

头文件,set中不允许相同元素,multiset允许存在相同的元素

map/multimap

map与``set的不同在于map中存放的元素有且仅有两个成员变量,一个名为first,另一个名为second,map根据first`值对元素进行小到大排序,可快速根据first检索元素

map与``multimap的不同在于是否允许相同的firsr`值的元素

容器适配器stack,queue,priority_queue

stack 栈

头文件 是项的有限序列,满足序列中被删除,检索和修改的项只能是最近插入序列的项。后进先出

queue 队列

插入只可以在尾部进行,删除,检索和修改只允许从头部进行。先进先出

priority_queue

头文件

优先级队列,最高优先级元素总是第一个出列

对象被插入容器中时,被插入是对象的一个复制品。许多算法,比如排序,查找,要求对容器中的元素进行比较,有的容器本身是排序的,所以放入容器对象所属的类,往往还应该重载==<运算符

顺序容器和关联容器中都有的成员函数

begin返回指向容器中第一个元素的迭代器

end返回指向容器中最后一个元素后面的位置的迭代器

rbegin返回指向容器中最后一个元素的迭代器

rend返回指向容器中第一个元素前面的位置的迭代器

erase从容器中删除一个或几个元素

clear从容器中删除所有元素

顺序容器的常用成员函数

front返回容器中第一个元素的引用

back返回容器中最后一个元素的引用

push_back在容器末尾增加新元素

pop_back删除容器末尾的元素

erase删除迭代器指向的元素,或删除一个区间,返回被删除元素后面那个元素的迭代器

迭代器:可用于依次存取容器中元素,类似于指针

算法:用来操作容器中元素的函数模板

迭代器

容器类名::iterator 变量名;
容器类名::const_iterator 变量名;

  
 
  • 1
  • 2

访问一个迭代器指向的元素:

* 迭代器变量名

  
 
  • 1

用于指向顺序容器和关联容器中的元素。用法和指针类似。有const和非const两种。通过迭代器可以读取它指向的元素。通过非const迭代器能修改其指向的元素。迭代器可以执行++操作

#include<venctor>
#include<iostream>
using namesapce std;

int main()
    vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	vector<int>::const_iterator i;
	for(i = v.begin();i != v.end();++i)
        cout << *i << ",";
	cout << endl;
	vector<int>::reverse_iterator r;
	for( r =v.rbegin();r != v.rend(); r++)
        cout << * r <<",";
	cout<<endl;
	vector<int>::iterator j;
	for(j=v.begin();j!=v.end();j++)
        *j = 100;
	for(i=v.begin();i!=v.end();i++)
        cout << * i <<",";
}

/*输出结果
1,2,3,4,
4,3,2,1,
100,100,100,100,

  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

双向迭代器

++p,p++使p指向容器中下一个元素

–p,p--是p指向容器中上一个元素

*p取p指向的元素

p = p1赋值

p == p1,p! = p1判断是否相等,不等

随机访问迭代器

双向迭代器所有操作都可以使用

p+=ip向后移动i个元素

p-=ip向前移动i个元素

p+i值为指向p后面第i个元素的迭代器

p-i值为指向p前面的第i个元素的迭代器

p[i]值为p后面的第i个元素的引用

p<p1,p<=p1,p>p1,p>=p1

容器 容器上迭代器类别
vector 随机访问
deque 随机访问
list 双向
set/multiset 双向
map/multimap 双向
stack 不支持
queue 不支持
priority_queue 不支持

vector迭代器是随机迭代器

遍历vector的几种做法(queue同)

vector<int> v(100);
int i;
for(i=0;i<v.size();i++)
    cout << v[i];//根据下标随机访问
vector<int>::const_iterator ii;
for(ii = v.begin();ii != v.end();ii++)
    cout << *ii;
for(ii = v.begin();ii<v.end();ii++)
    cout << *ii;

  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

list迭代器是双向迭代器

list<int> v;
list<int>::const_iterator ii;
for(ii = v.begin;ii!=v.end();++ii)
    cout << *ii;

  
 
  • 1
  • 2
  • 3
  • 4

双向迭代器不支持<,list没有[]成员函数

算法

是一个个函数模板,往往在中定义

find()

template<class InIt,class T>
InIt	find(InIt first,InIt last,const T&val);

  
 
  • 1
  • 2

查找区间是[first,last),用==判断相等

#include<vector>
#include<algorithm>
#include<iostream>

using namespace std;

int main()
{
    int array[10] = {10,20,30,40};
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    vector<int>::iterator p;
    p = find(v.begin(),v.end(),3)
    if(p!=v.end())
        cout << *p << endl;//输出3
   	p = find(v.begin(),v.end(),9);
    if(p==v.end())
        cout << 'not found'<<endl;
    p = find(v.begin()+1,v.end()-2,1);
    if(p!=v.end())
        cout << *p <<endl;
    int * pp = find(array,array+4,20);
    cout << *pp << endl;
    
}

  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

vector

vector实现二维数组

vector<vector<int> >v(3);

  
 
  • 1

deque双向队列

所有vector的操作都适合dequedeque还有push_frontpop_front操作

list双向链表

不支持随机存取,任何位置插入删除都是常数时间

push_front在前面插入

pop_front删除前面元素

sort排序

remove删除和指定值相等的所有元素

unique删除和前一个元素相同的元素

merge合并两个链表,并清空被合并的那个

reverse颠倒链表

splice指定位置前面插入另一个链表的一个或多个元素,并在另一个链表中删除被插入的元素

函数对象

若一个类重载了运算符(),那么该类的对象就是函数对象

class CMyAverge{
    public:
    	double operator() (int a1,int a2,int a3)
        {
            return (double)(a1+a2+a3)/3;
        } 
    CMyAverage average;
    cout << average(3,2,3);
}

  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

文章来源: blog.csdn.net,作者:沧夜2021,版权归原作者所有,如需转载,请联系作者。

原文链接:blog.csdn.net/CANGYE0504/article/details/105908414

【版权声明】本文为华为云社区用户转载文章,如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。