精华内容
下载资源
问答
  • C++STL库开发文档

    2020-11-25 14:04:44
    查询一些熟悉又陌生的方法的参数与返回值、
  • c++中常用模板头文件及其源代码,例如<stl_queue.h>,<stl_vector.h>,<stl_map.h>等
  • C++模板与STL库介绍

    2019-03-18 16:16:29
    C++模板与STL库介绍 非常详细
  • STL的相关概念 STL( Standard Template Library ) 是一个具有工业强度的高效的C++程序 被容纳于C++标准程序(C++ Standard Library)中是ANSI / ISO C++ 标准中极具革命性的一部分 包含了诸多在计算机科学领域里所...
  • c++ STL 使用示例

    2018-04-18 13:18:42
    C++ STL库使用示例, 包含了基本上所有C++库函数使用, 是C++开发常用必备手册
  • C++ STL库应用汇总

    2020-08-24 22:17:05
    在本篇文章里小编给大家整理的是关于C++ STL库应用集合,有需要的朋友们可以参考下。
  • 集合C标准库、glibc库,多个版本的stl库的实现源代码,这里留个存档,方面后面研究学习....................
  • STL库简介

    万次阅读 多人点赞 2019-03-29 18:11:23
    STL是c++中的一个标准模板,作为C++标准不可缺少的一部分,STL应该是渗透在C++程序的角角落落里的。STL不是实验室里的宠儿,也不是程序员桌上的摆设,她的激动人心并非昙花一现。本教程旨在传播和普及STL的基础...

    一、前言

    STL是c++中的一个标准模板库,作为C++标准不可缺少的一部分,STL应该是渗透在C++程序的角角落落里的。STL不是实验室里的宠儿,也不是程序员桌上的摆设,她的激动人心并非昙花一现。本教程旨在传播和普及STL的基础知识,若能借此机会为STL的推广做些力所能及的事情,到也是件让人愉快的事情。   

     

    二、什么是STL
      

    "什么是STL?",假如你对STL还知之甚少,那么我想,你一定很想知道这个问题的答案,坦率地讲,要指望用短短数言将这个问题阐述清楚,也决非易事。因此,如果你在看完本节之后还是觉得似懂非懂,大可不必着急,在阅读了后续内容之后,相信你对STL的认识,将会愈加清晰、准确和完整。不过,上述这番话听起来是否有点像是在为自己糟糕的表达能力开脱罪责呢?:)   

    不知道你是否有过这样的经历。在你准备着手完成数据结构老师所布置的家庭作业时,或者在你为你所负责的某个软件项目中添加一项新功能时,你发现需要用到一个链表(List)或者是映射表(Map)之类的东西,但是手头并没有现成的代码。于是在你开始正式考虑程序功能之前,手工实现List或者Map是不可避免的。于是……,最终你顺利完成了任务。或许此时,作为一个具有较高素养的程序员的你还不肯罢休(或者是一个喜欢偷懒的优等生:),因为你会想到,如果以后还遇到这样的情况怎么办?没有必要再做一遍同样的事情吧!   

    如果说上述这种情形每天都在发生,或许有点夸张。但是,如果说整个软件领域里,数十年来确实都在为了一个目标而奋斗--可复用性(reusability),这看起来似乎并不夸张。从最早的面向过程的函数库,到面向对象的程序设计思想,到各种组件技术(如:COM、EJB),到设计模式(design pattern)等等。而STL也在做着类似的事情,同时在它背后蕴涵着一种新的程序设计思想--泛型化设计(generic programming)。   

    继续上面提到的那个例子,假如你把List或者map完好的保留了下来,正在暗自得意。且慢,如果下一回的List里放的不是浮点数而是整数呢?如果你所实现的Map在效率上总是令你不太满意并且有时还会出些bug呢?你该如何面对这些问题?使用STL是一个不错的选择,确实如此,STL可以漂亮地解决上面提到的这些问题,尽管你还可以寻求其他方法。   

    说了半天,到底STL是什么东西呢?   

    STL(Standard Template Library),即标准模板库,是一个具有工业强度的,高效的C++程序库。它被容纳于C++标准程序库(C++ Standard Library)中,是ANSI/ISO C++标准中最新的也是极具革命性的一部分。该库包含了诸多在计算机科学领域里所常用的基本数据结构和基本算法。为广大C++程序员们提供了一个可扩展的应用框架,高度体现了软件的可复用性。这种现象有些类似于Microsoft Visual C++中的MFC(Microsoft Foundation Class Library),或者是Borland C++ Builder中的VCL(Visual Component Library),对于此二者,大家一定不会陌生吧。   

    从逻辑层次来看,在STL中体现了泛型化程序设计的思想(generic programming),引入了诸多新的名词,比如像需求(requirements),概念(concept),模型(model),容器(container),算法(algorithmn),迭代子(iterator)等。与OOP(object-oriented programming)中的多态(polymorphism)一样,泛型也是一种软件的复用技术。   

    从实现层次看,整个STL是以一种类型参数化(type parameterized)的方式实现的,这种方式基于一个在早先C++标准中没有出现的语言特性--模板(template)。如果查阅任何一个版本的STL源代码,你就会发现,模板作为构成整个STL的基石是一件千真万确的事情。除此之外,还有许多C++的新特性为STL的实现提供了方便。   

    不知你对这里一下子冒出这么多术语做何感想,希望不会另你不愉快。假如你对它们之中的大多数不甚了解,敬请放心,在后续内容中将会对这些名词逐一论述。正如开头所提到的。   

    有趣的是,对于STL还有另外一种解释--STepanov %26amp; Lee,前者是指Alexander Stepanov,STL的创始人;而后者是Meng Lee,她也是使STL得以推行的功臣,第一个STL成品就是他们合作完成的。这一提法源自1995年3月,Dr.Dobb’s Journal特约记者, 著名技术书籍作家Al Stevens对Alexander Stepanov的一篇专访。   



    三、STL的历史   


    在结识新朋友的时候,大多数人总是忍不住想了解对方的过去。本节将带您简单回顾一下STL的过去。   

    被誉为STL之父的Alexander Stepanov,出生于苏联莫斯科,早在20世纪70年代后半期,他便已经开始考虑,在保证效率的前提下,将算法从诸多具体应用之中抽象出来的可能性,这便是后来泛型化思想的雏形。为了验证自己的思想,他和纽约州立大学教授Deepak Kapur,伦塞里尔技术学院教授David Musser共同开发了一种叫做Tecton的语言。尽管这次尝试最终没有取得实用性的成果,但却给了Stepanov很大的启示。   

    在随后的几年中,他又和David Musser等人先后用Schema语言(一种Lisp语言的变种)和Ada语言建立了一些大型程序库。这其间,Alexander Stepanov开始意识到,在当时的面向对象程序设计思想中所存在的一些问题,比如抽象数据类型概念所存在的缺陷。Stepanov希望通过对软件领域中各组成部分的分类,逐渐形成一种软件设计的概念性框架。   

    1987年左右,在贝尔实验室工作的Alexander Stepanov开始首次采用C++语言进行泛型软件库的研究。但遗憾的是,当时的C++语言还没有引入模板(template)的语法,现在我们可以清楚的看到,模板概念之于STL实现,是何等重要。是时使然,采用继承机制是别无选择的。尽管如此,Stepanov还是开发出了一个庞大的算法库。与此同时,在与Andrew Koenig(前ISO C++标准化委员会主席)和Bjarne Stroustrup(C++语言的创始人)等顶级大师们的共事过程中,Stepanov开始注意到C/C++语言在实现其泛型思想方面所具有的潜在优势。就拿C/C++中的指针而言,它的灵活与高效运用,使后来的STL在实现泛型化的同时更是保持了高效率。另外,在STL中占据极其重要地位的迭代子概念便是源自于C/C++中原生指针( native pointer)的抽象。   

    1988年,Alexander Stepanov开始进入惠普的Palo Alto实验室工作,在随后的4年中,他从事的是有关磁盘驱动器方面的工作。直到1992年,由于参加并主持了实验室主任Bill Worley所建立的一个有关算法的研究项目,才使他重新回到了泛型化算法的研究工作上来。项目自建立之后,参与者从最初的8人逐渐减少,最后只剩下两个人--Stepanove本人和Meng Lee。经过长时间的努力,最终,信念与汗水所换来的是一个包含有大量数据结构和算法部件的庞大运行库。这便是现在的STL的雏形(同时也是STL的一个实现版本--HP STL)。   

    1993年,当时在贝尔实验室的Andrew Koenig看到了Stepanove的研究成果,很是兴奋。在他的鼓励与帮助下,Stepanove于是年9月的圣何塞为ANSI/ISO C++标准委员会做了一个相关演讲(题为"The Science of C++ Programming"),向委员们讲述了其观念。然后又于次年3月,在圣迭戈会议上,向委员会提交了一份建议书,以期使STL成为C++标准库的一部分。尽管这一建议十分庞大,以至于降低了被通过的可能性,但由于其所包含的新思想,投票结果以压倒多数的意见认为推迟对该建议的决定。   

    随后,在众人的帮助之下,包括Bjarne Stroustrup在内,Stepanove又对STL进行了改进。同时加入了一个封装内存模式信息的抽象模块,也就是现在STL中的allocator,它使STL的大部分实现都可以独立于具体的内存模式,从而独立于具体平台。在同年夏季的滑铁卢会议上,委员们以80%赞成,20%反对,最终通过了提案,决定将STL正式纳入C++标准化进程之中,随后STL便被放进了会议的工作文件中。自此,STL终于成为了C++家族中的重要一员。   

    此后,随着C++标准的不断改进,STL也在不断地作着相应的演化。直至1998年,ANSI/ISO C++标准正式定案,STL始终是C++标准中不可或缺的一大部件。


    一、什么时候用STL

        如果,有的时候,你要在程序中用到堆、栈、队列、链表等一些基本的算法,而你又实在不想自己去实现数据结构教科书中那些繁琐的算法,那么你就可以考虑使用STL。

        另外,STL作为一种标准,便于交流,掌握它,一方面可以让你写的程序,易于让别人理解,另一方面你也能够比较容易地理解别人写的程序。

    二、什么是STL

        全称为  Standard Template Library  ,即标准模板库

        要使用STL,要了解以下几个基本概念:

    •         容器:可以把它理解为存放数据的地方,常用的一些容器有 链表(list) 栈(stack) 动态数组 (vector) 双端队列(deque) 队,列(queue) 映射(map)
    •         迭代器:(iterator):可以把它理解为指针类型,STL中的许多函数需要用到它们作为参数
    •         算法:它们通常需要与容器和游标配合使用,使用它们,你可以方便地对容器中的数据进行各种常见的操作,如排序操作,寻找最大元素的操作等
       

    三、主要有以下的容器

    • string
    • vector
    • list
    • set / multiset
    • map / multimap
    • stack queue /
    • priority_queue pair
    • STL 算法 <algorithm> sort等
    • 迭代器 iterator 、reverse_iterator

     

    三、STL--使用

    一、容器模板的使用

        大致有下面6个步骤:

            1.添加相应的头文件(如 #include <list> )( 注意,没有 .h )

            2.添加std命名空间(用 using namespace std; )

            3.赋予模板具体的使用类型(如 typedef list<string> LISTSTR; )

            4.实例化模板(如 LISTSTR test; )

            5.实例化游标(如 LISTSTR::iterator i; )

            6.通过迭代器对象访问模板对象,例如

                // 逐个输出链表test中的元素
                for ( i =  test.begin(); i != test.end(); ++i )
                    cout << *i << " ";

    二、容器模板中的常用函数

       assign()           赋值

       empty()            容器为空则返回非0值

       erase()            删除指定位置或指定范围内的元素

       push_front()   从容器头部插入元素  

       push_back()   从容器尾部插入元素

       pop_front()     删除第一个元素

       pop_back()     删除最后一个元素

       back()              返回最后一个元素的引用

       front()              返回第一个元素的引用

       begin()             返回指向第一个元素的游标 (与迭代器配合使用)

       end()                返回指向最后一个元素的后一个位置的游标 (最后1个元素再加1) (与迭代器配合使用)

    转自:http://www.cppblog.com/bhjjkg/articles/94514.html 

    展开全文
  • C++和Java中STL库入门

    2020-05-28 22:36:48
    C++和Java中STL库入门STL简介为什么使用STLSTL基本概念STL使用前的初始化C++里STL基本容器详解 STL简介 STL简称标准模版库,被容纳在C++标准程序库,包含了许多基本数据结构和基本算法,使程序员写起来得心应手。 为...


    参考会长大佬 https://me.csdn.net/m0_43448982

    STL简介

    STL简称标准模版库,被容纳在C++标准程序库,包含了许多基本数据结构和基本算法,使程序员写起来得心应手。

    为什么使用STL

    在学习数据结构的时候,在程序中会使用到堆、栈、队列、链表等一些基本的算法,而学习数据结构的时候,这些基本算法写起来十分繁琐,如果不想写这些,那么就可以考虑一下STL了。
    但是不要太过于依赖STL!

    STL基本概念

    要使用STL,需要理解以下几个基本概念:
    容器:是存放数据的地方,常见的容器有:链表(list) 栈(stack) 动态数组 (vector) 双端队列(deque) 队列(queue) 映射(map)
    迭代器(iterator):可以理解为C语言里的地址,而迭代器就是容器的一个指针,十分重要!!!
    算法:可以对容器里的数据做一些基本操作,比如排序,找最大元素等等。

    STL使用前的初始化

    C++
    1.需要对应的头文件,比如list就需要#include<list>,且没有.h,或者恶心的万能头#include<bits/stdc++.h>。
    2.添加std命名空间(using namespace std;)不加的话后面可以自己写一堆。。。

    java:
    1.需要import类,可以统一写成import java.util.*;

    C++里STL基本容器详解

    cmp类
    通过自定义cmp类来完成STL的更加自由的设置

    struct cmp {
        bool operator()(int a, int b) {
            return a > b;
        }
    };
    

    sort:
    1.需要头文件#include<algorithm>;
    2.复杂度为O(nlogn),比较排序的极限了。

    bool cmp(int a, int b)
    {
    	return a > b;
    }
    int a[] = {1, 2 ,3 , 4};
    sort(a, a + 4, cmp);
    

    sort里第一个参数是数组需要排序的第一个地址,第二个参数是数组需要排序的第二个地址,都三个参数是一个自定义函数,对数组排序的函数,上面的cmp函数是使数组元素从大到小排序。

    sort是不稳定排序,即对于相同的值,无法保证其前后顺序
    解决办法:
    1、增加一个 index 变量,在值相同的使用比较 index 值的大小
    2、使用 stable_sort

    vector
    1.需要头文件#include<vector>
    2.不定数组

    vector<int> a, b;
    a.push_back(1);	// 推入一个新的值到数组最后
    a.pop_back();		// 删除数组最后的那个值
    a.front();			// 数组开头的值
    a.back();			// 数组结尾的值
    a = b;				// 数组拷贝
    a == b;				// 数组是否相同
    a[1];				// 数组中第二个值
    
    vector<int> a;
    a.size();				// 容器内的元素个数
    a.empty();				// 容器是否为空
    // 除了queue和stack外通用的方法
    a.clear();				// 清空容器内的所有元素
    a.begin();				// 容器的一个元素的迭代器
    a.end();				// 容器尾后迭代器
    
    vector<int> v;
    vector<int>::iterator iter	// 定义迭代器
    iter = v.begin();				// 数组头“指针”
    iter = v.end();				// 数组尾“指针”
    

    list:
    1.需要头文件#include<int> l;
    2.双向链表

    list<int> l;
    l.push_front(1);			// 插入元素到开头
    l.pop_front();			// 从开头删掉元素
    l.erase(l.begin());		// 删除指定迭代器处的元素
    l.insert(l.begin(), 1);	// 在指定迭代器前插入元素
    l.reverse();				// 反转整个链表
    

    string:
    1.伪字符串;
    2.定义:string s;
    3.只能流输入和流输出;

    string a, b;
    a[1] == 'a';				// 得到某个字符
    a = b;						// 字符串拷贝
    a >= b;						// 字典序比较
    a[1] = b[1];				// 修改某个字符
    a += b;						// 字符串拼接
    a = a + b;					// 字符串拼接
    a += "123";				// 字符串拼接
    a = b + "123";				// 字符串拼接
    int len = a.lenth();		// 字符串的长度
    

    queue
    1.需要头文件#include<queue>;
    2.先进先出(内部为链表实现)

    queue<int> q;
    q.push(1);				// 将1推入队列
    q.pop();				// 推出队列开头的元素
    q.front();				// 队列的第一个元素
    

    stack:
    1.需要头文件#include<stack>;
    2.后进先出(内部为数组实现)

    stack<int> q;
    q.push(1);				// 将1推入堆栈
    q.pop();				// 推出堆栈最后的元素
    q.top();				// 堆栈的最后的元素
    

    pair:
    1.需要头文件#include<map>
    2.表示一组键对(有两个变量的结构体)

    pair<int, string> p;
    p.first = 1;
    p.second = "abc";
    p = make_pair(1, "abc");
    p = {1, "abc"};
    
    pair<int, string> p[100];
    sort(p, p + 100);
    // 默认优先first从小到大
    // 如果first相同则second从小到大
    

    pair与其他结构嵌套

    vector<pair<int, string> > vp;
    queue<pair<float, int> > qp;
    queue<pair<pair<int, int>, int> > qpp;
    

    set:
    1.需要头文件#include<set>;
    2.set保存了不可重复的元素–二叉搜索树-红黑树

    set<int> s;
    s.insert(1);				// 插入到集合中
    s.erase(1);				// 从集合中删除
    s.erase(s.begin());		// 从集合中删除
    s.count(1);				// 集合中是否存在
    s.find(1);
    // 返回对应值的迭代器(若无则返回尾后迭代器)
    

    ·由于set是红黑树,所以满足以下内容
    1、内部有序(默认从小到大)
    2、没有重复值,如果出现重复值会不断被覆盖
    3、几乎所有操作复杂度均为 O(logN)
    4、不可以修改节点上的值
    5、修改操作只能进行插入和删除两个操作

    set通常作用:保证唯一性,保证数列有序

    map
    1.需要头文件#include<map>;
    2.map字典(键对集合)——二叉搜索树——红黑树

    map<char, int> m;
    m.insert(make_pair('a', 1));	// 加入字典
    m.insert({'a', 1});			// 加入字典
    m.erase('a');					// 从字典中删除
    m.count('a');					// 字典中是否存在
    m.find('a');
    // 返回对应值的迭代器(若无则返回尾后迭代器)
    

    通常称map的first元素为key,second元素为value
    ·由于map是键对红黑树,所以满足以下内容
    1、set的大部分性质;
    2、key不能重复,不能修改,只能删除和添加;
    3、允许value重复,可以对value进行修改;
    4、map是按照key进行排序的;
    5、key和value一定是成对出现的;
    6、map的迭代器指向的内容是一个pair;

    priority_queue:
    1.需要头文件#include<queue>
    2.优先队列–堆

    priority_queue<int> prq;
    prq.top();				// 堆顶上的元素
    prq.pop();				// 弹出堆顶上的元素
    prq.push(1);			// 推入堆
    

    ·priority_queue默认为最大堆,即堆顶的元素最大
    ·和queue一样,priority_queue不允许访问除了堆顶元素以外的任何一个元素。
    ·priority_queue的插入和弹出操作的复杂度均为O(logN)

    priority_queue功能与set接近,而且set的功能更强大,并且理论复杂度相同,为什么有时候反而就是用priority_queue?
    ·priority_queue的复杂度为最差情况下的复杂度,而set和map的复杂度均为稳定复杂度的极限值

    Java里STL基本容器详解

    参考https://blog.csdn.net/qq_38173003/article/details/79733423
    https://www.cnblogs.com/solvit/p/9600591.html
    所有的容器都要有import类import java.util.*

    vector:
    和c++的vector使用方法类似。

    import java.util.*;
    
    public class Main {
        public static void main(String[] args) {
    		Vector<Integer> vec=new Vector<> ();
    		vec.add(1);//添加元素
            vec.add(4,6);//在下表为4前添加6元素
            vec.set(3, 7);//替换下表为3元素值为7
    		vec.remove(0);//删除下表为1的元素
    		for(int i=0;i<vec.size();i++){  //size获取长度
    			System.out.println(vec.get(i)); //get获取下表为i的值
    		}
    		vec.clear();//清空
    	}
    }
    

    ArrayList:
    Java.util.ArrayList类是一个动态数组类型,也就是说,ArrayList对象既有数组的特征,也有链表的特征。

    import java.util.*;
     
    public class Main {
        public static void main(String[] args) {
            ArrayList<Integer> arr=new ArrayList<>();
            arr.add(1);//添加
            arr.add(2,6);
            arr.size();//获取长度
            arr.set(1, 4);//修改
            int st=arr.remove(0);//删除
            //arr.clear();//清空
            //arr.get(1);//获取
            int v=arr.indexOf(3);//获取索引
            System.out.println(v);
        }
    }
    

    LinkedList
    LinkedList 实现 Deque 接口,即能将LinkedList当作双端队列使用。

    import java.util.*;
     
    public class Main {
        public static void main(String[] args) {
            LinkedList<Integer> lin=new LinkedList<>();
            lin.addFirst(st);//在首部加
            lin.addLast(st);//在尾
            lin.removeFirst();//移除首元素
            lin.removeLast();//尾
            lin.push(st);//压入栈
            lin.pop();//弹出栈
        }
    }
    

    HashSet:
    无重复元素

    import java.util.*;
     
    public class Main {
    	public static void main(String[] args) {
    		HashSet<Integer> hashset=new HashSet<>();
    		hashset.add(4);//添加
    		hashset.remove(2); //找到值2删除
    		System.out.println(hashset);
    		
    	}
    }
    

    HashMap:

    import java.util.*;
     
    public class Main {
    	public static void main(String[] args) {
    		HashMap<Integer, Integer> map=new HashMap<>();
    		map.put(1, 1); //添加元素
    		map.put(1, 2); //替换
    		map.remove(4);
    		System.out.println(map.get(1));
    		System.out.println(map.size());
    		System.out.println(map);
    		map.clear();
    	}
    }
    
    
    

    只做入门参考。

    展开全文
  • 在本篇文章里小编给大家整理的是关于c++STL库容器之集合set代码实例,需要的朋友们可以参考下。
  • stl库介绍与练习

    2018-08-17 11:13:01
    STL是Standard Template Library的简称,中文名标准模板,惠普实验室开发的一系列软件的统称。它是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室工作时所开发出来的。从根本上说,STL是一些“容器...
  • STL库简单介绍

    2019-07-12 09:46:34
    STL包括两部分内容:容器和算法 容器即存放数据的地方,比如array, vector,分为两类,序列式容器和关联式容器 序列式容器,其中的元素不一定有序,但是都可以被排序,比如vector,list,queue,stack,heap, ...

    STL包括两部分内容:容器和算法

    容器即存放数据的地方,比如array, vector,分为两类,序列式容器和关联式容器

    序列式容器,其中的元素不一定有序,但是都可以被排序,比如vector,list,queue,stack,heap, priority-queue, slist

    关联式容器,内部结构是一个平衡二叉树,每个元素都有一个键值和一个实值,比如map, set, hashtable, hash_set

    算法有排序,复制等,以及各个容器特定的算法

    迭代器是STL的精髓,迭代器提供了一种方法,使得它能够按照顺序访问某个容器所含的各个元素,但无需暴露该容器的内部结构,它将容器和算法分开,让二者独立设计。

    (1)STL中map和set的原理(关联式容器)

    map和set的底层实现主要通过红黑树来实现

    红黑树是一种特殊的二叉查找树

    1)每个节点或者是黑色,或者是红色

    2)根节点是黑色

    3) 每个叶子节点(NIL)是黑色。 [注意:这里叶子节点,是指为空(NIL或NULL)的叶子节点!]

    4)如果一个节点是红色的,则它的子节点必须是黑色的

    5)从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

    特性4)5)决定了没有一条路径会比其他路径长出2倍,因此红黑树是接近平衡的二叉树。

    (2)STL中的vector的实现,是怎么扩容的?

    vector使用的注意点及其原因,频繁对vector调用push_back()对性能的影响和原因。

    vector就是一个动态增长的数组,里面有一个指针指向一片连续的空间,当空间装不下的时候,会申请一片更大的空间,将原来的数据拷贝过去,并释放原来的旧空间。当删除的时候空间并不会被释放,只是清空了里面的数据。对比array是静态空间一旦配置了就不能改变大小。

    vector的动态增加大小的时候,并不是在原有的空间上持续新的空间(无法保证原空间的后面还有可供配置的空间),而是以原大小的两倍另外配置一块较大的空间,然后将原内容拷贝过来,并释放原空间。在VS下是1.5倍扩容,在GCC下是2倍扩容。

    在原来空间不够存储新值时,每次调用push_back方法都会重新分配新的空间以满足新数据的添加操作。如果在程序中频繁进行这种操作,还是比较消耗性能的。

    (3)STL中unordered_map和map的区别

    map是STL中的一个关联容器,提供键值对的数据管理。底层通过红黑树来实现,实际上是二叉排序树和非严格意义上的二叉平衡树。所以在map内部所有的数据都是有序的,且map的查询、插入、删除操作的时间复杂度都是O(logN)。

    unordered_map和map类似,都是存储key-value对,可以通过key快速索引到value,不同的是unordered_map不会根据key进行排序。unordered_map底层是一个防冗余的哈希表,存储时根据key的hash值判断元素是否相同,即unoredered_map内部是无序的。

    (4)C++标准库vector以及迭代器

    每种容器类型都定义了自己的迭代器类型,每种容器都定义了一队命名为begin和end的函数,用于返回迭代器。

    迭代器是容器的精髓,它提供了一种方法使得它能够按照顺序访问某个容器所含的各个元素,但无需暴露该容器的内部结构,它将容器和算法分开,让二者独立设计。

     

    展开全文
  • STL库和Boost库

    千次阅读 2018-06-04 09:26:44
    但是因为Boost并不在标准中,或者说是下一代标准的试验场,所以的种类要更多一些,手法也更加丰富一些。2. STL/Boost 针对 Developer 和 User 的要求不同对于Boost开发者而言,强调的是代码可读、高效、强调元编程...

     在设计原则上,STL和Boost大体统一
    因为STL和Boost基本上都是标准委员会那批人在策划、审核和维护,所以口味上是相对接近的。
    但是因为Boost并不在标准中,或者说是下一代标准的试验场,所以库的种类要更多一些,手法也更加丰富一些。

    2. STL/Boost 针对 Developer 和 User 的要求不同
    对于Boost开发者而言,强调的是代码可读、高效、强调元编程和编程技巧。

    补注:评论里面果然有人提到说可读性和元编程有矛盾。这种说法大概类似于“这段代码可读性差是因为业务太复杂”。这是不对的。可读性是要建立在正确的满足功能和性能的基础上的。这也是为什么我要特别为后两点解(Jiao)释(Bian)一下。


    这里要解释一下后两点:

    • 编程技巧主要是为了实现一些看起来有点像天方夜谭的功能,例如C++11之前的Boost.Auto(利用了编译器的Bug或者特性);以及1.56才加入的TypeIndex,该宏利用了编译器能产生Mangled/Demangled函数签名的能力。
    • 元编程主要是为了解决三个问题:
      • 增加宏/模板演算的能力,为图灵完备的模板编程提供类型/常量运算的库,方便开发者。例如Boost.MPL和Boost.PP;
      • 增加C++的语言内描述能力,也就是Embedded DSL。例如Spirit和Proto,都是很好的例子;
      • 做尽可能多的静态检查。比如Boost.Chrono将单位绑定到类型中,解决了单位转换容易出错的问题。

    而STL因为处于标准中,所以会对不同平台的编译器都做出了统一要求,需要编译器配合的地方,也不会用语言机制或者奇技淫巧来迁就,例如Static Assertion、Auto、decltype,在Boost当中是以一定的技巧实现的(因为编译器不能直接支持),而在C++11种就变成了一个内置的语言特性。与此类似的还有很多的Type Traits。

    对于User而言,Boost/STL的库可以分为四种风格。

    • 第一种风格为Lib风格,以提供功能为主,使用方法一般也就是as-is。例如Pool,Graph,Interval,Chrono,ASIO等。它们的接口使用也可以分为两个部分,第一阶段是型别特化,第二阶段是基于运行时接口。STL和Boost里,大部分库都是这样的风格。这也是最容易使用和使用频率最高的风格。
    • 第二种风格是语法糖类。Boost.Foreach等都属于这一类。但是在STL中就非常罕见,因为语言已经得到了充分升级。
    • 第三种风格是范式和方法论的拓展,即在C++中模拟其他编程范式和方法论。例如spirit,lambda,proto。严格的说,boost.mpl也可以归属此类。这一类库的使用方式分为两步,第一步是定制方言,第二步是使用方言。这类应用因为面向库的开发者,所以STL中很难见。
    • 第四类风格,是元编程。利用模板和宏进行编译器推导,以实现代码展开、选择编译等工作。典型的例子有Boost.PP,STL/Boost.TypeTraits,enable_if等,这一部分对于一般用户是可以不用的。STL中有部分基础的元编程支持(例如Traits)。

    因为STL多数是面向一般程序员,所以以第一种库居多,而Boost包含了全部四类的库的风格。

    3. 文档
    Boost的文档基本上是tutorial风格的,Reference做的并不好。而被标准化的STL通常会有更加清晰易读的Reference。

    4. 平台特定性
    Boost有很多支持不同平台、或者IO相关的玩意儿,比如Boost.Process,GIL,ASIO,Context,哪个都不是平台无关的省油灯。反观STL对这方面一直都很保守,之前一直就只有容器这类东西,C++11之后才把Thread、File System这种和平台有些关系的内容陆续给弄进来,IO和网络到现在都是一块一毛不拔的荒地。

    5. 问题
    Boost和STL的问题几乎是相通的,就是因为模板使用多,编译时间较长,二进制也相对较大。编译错误也不是非常明确。Boost中一些元编程分量更多的库,例如MSM和Spirit的问题要更加严重。
    此外,因为Boost是试验性质的库,所以接口可能不是非常稳定。而一旦库进入STL之后,就几乎不可能有变化了。比如Boost.Filesystem在进入TR2之前,先后有三个比较大版本的API变动;Spirit也做出了一次比较大的调整。
    还有就是,Boost的库和其它语言的标准库相比,零散杂乱,我经常也忘记Boost/STL中的某些库,自己去发明了一个一点都不好用的轮子。

    6. 干儿子
    最后就是,虽然Boost是标准委员会的干儿子,但是也不保证它的实现就一定是进入STL。比如网络库,最后进标准的,应该是CppNetlib,而不是ASIO。

    展开全文
  • c++stl标准源码

    2017-12-07 10:58:45
    c++ stl The Standard Template Library, 容器(Container) 迭代器(Iterator) 算法(Algorithm)仿函数(Function object)迭代适配器(Adaptor)空间配制器(allocator)
  • STL库 c++文档

    2012-12-09 22:00:23
    讲解STL库的最基础的文档 利于入门了解STL库
  • c++中STL库 简介 及 使用说明

    万次阅读 多人点赞 2017-10-27 09:03:48
    该文章讲的很清楚! 作为C++标准不可缺少的一部分,STL应该是渗透在C++程序的角角落落里的。...本教程旨在传播和普及STL的基础知识,若能借此机会为STL的推广做些力所能及的事情,到也是件让人愉快的事情。 
  • C/C++中的STL库

    千次阅读 2016-12-10 09:53:42
    标准模板(standard template library ,STL)支持不同的容器和算法。 STL提供了常量数据结构的实现,如链表和队列。当然在使用C++时候,并不需要我们再一次进行编写这样的数据结构。数据结构的实现使用了一个...
  • C++ STL list 链表的基本定义及操作

    千次阅读 2020-01-11 19:24:38
    文章目录一,list二,forward_list 一,list 二,forward_list
  • 定义 头文件 定义 常用函数
  • 2015年侯捷STL标准与泛型编程视频教程的课件和源码,源码剖析
  • STL库的map和set的使用

    千次阅读 2017-11-12 14:01:35
    之前我们讲到过红黑树这个数据结构,STL库中还有两个非常重要的容器的底层是通过红黑树实现的,那就是map(图)和set(集合)。两者的表示上的区别在于,set存储的只是一个key,而map是以key和value的方式存储的...
  • STL库简述

    2020-07-16 12:14:40
    STL库包含六个大类: 容器库 算法库 迭代器库 配置器(allocator) 适配器(adaptor) 仿函数(函数对象) 其中后四个类主要为前两个类服务。 其中使用频率最高的就是容器库,迭代器库,算法库。容器库为我们提供...
  • C++模板与STL库介绍.ppt

    2021-10-07 21:23:19
    C++模板与STL库介绍.ppt
  • c++ STL库中自带find()函数, 使用时要把algorithminclude进来. 使用格式: find(数组的头地址, 数组的尾地址, 要找的数) find(nums.begin(), nums.end(), target) 返回的是target第一次出现的地址 如果没有找到返回尾...
  • STL库中快排sort函数详解

    千次阅读 2019-03-13 20:42:34
    另外,其实我们还可以再懒一点,在标准中已经有现成的。它 在哪 呢?答案是 functional ,我们include进来试试看。functional提供了一堆基于模板的比较函数对象,它们是:equal_to、not_equal_to、greater、...
  • STL库的一些使用

    2019-01-21 18:20:58
    stl的一些使用例程。 标准C++类与组件在逻辑上分为以下6种类型: 输入输出类 容器类与ADT(抽象数据类型) 存储管理类 算法 错误处理 运行环境支持
  • 头文件 1.容器 近容器: char buffer[1024]; string str; bitset位容器vector 顺序容器: resize() vector(内存可自增长的数组) reserve(100)预留空间 push_back(val) insert(iterator,
  • 定义 栈是限定仅在表尾进行插入或删除操作的线性表。(按后进先出的原则进行) 对栈来说,表尾端称为栈顶,表头端称为栈底。 栈的示意图如下: 栈的类型定义 ADT Stack{ 数据对象:D={ai|ai∈......
  • 本文档包含对C++模板与STL库相关内容的资料以及介绍

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 80,986
精华内容 32,394
关键字:

stl库