STL

最新推荐文章于 2024-02-16 15:38:25 发布

pmt123456

最新推荐文章于 2024-02-16 15:38:25 发布

阅读量611

点赞数

分类专栏：面试汇总

面试汇总专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、STL概述

1、STL提供六大组件，彼此可以组合套用

1、容器（Containers）：各种数据结构，如：vector、list、deque、set、map。用来存放数据。从实现的角度来看，STL容器是一种class template。

2、算法（algorithms）：各种常用算法，如：sort、search、copy、erase。从实现的角度来看，STL算法是一种 function template。

3、迭代器（iterators）：容器与算法之间的胶合剂，是所谓的“泛型指针”。共有五种类型，以及其他衍生变化。从实现的角度来看，迭代器是一种将 operator*、operator->、operator++、operator- - 等指针相关操作进行重载的class template。所有STL容器都有自己专属的迭代器，只有容器本身才知道如何遍历自己的元素。原生指针(native pointer)也是一种迭代器。

4、仿函数（functors）：行为类似函数，可作为算法的某种策略（policy）。从实现的角度来看，仿函数是一种重载了operator（）的class或class template。一般的函数指针也可视为狭义的仿函数。

5、配接器（adapters）；一种用来修饰容器、仿函数、迭代器接口的东西。例如：STL提供的queue 和 stack，虽然看似容器，但其实只能算是一种容器配接器，因为它们的底部完全借助deque，所有操作都由底层的deque供应。改变 functors接口者，称为function adapter；改变 Container 接口者，称为container adapter；改变iterator接口者，称为iterator adapter。

6、配置器（allocators）：负责空间配置与管理。从实现的角度来看，配置器是一个实现了动态空间配置、空间管理、空间释放的class template。

2、一些可能令人困惑的C++语法

a. 静态常量整数成员（const static integraldata member）可以在class内部直接初始化,integral泛指所有整数型别，不单只是int

class  A
{
public:
	static const int a = 5;
	static const long b = 3L;
	static const char c = 'c';

};

b. 任何一个stl算法，都需要由一对迭代器（泛型指针）所标示的区间，用以标示操作范围，这一对迭代所表示的是所谓的前闭后开区间，以[first,last)表示

3、泛型指针、原生指针和只智能指针

1. 泛型指针

泛型指针有多种含义。
(1) 指void*指针，可以指向任意数据类型，因此具有“泛型”含义。
(2) 指具有指针特性的泛型数据结构，包含泛型的迭代器、智能指针等。
广义的迭代器是一种不透明指针，能够实现遍历访问操作。通常所说的迭代器是指狭义的迭代器，即基于C++的STL中基于泛型的iterator_traits实现的类的实例。

总体来说，泛型指针和迭代器是两个不同的概念，其中的交集则是通常提到的迭代器类。

2. 原生指针就是普通指针，与它相对的是使用起来行为上象指针，但却不是指针。
说“原生”是指“最简朴最基本的那一种”。因为现在很多东西都抽象化理论化了，所以“以前的那种最简朴最基本的指针”只是一个抽象概念（比如iterator）的表现形式之一。

3. 智能指针是C++里面的概念：由于 C++ 语言没有自动内存回收机制，程序员每次得自己处理内存相关问题，但用智能指针便可以有效缓解这类问题。
引入智能指针可以防止出现悬垂指针的情况
一般是把指针封装到一个称之为智能指针类中，这个类中另外还封装了一个使用计数器，对指针的复制等操作将导致该计数器的值加1，对指针的delete操作则会减1，值为0时，指针为NULL
分类: C++

1.std::vector的底层（存储）机制。

vector维护一个连续线性空间，普通指针可作为vector的迭代器。

容量：vector的容量永远大于等于其大小，运用start,finish,end_of_storage三个迭代器。

容量的扩张必须经历“重新配置，元素移动，释放原空间”等过程

当空间不够装下数据时，会以原大小的两倍配置另一块较大空间，然后把原来的数据拷贝过去，接着释放原来的那片空间。

对vector的任何操作，一旦引起空间重新配置，指向原vector的所有迭代器就都失效了。

元素操作

a、删除元素

#pop_back()
--finish;
destroy(finish);

#清除[first, last)中所有元素，erase(iterator first, iterator last)
iterator i = copy(last, finish, first);
destroy(i, finish);

#清除某个位置的元素
copy(position + 1, finish, position);

b、添加（insert）元素

2.std::vector的自增长机制。

当已经分配的空间不够装下数据时，分配双倍于当前容量的存储区，把当前的值拷贝到新分配的内存中，并释放原来的内存。

3.说说std::list的底层（存储）机制。

是一个环状双向链表，以结点为单位存放数据，结点的地址在内存中不一定连续，每次插入或删除一个元素，就配置或释放一个元素空间

4.什么情况下用vector，什么情况下用list。

vector可以随机存储元素（即可以通过公式直接计算出元素地址，而不需要挨个查找），但在非尾部插入删除数据时，效率很低，适合对象简单，对象数量变化不大，随机访问频繁。

list不支持随机存储，适用于对象大，对象数量变化频繁，插入和删除频繁。

5.list自带排序函数的排序原理。

归并排序变形：http://blog.csdn.net/shoulinjun/article/details/19501811

将前两个元素合并，再将后两个元素合并，然后合并这两个子序列成4个元素的子序列，重复这一过程，得到8个，16个，...，子序列，最后得到的就是排序后的序列。

时间复杂度：O(nlgn)

list的sort实现：merge排序变形

template <class T, class Alloc>

 void list<T, Alloc>::sort() {

  if (node->next == node || link_type(node->next)->next == node) return;

  list<T, Alloc> carry;

  list<T, Alloc> counter[64];

  int fill = 0;

  while (!empty()) {

    carry.splice(carry.begin(), *this, begin());

    int i = 0;

    while(i < fill && !counter[i].empty()) {

      counter[i].merge(carry);

      carry.swap(counter[i++]);

    }

    carry.swap(counter[i]);        

    if (i == fill) ++fill;

  }

  for (int i = 1; i < fill; ++i) counter[i].merge(counter[i-1]);

  swap(counter[fill-1]);

}

分析

对于序列7,6,5,4,3,2,1

第一趟：

carry.splice(carry.begin(), *this, begin()); ->carry:7

carry.swap(counter[i]); ->carry:NULL,counter[0]:7

i==fill(0)->fill:1

第二趟：

carry.splice(carry.begin(), *this, begin());->carry:6

i=0,fill=1,count[0]不为empty，进入循环

counter[i].merge(carry);count[0]和carry进行归并 ->carry：NULL，counter[0]:6,7

carry.swap(counter[i++]); ->carry：6,7

退出U型你换

carry.swap(counter[i]); ->counter[1]:6,7

第三趟：

carry.splice(carry.begin(), s, s.begin()); ->carry：5

counter[1]:empty ->跳过循环

carry.swap(counter[i]); ->counter[0]：5

第四趟：

carry.splice(carry.begin(), s, s.begin()); ->carry：4

i=0,fill=2，进入循环

counter[i].merge(carry); ->counter[0]:4,5

carry.swap(counter[i++]); ->carry:4,5

i=1

counter[i].merge(carry); ->counter[1]:4,5,6,7

carry.swap(counter[i++]); ->carry：4,5,6,7

退出循环

carry.swap(counter[i]); ->counter[2]:4,5,6,7

++fill; ->fill：3

.....

for (int i = 1; i < fill; ++i) counter[i].merge(counter[i-1]); ->最后来一次总的归并

总结：

将前两个元素归并，再将后两个元素归并，归并这两个小子序列成为4个元素的有序子序列；重复这一过程，得到8个元素的有序子序列，16个的，32个的。。。，直到全部处理完。主要调用了swap和merge函数，而这些又依赖于内部实现的transfer函数(其时间代价为O(1))。该mergesort算法时间代价亦为n*lg(n)，计算起来比较复杂。list_sort中预留了 64个temp_list（counter[64]），所以最多可以处理2^64-1个元素的序列，这应该足够了。

6.说说std::deque的底层机制。

deque动态地以分段连续空间组合而成，随时可以增加一段新的连续空间并串接在这个deque的头端或尾端。deque采用一块map（不是STL的map容器）作为主控，其为一小块连续空间，其中每个元素都是指针，指向另一段较大的连续空间（缓冲区）。

deque的迭代器包含4个内容：

1）cur：迭代器当前所指元素

2）first：此迭代器所指的缓冲区的头。

3）last：缓冲区尾。

4）node：指向管控中心。

注意：除非必要，我们尽可能选择使用vector而非deque，因为deque的迭代器比vector迭代器复杂很多。对deque排序，为了提高效率，可先将deque复制到一个vector上排序，然后再复制回deque。

6. deque与vector的区别。

1）vector是单向开口的连续线性空间，deque是双向开口的连续线性空间。（双向开口是指可以在头尾两端分别做元素的插入和删除操作）。

2）deque没有提供空间保留功能，而vector则要提供空间保留（reserve）功能。（因为像vector那样因旧空间不足而重新分配一块更大的空间，然后复制元素，在释放就空间这样的事在deque不会发生）

3）deque也提供随机访问迭代器，但是其迭代器比vector迭代器复杂很多。

7.不允许有遍历行为的容器有哪些（不提供迭代器）？

1）queue，除了头部外，没有其他方法存取deque的其他元素。

2）stack（底层以deque实现），除了最顶端外，没有任何其他方法可以存取stack的其他元素。

3）heap，所有元素都必须遵循特别的排序规则，不提供遍历功能。

7.说说std::map底层机制。

map以RB-TREE为底层机制。RB-TREE是一种平衡二叉搜索树，自动排序效果不错。

通过map的迭代器不能修改其键值，只能修改其实值。所以map的迭代器既不是const也不是mutable。

8.vector插入删除和list有什么区别？

vector是一个线性顺序结构，相当于数组，vector插入和删除数据，需要对现有数据进行复制移动，如果vector存储的对象很大或者构造函数很复杂，则开销较大，如果是简单的小数据，效率优于list。

list是环状双向链表，以结点为单位存放数据，结点的地址在内存中不一定连续，插入和删除数据，需要对现有数据进行遍历，但在首部插入数据，效率很高。

9.hashtable如何避免地址冲突？

1）线性探测：先用hash function计算某个元素的插入位置，如果该位置的空间已被占用，则继续往下寻找，知道找到一个可用空间为止。

进行元素搜索的时候，如果hash function计算出来的位置上的元素值与我们搜寻目标不符，就循环往下一一寻找，直到找到吻合者，或直到遇上空格元素。

其删除采用惰性删除：只标记删除记号，实际删除操作等到表格重新整理时再进行。（因为hash table中的每一个元素不仅表述它自己，也关系到其他元素的排列。）

2）二次探测：如果计算出的位置为H且被占用，则依次尝试H+1^2，H+2^2等（解决线性探测中主集团问题）。

3）开链：每一个表格元素中维护一个list，hash function为我们分配一个list，然后在那个list执行插入、删除等操作。

10.hashtable，hash_set，hash_map的区别。

hash_set以hashtable为底层，不具有排序功能，能快速查找。其键值就是实值。（set以RB-TREE为底层，具有排序功能。）

hash_map以以hashtable为底层，没有自动排序功能，能快速查找，每一个元素同时拥有一个实值和键值。（map以RB-TREE为底层，具有排序功能。）

11.hash_map与map的区别？什么时候用hash_map，什么时候用map？

构造函数：hash_map需要hash function和等于函数，而map需要比较函数（大于或小于）。

存储结构：hash_map以hashtable为底层，而map以RB-TREE为底层。

总的说来，hash_map查找速度比map快，而且查找速度基本和数据量大小无关，属于常数级别。而map的查找速度是logn级别。但不一定常数就比log小，而且hash_map还有hash function耗时。

如果考虑效率，特别当元素达到一定数量级时，用hash_map。

考虑内存，或者元素数量较少时，用map。

注：

树查找，在总查找效率上比不上hash表，但是它很稳定，它的算法复杂度不会出现波动。在一次查找中，你可以断定它最坏的情况下其复杂度不会超过O(log2N)。而hash表就不一样，是O(1)，还是O(N)，或者在其之间，你并不能把握。假若你在开发一个供外部调用的接口，其内部有关键字的查找，但是这个接口调用并不频繁，你是会希望其调用速度快、但不稳定呢，还是希望其调用时间平均、且稳定呢。反之假若你的程序需要查找一个关键字，这个操作非常频繁，你希望这些操作在总体上的时间较短，那么hash表查询在总时间上会比其他要短，平均操作时间也会短。这里就需要权衡了。

　　这里总结一下，选用map还是hash_map，关键是看关键字查询操作次数，以及你所需要保证的是查询总体时间还是单个查询的时间。如果是要很多次操作，要求其整体效率，那么使用hash_map，平均处理时间短。如果是少数次的操作，使用 hash_map可能造成不确定的O(N)，那么使用平均处理时间相对较慢、单次处理时间恒定的map，考虑整体稳定性应该要高于整体效率，因为前提在操作次数较少。如果在一次流程中，使用hash_map的少数操作产生一个最坏情况O(N)，那么hash_map的优势也因此丧尽了。

12.红黑树有什么性质？

红黑树（Red Black Tree）是一种自平衡二叉查找树

1）每个结点是红色或者黑色。

2）根结点为黑色。

3）叶结点为黑色的NULL结点。

4）如果结点为红，其子节点必须为黑。

5）任一结点到NULL的任何路径，所含黑结点数必须相同。

和AVL的区别

http://blog.csdn.net/hustyangju/article/details/27214251?utm_source=tuicool&utm_medium=referral

13.map和set的3个问题。

1）为何map和set的插入删除效率比其他序列容器高。

底层实现是红黑树，插入删除都是logn的；不需要内存拷贝和内存移动

2）为何map和set每次Insert之后，以前保存的iterator不会失效？

mpp和set的内存时不连续的，因为插入操作只是结点指针换来换去，其他结点内存没有改变。而iterator就像指向结点的指针，内存没变，指向内存的指针也不会变。

2）当数据元素增多时（从10000到20000），map的set的查找速度会怎样变化？

RB-TREE用二分查找法，时间复杂度为logn，所以从10000增到20000时，查找次数从log10000=14次到log20000=15次，多了1次而已。

14.vector中begin和end函数返回的是什么？

begin返回的是第一个元素的迭代器，end返回的是最后一个元素后面位置的迭代器。

15.为什么vector的插入操作可能会导致迭代器失效？

vector动态增加大小时，当空间大小不足时，并不是在原空间后增加新的空间，而是以原大小的两倍在另外配置一片较大的新空间，然后将内容拷贝过来，并释放原来的空间。由于操作改变了空间，所以迭代器失效。

16.vector、list、map、deque用erase（it）后，迭代器的变化。

vector和deque是序列式容器，其内存分别是连续空间和分段连续空间，删除迭代器it后，其后面的迭代器都失效了，此时it及其后面的迭代器会自动加1，使it指向被删除元素的下一个元素。

list删除迭代器it时，其后面的迭代器都不会失效，将前面和后面连接起来即可。

map也是只能使当前删除的迭代器失效，其后面的迭代器依然有效。

17.hashtable和hashmap的区别

hashmap以hashtable为底层。主要有以下几点不同：

1）hashtable是Dictionary的子类，而hashmap是Map接口的一个实现类。

2）hashtable中的方法是同步的，而hashmap的方法不同步。

18.STL的底层数据结构实现

1）vector：底层数据结构为数组，支持快速随机访问。

2）list：底层数据结构为双向链表，支持快速增删。

3）deque：底层数据结构为一个中央控制器和多个缓冲区，支持首尾（中间不能）快速增删，支持随机访问。

4）stack：底层用deque或者list实现，不用vector的原因是扩容耗时。

5）queue：底层用deque或者list实现，不用vector的原因是扩容耗时。

6）priority_queue：底层数据结构一般以vector为底层容器，heap为处理规则来管理底层容器实现。

7）set：底层数据结构为红黑树，有序，不重复。

8）multiset：底层数据结构为红黑树，有序，可重复。

9）map：底层数据结构为红黑树，有序，不重复。

10）multimap：底层数据结构为红黑树，有序，可重复。

11）hash_set：底层数据结构为hashtable，无序，不重复。

12）hash_map：底层数据结构为hashtable，无序，不重复。

13）hashtable：底层数据结构是vector。

19、总结

20、空间配置器

21、迭代器失效

deque迭代器失效

STL的erase()陷阱-迭代器失效总结

22、vector释放内存swap

24、map insert返回值

map在进行插入的时候是不允许有重复的键值的，如果新插入的键值与原有的键值重复则插入无效，可以通过insert的返回值来判断是否成功插入。下面是insert的函数原型：

 pair<iterator, bool> insert(const value_type& x);

可以通过返回的pair中第二个bool型变量来判断是否插入成功。下面是代码：

#include <map>
#include <iostream>

int main(){

    std::map< int,int > ll;
    ll.insert( std::pair< int,int >(1,2) );

    std::pair< std::map< int,int >::iterator,bool > ret;
    ret=ll.insert( std::pair< int,int >(1,3) );
    
    if( ret.second ){
        std::cout<<"成功"<<std::endl;
    }
    else{
        std::cout<<"失败"<<std::endl;
    }

    return 0;
}

25、traits编程技术

在算法中运用迭代器时，很可能会用到其相应型别（eg 迭代器所指之物）。可以利用function templdate的参数推导机制

template<typename Iterator, typename T>  
void func_impl(Iterator iter, T t)  
{  
    T temp;//这里就解决了问题  
    //这里做原本func()的工作  
}  
  
template<typename Iterator>  
void func(Iterator iter)  
{  
    func_impl(iter, *iter);//func的工作全部都移到func_impl里面了  
}  
  
int main(int argc, const char *argv[])  
{  
    int i;  
    func(&i);  
}

以func()为对外接口，把实际操作全部置于func_impl中。由于func_impl是一个function template，一旦被调用，编译器会自动进行template参数推导，推导出型别T。

为了推导函数的返回值型别，更好的方法时声明内嵌型别

template<class T>  
class Iterator  
{  
public:  
    typedef T value_type;//内嵌类型声明  
    Iterator(T *p = 0) : m_ptr(p) {}  
    T& operator*() const { return *m_ptr;}  
    //...  
  
private:  
    T *m_ptr;  
};  
  
template<typename Iterator>  
typename Iterator::value_type  //以迭代器所指对象的类型作为返回类型，返回型别必须加上关键词typename，因为T是一个template参数，再被
func(Iterator iter)            //编译器具现化之前，编译器对T义务所知，即编译器此时并不知道MyIter<T>现在是一个型别或是一个data member
{  
    return *iter;  
}  
  
int main(int argc, const char *argv[])  
{  
    Iterator<int> iter(new int(10));  
    cout<<func(iter)<<endl;  //输出：10  
}

为class type声明一个class template iterator_traits来萃取迭代器特性
如果不是class type，就无法为他定义内嵌型别，利用偏特化，为原生指针设计特化版的迭代器

template<typename Iterator>  
struct iterator_traits  
{  
    typedef typename Iterator::value_type value_type;  
};

//iterator_traits的偏特化版本，针对迭代器是个原生指针的情况  
template<typename T>  
struct iterator_traits<T*>  
{  
    typedef T value_type;  
};

原生指针的const指针型别萃取的型别应该为no const版本

template<typename T>  
struct iterator_traits<const T*>  
{  
    typedef T value_type;  
}

最常使用的迭代器型别应该有五中

tempalte<typename I>  
struct iterator_traits  
{  
    typedef typename I::iterator_category iterator_category;  
    typedef typename I::value_type value_type;  
    typedef typeanme I:difference_type difference_type;  
    typedef typename I::pointer pointer;  
    typedef typename I::reference reference;  
};

设计适当的相应型别，是迭代器的责任。设计适当的迭代器，是容器的责任。唯有迭代器本身，才知道该设计出怎样的迭代器来遍历自己，并执行迭代器该有的各种行为。

至于算法，完全独立于容器和迭代器之外自行发展，只要设计时以迭代器为对外接口就可以了。

pmt123456

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
STL

1.说说std::vector的底层（存储）机制。 vector就是一个动态数组，里面有一个指针指向一片连续的内存空间，当空间不够装下数据时，会自动申请另一片更大的空间（一般是增加当前容量的50%或100%），然后把原来的数据拷贝过去，接着释放原来的那片空间；当释放或者删除里面的数据时，其存储空间不释放，仅仅是清空了里面的数据。2.std::vector的自增长机制。
复制链接

扫一扫