C++与STL的一些总结

1、不能作为类的成员的是自身类对象，可以作为类的成员的是自身类对象的指针，自身类对象的引用。

2、下列程序的输出结果是10,20,30

#include <iostream.h>

void main()

{

int n[][3] = {10,20,30,40,50,60};

int (*p)[3];

p = n;

cout << p[0][0] << “,”<<*(p[0]+1)<<”,”<<(*p)[2] << endl;

}

3、定义类的动态对象数组时，系统只能够自动调用该类的无参构造函数对其进行初始化。

4、对复制运算符继续拧重载时，应声明为类成员函数。

5、String类的find方法返回查找到的字符串在主串的位置。

6、格式控制输入输出的操作中，函数setfill（char）是用来设置填充字符。

7、设函数sum是由函数模板实现的，并且sum(3,6)和sum(4,6,8)都是正确的函数调用，则函数模板具有2个类型参数。

8、在类内部不能对数据成员直接进行赋值。

9、抽象类是为了抽象和设计的目的而建立的，处于继承层次结构的上层。具体类是能够建立对象的类。抽象类的规定：（1）抽象类只能用作其他类的基类，不能建立抽象类对象。（2）抽象类不能用作参数类型、函数返回类型或显式转换的类型。（3）可以定义指向抽象类的指针和引用，此指针可以指向它的派生类，进而实现多态性。

10、假定AB为一个类，则执行“AB a(2),b[3],*p[4];”语句时调用该类构造函数的次数为4次。指针没有给他分配空间，没有调用构造函数。

11、this指针存在的目的是保证每个对象拥有自己的数据成员，但共享处理这些数据成员的代码。

12、已知：p是一个指向类A数据成员m的指针，A1是类A的一个对象。如果要给m复制为5，正确的写法是：A1.*p = 5.

13、在C++体系中，不能被派生类继承的有构造函数、拷贝构造函数、赋值函数、析构函数。

14、静态成员函数不能说明为虚函数。

15、一个抽象类的派生类可以实例化的必要条件是实例化，所以派生类要实例化必须对纯虚函数进行定义。

16、在C++程序设计中，简历继承关系倒挂的树应使用单继承。

17、C++语言中如果调用函数时，需要改变实参或者返回多个值，应该采取传地址或引用的方式。

18、对于int *pa[5];的描述，正确的是pa是一个具有5个元素的指针，该元素是int型指针。

19、设类A有成员函数void f(void)；若要定义一个指向类成员函数的指针变量pf来指向f,该指针变量的声明语句是：void (A::*f)(void)=&A::f。

20、已知f1和f2是同一类的两个成员函数，但f1不能直接调用f2，这说明f1是静态函数，f2不是静态函数。普通成员函数可以调用静态函数，相反静态函数不能调用普通成员函数。

21、关于C++编译指令，一下叙述正确的是（B）

A.C++每行可以写多条编译指令。

B.#include指令中的文件名可含有路径信息。

C.C++的编译指令可以以#或//开头。

D.C++中不管#if后的常量表达式是否为真，该部分都需要编译。

22、C++派生类使用两种基本的面向对象技术：第一种称为性质约束，即对基类的性质加以限制；第二种称为性质扩展，即增加派生类的性质。

23、预处理语句有三种，分别是宏定义、文件包含和条件编译。

24、要实现动态联编必须通过对象指针或引用调用虚函数。在构造函数和析构函数中调用虚函数时采用静态联编。

25、注意：当一个类的某个函数被声明为virtual时，该函数在该类的所有派生类中都是虚函数。

26、所谓数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是类。

 

1. C中static有什么作用

（1）隐藏。 当我们同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性，故使用static在不同的文件中定义同名函数和同名变量，而不必担心命名冲突。（2）static的第二个作用是保持变量内容的持久。存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。共有两种变量存储在静态存储区：全局变量和static变量。（3）static的第三个作用是默认初始化为0.其实全局变量也具备这一属性，因为全局变量也存储在静态数据区。在静态数据区，内存中所有的字节默认值都是0×00,某些时候这一特点可以减少程序员的工作量。

2.C++中const有什么用？

不要一听到const就说是常量，这样给考官一种在和一个外行交谈的感觉。应该说const修饰的内容不可改变就行了， 定义常量只是一种使用方式而已，还有const数据成员，const参数， const返回值， const成员函数等， 被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。

3. C与C++各自是如何定义常量的？有什么不同？

C中是使用宏#define定义， C++使用更好的const来定义。

区别：1）const是有数据类型的常量，而宏常量没有，编译器可以对前者进行静态类型安全检查，对后者仅是字符替换，没有类型安全检查，而且在字符替换时可能会产生意料不到的错误（边际效应）。

2）有些编译器可以对const常量进行调试， 不能对宏调试。

4. 既然C++中有更好的const为什么还要使用宏？

const无法代替宏作为卫哨来防止文件的重复包含。

5. C++中引用和指针的区别？

引用是对象的别名， 操作引用就是操作这个对象， 必须在创建的同时有效得初始化（引用一个有效的对象， 不可为NULL）， 初始化完毕就再也不可改变， 引用具有指针的效率， 又具有变量使用的方便性和直观性， 在语言层面上引用和对象的用法一样， 在二进制层面上引用一般都是通过指针来实现的， 只是编译器帮我们完成了转换。 之所以使用引用是为了用适当的工具做恰如其分的事， 体现了最小特权原则。

6. 说一说C与C++的内存分配方式？

1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在，如全局变量，static变量。

2）在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。

3）从堆上分配（动态内存分配）程序在运行的时候用malloc或new申请任意多少的内存，程序员负责在何时用free或delete释放内存。动态内存的生存期自己决定，使用非常灵活。

7. new/delete 与 malloc（）/free（） 的区别？

malloc（） 与 free（） 是C语言的标准库函数， new/delete 是C++的运算符， 他们都可以用来申请和释放内存， malloc（）和free（）不在编译器控制权限之内， 不能把构造函数和析构函数的任务强加给他们。

8. #include<a.h>和#include"a.h" 有什么区别？

答：对于#include <a.h> ,编译器从标准库路径开始搜索 a.h对于#include "a.h" ,编译器从用户的工作路径开始搜索 a.h

9. 在C++ 程序中调用被 C编译器编译后的函数，为什么要加 extern "C"?

C++语言支持函数重载，C语言不支持函数重载。函数被C++编译后在库中的名字与C语言的不同。假设某个函数的原型为： void foo（int x, int y）；该函数被C编译器编译后在库中的名字为_foo,而C++编译器则会产生像_foo_int_int之类的名字。C++提供了C连接交换指定符号extern"C"来解决名字匹配问题。

10. C++中的什么是多态性？ 是如何实现的？

多态性是面向对象程序设计语言继数据抽象和继承之后的第三个基本特征。它是在运行时出现的多态性通过派生类和虚函数实现。基类和派生类中使用同样的函数名， 完成不同的操作具体实现相隔离的另一类接口，即把" w h a t"从"h o w"分离开来。多态性提高了代码的组织性和可读性，虚函数则根据类型的不同来进行不同的隔离。

11. 什么是动态特性？

在绝大多数情况下， 程序的功能是在编译的时候就确定下来的， 我们称之为静态特性。 反之， 如果程序的功能是在运行时刻才能确定下来的， 则称之为动态特性。C++中， 虚函数，抽象基类， 动态绑定和多态构成了出色的动态特性。

12. 什么是封装？C++中是如何实现的？

封装来源于信息隐藏的设计理念， 是通过特性和行为的组合来创建新数据类型让接口与具体实现相隔离。C++中是通过类来实现的， 为了尽量避免某个模块的行为干扰同一系统中的其它模块，应该让模块仅仅公开必须让外界知道的接口。

13. 什么是RTTI?

RTTI事指运行时类型识别（Run-time type identification）在只有一个指向基类的指针或引用时确定一个对象的准确类型。

14. 什么是拷贝构造函数？

它是单个参数的构造函数，其参数是与它同属一类的对象的（常）引用；类定义中，如果未提供自己的拷贝构造函数，C++提供一个默认拷贝构造函数，该默认拷贝构造函数完成一个成员到一个成员的拷贝

15. 什么是深浅拷贝？

浅拷贝是创建了一个对象用一个现成的对象初始化它的时候只是复制了成员（简单赋值）而没有拷贝分配给成员的资源（如给其指针变量成员分配了动态内存）； 深拷贝是当一个对象创建时，如果分配了资源，就需要定义自己的拷贝构造函数，使之不但拷贝成员也拷贝分配给它的资源。

16. 面向对象程序设计的优点？

开发时间短， 效率高， 可靠性高。面向对象编程的编码具有高可重用性，可以在应用程序中大量采用成熟的类库（如STL），从而虽短了开发时间，软件易于维护和升级。

 

 

STL中要注意的地方

1、vecor、list、set、map移除指定所有指定值的方法：

vector移除所有值为value的值：

（1）STL算法：coll1.erase(remove(coll1.begin(),coll1.end(),5),coll1.end());

（2）for循环：for（；iter != coll1.end()；）{if(*iter ==  value) iter = coll1.erase(iter;)else

++iter;}。注意：iter = coll.erase.erase(iter) 不能改成coll.erase.erase(iter++)。

list移除所有值为value的值：

（1）STL算法：coll2.remove(value);

（2）for循环：for(；iter2 != coll2.end()；){if(*iter2 == value)coll2.erase(iter2++);}else

++iter2;}。这里的指针和引用都不失效。

set和map移除所有值为value的值：

（1）coll3.erase(value);注意：删除的value,set是value，map是key。

（2）for循环：for(；iter3 != coll3.end()；){if(*iter3 == value)coll3.erase(iter3++);}else

++iter3;}。这里的指针和引用都不失效。map的删除判断是if(iter3->second == value)。

2、怎么样其选择使用哪种容器：

vector采用线性空间存储数据，如果空间不够，则另外分配新的两倍大小的空间。然后把旧空间释放掉。vector进行随机访问方便，即支持[]操作符和vector.at(),节省空间。不适合中间插入删除操作，中间插入删除操作会引起内存拷贝。

list采用非线性的空间存储数据。list适合插入删除频繁地场所。不管插入还是删除，时间基本上都是常数。List不适合随机线性访问,相对于vector占用的内存多。

deque 采用类似文件系统的方式存储数据。其中有数个连续空间的缓存区存储数据。这些缓冲区连接起来，给上层用户一个假象就是，存储的数据空间是连续的。deque是list和vector的这种方案，兼容它们的优点。deque仍旧不适合中间插入删除操作，deque适合线性随机访问数据。deque占用的内存多。

如果你需要高效的随即存取，而不在乎插入和删除的效率，使用vector 。

如果你需要大量的插入和删除，而不关心随即存取，则应使用list 。

如果你需要随即存取，而且关心两端数据的插入和删除，则应使用deque

stack是deque的一种变种，优缺点不变。

queue是deque的一种变种，优缺点不变。

heap容器采用二叉树存储数据。所以heap容器适合经常排序的场所，heap容器里的数据是自动排序的。

关联容器的有点在于他提供了对元素的快速访问。set,multiset,map,multimap。

 

容器名	名称	数据结构	性能	备注
string	通用字符串库	连续存放的内存块、 有保留内存 堆中分配内存	高效率的随机访问； O（1）的访问时间； 在最后增加元素时，一般不需要分配内存空间，速度快； 在中间或开始操作元素时要进行内存拷贝效率低； 支持[]操作;
Vector	通用向量（数组）库	变长一维数组； 连续存放的内存块； 有保留内存； 堆中分配内存；	高效率的随机访问； O（1）的访问时间 在最后增加元素时，一般不需要分配内存空间，速度快； 在中间或开始操作元素时要进行内存拷贝效率低; 支持[]操作;	需要高效的随即存取，而不在乎插入和删除使用vector
list	通用链表库	双向链表； 内存空间上可能是不连续; 无保留内存 堆中分配内存；	随机存储需要遍历指针所以效率低; 很高的效率进行任意地方删除插入; 开始和结尾元素的访问时间快,其它元素都O（n）;	大量的插入和删除，而不关系随即存取使用list
deque		双端队列; 在堆上分配内存; 个堆保存几个元素，而堆之间使用指针连接;	支持[]操作; 像是list和vector的结合;	关心插入和删除并关心随即存取折中使用deque
set	通用集合库	集合; 无序的保存元素
map	通用字典库	平衡二叉树; 一个值映射成另一个值	查找某一值是常数时间O(1);  每次插入值的时候，会重新构成底层的平衡二叉树，效率有一定影响	创建字典时使用

 

3、小心对“容器无关代码”的幻想。

4、使容器里对象的拷贝操作轻量而正确。

拷贝对象是STL的方式。由于继承的存在，拷贝会导致分割，也就是说，如果你以对象建立一个容器，而你试图插入派生类对象，那么当对象（通过基类的拷贝构造函数）拷贝容器的时候对象的派生部分会被删除。如果使用指针拷贝就没有分割。

5、用empty()来代替检车size()==0。

6、尽量使用区间成员函数代替它们的单元素兄弟。尽量少使用for循环单个元素进行操作，而使用容器的自带的功能函数和区间函数。

7、永不建立auto_ptr的容器。

8、尽量使用vector和string来替代动态分配的数组。使用reserve来避免不必要的内存重新分配，在开始创建的时候使用reserve来分配内存。

9、小心string实现的多样性。在实现中，每个string对象包含一个它配置器的拷贝，字符串的大小，它的容量，和一个指向包含引用计数（“RefCnt”）和字符串值的的缓冲区的指针。

10、string对象的大小可能从1到至少7倍char*指针的大小。新字符串值的建立可能需要0、1或2次动态分配。string对象可能是或可能不共享字符串的大小和容量信息。不同实现对于最小化字符缓冲区的配置器有不同策略。

11、避免使用vector<bool>。

12、可以使用交换技巧来修整过剩容器。

13、使用vector和string来将数据传给遗留的API。

14、了解相等和等价的区别。不同版本基于相等比较的依据不同，有的是基于相等，有的是基于等价。

15、如果容器里面存储的是对象的指针类型，那么他们比较默认是的通过指针进行比较的，需要对容器里面的元素比较或者排序规则进行重新定义。

 

容器：

1、容器操作中的zise(),empty(),max_size(）操作是非变动性性操作，定义为const，所以是常量函数。

2、序列容器和关联容器都支持元素间的比较。

3、set、map使用count计算与value相等的元素个数。使用容器的算法find、lower_bound、upper_bound、equal_range、key_comp、value_comp作为set、map的非变动性操作。

4、operator=操作，序列容器和关联容器都有对应的操作，返回容器。

assign（num,value）操作用于关联容器，assign（beg,end）操作用于序列容器，都返回void。

c1.swap(c2)、swap(c1,c2)用于关联容器和序列容器的交换，返回void。

5、at和operator[]操作中，vector、deque、string如果用at修改了值或内存重新分配了，可能会导致返回的reference失效。传给一个无效索引，会抛出out_of_range的异常。

6、map的operator[]（const key_value key）操作会导致新元素的添加，返回的是value型别。

7、front、back的操作中，如果没有元素，会导致未定义行为。适用于vector、deque、list。

8、set、multiset、map、multimap支持insert(value)操作，返回迭代器。set、map如果插入已有的元素，会返回一个现有元素的位置和一个false，无法再次插入，插入成功，返回迭代器和true。对于vector、deque、list、string，返回void，并且操作不会带来任何影响。

9、insert（pos,value)使用常用的容器，对于关联容器，pos没有特别的作用，只适用于开始插入位置的搜寻起点。会导致vector、deque的迭代器和引用无效。对于string，value并不采用pass by reference。

10、insert(beg,end)适用于set、multiset、map、multimap、string类型容器,返回void。insert(pos,beg,end)适用于vector、deque、list、string。

11、push_front适用于deque和list。对于deque操作会导致指向其他元素的iterator失效，不会导致指向其他元素的引用失效。返回void.

12、push_back适用于vector、list、deque、string。会导致一些迭代器(vector、deque)和引用(vector)失效。

13、list有专门的remove和remove_if成员函数，其他的容器只有使用STL中的版本，都会调用相应的析构函数。

14、erase(pos)、erase(beg,end)操作使用与所有的容器，对于序列容器，返回类型为迭代器，对于关联容器，返回类型为void。调用者必须确保迭代器pos是有效的。对于vector和deque，此操作可能会导致迭代器和引用失效。被移除的元素会调用其元素的析构函数。

15、pop_front如果元素为空，会导致未定义行为,不会抛出异常。适用于deque和list。pos_back如果元素为空，会导致未定义行为,不会抛出异常。适用于vector、deque和list。

16、resize(num)、resize(num,value)适用vector、deque、list、string。如果小于size(),则移除尾端元素。

17、clear适用序列容器和关联容器。调用析构函数。

18、list类型容器还有unque、splite、sort、merge，reverse等操作。其中有些函数会导致未定义行为，但是不会抛出异常。

 

算法：

1、遍历算法：for_each(beg,end,op)返回的是op的类型，op可以改变元素。时间复杂度为numberOfElements次。

2、元素计数：count(beg,end,value),count_if(beg,end,op)。返回的是difference_type类型。时间复杂度为numberOfElements次。

3、min_element(beg,end),min_element(beg,end,op),max_element(beg,end),max_element(beg,end,op)。返回迭代器。时间复杂度为numberOfElements-1次。

4、find(beg,end),find_if(beg,end,op)。其中op不应该改动传递过来的参数。必须要保证迭代的是一个有效的区域，返回迭代器。时间复杂度为numberOfElements次。

5、search_n(beg,end,cout,value)、search_n(beg,end,cout,value,op)。返回第一个迭代器，第一组元素的位置。op不应该改动传递过来的参数。时间复杂度为numberOfElements*count次。

6、search(beg,end,searchbeg,searchend),search(beg,end,searchbeg,searchend,op)。返回吻合的第一个区间内的第一个元素的位置。op不应该改动传递过来的参数。时间复杂度为numberOfElements*numberOfSearchElements次。

7、find(beg,end,searchbeg,searchend),find(beg,end,searchbeg,searchend,op)。返回吻合的最后一个区间内的第一个元素的位置。op不应该改动传递过来的参数。时间复杂度为numberOfElements*numberOfSearchElements次。

8、find_first_of(beg,end,searchbeg,searchend),find_first_of(beg,end,searchbeg,searchend,op)。返回吻合的第一个区间内的第一个元素的位置。op不应该改动传递过来的参数。时间复杂度为numberOfElements*numberOfSearchElements次。

9、adjuent_find(beg,end),adjuent_find(beg,end,op)。返回连续两个相等（op为true）元素的第一个元素的位置。时间复杂度为numberOfElements次。

10、equal(beg,end,cmpbeg),equal(beg,end,cmpbeg,op)。返回bool值。确保cmpbeg开头的区间的元素足够。时间复杂度为numberOfElements次。

11、mismatch(beg,end,cmpbeg),mismatch(beg,end,cmpbeg,op)。返回连续两个相异（op为true）元素的两个迭代器的位置。时间复杂度为numberOfElements次。

12、lexicographical_compare(beg1,end1,beg2,end2),lexicographical_compare(beg1,end1,beg2,end2,op)。返回bool值。不一定两区间的元素足够作为比较。时间复杂度为2*min(numberOfElements1,numberOfElements2)次。

13、copy(sourcebeg,sourceend,destbeg),copy_backward(sourcebeg,sourchend,destend)。destbeg,deskend不处于[sourcebeg,sourceend)区间中。返回最后一个呗复制的元素的下一位置。时间复杂度为numberOfElements次。

14、transform(sourcebeg,sourceend,destbeg,destend,op)，transform(sourcebeg1,sourceend1,sourcebeg2，destbeg,destend,op)。返回目标区域中最后一个被转换的元素的下一位置。时间复杂度为numberOfElements次。

15、swap_ranges(beg1,end1,beg2)。返回第二区间中的最会一个被替换的下一个位置。需要确保区间的元素足够。如果相同型别的两个容器内全部元素进行互换，应使用swap()成员函数。时间复杂度为numberOfElements次。

16、fill(beg,end,value),fill_n(beg,num,value)。返回void。需要保留足够的空间，否则使用插入迭代器。时间复杂度为numberOfElements或num次。

17、generate(beg,end,op),generate(beg,num,op)。返回void。需要保留足够的空间，否则使用插入迭代器。时间复杂度为numberOfElements或num次。

18、replace(beg,end,oldvalue,newvalue),replace_if(beg,end,op,newvalue)。返回void。时间复杂度为numberOfElements次。

19、replace_copy(sourcebeg,sourceend,destbeg,oldvalue,newvalue),replace_copy_if(ourcebeg,sourceend,destbeg,op,newvalue)。返回最后一个被复制的元素的下一个位置。时间复杂度为numberOfElements次。

20、remove(beg,end,value),remove_if(beg,end,op)。返回新逻辑点。如果一元判别式在函数调用过程中改变状态，就可能导致问题。时间复杂度为numberOfElements次。

21、remove_copy(sourcebeg,sourceend,destbeg,value),remove_copy_if(sourcebeg,sourceend,destbeg,op)。op不应该改变自身状态。调用时必须确保目标区间够大，要不就是用插入行迭代器。返回最后一个被复制的元素的下一个位置。时间复杂度为numberOfElements次。

22、unique(beg,end),unique(beg,end,op)。返回新的逻辑终点。时间复杂度为numberOfElements次。此算法不适合用于关联容器。

23、unique_copy(sourcebeg,sourceend,destbeg),unique_copy(sourcebeg,sourceend,destbeg,op)。返回目标区间的最后一个呗复制的元素的下一个位置。需要保留足够的空间，否则使用插入迭代器。时间复杂度为numberOfElements次。

24、reverse(beg,end),reverse_copy(sourcebeg,sourceend,destbeg)。reverse返回void,reverse_copy返回目标区间中最后一个被复制元素的一下一位置。需要保留足够的空间，否则使用插入迭代器。时间复杂度为numberOfElements次。

25、rotate(beg,newbeg,end)。返回void。需要确保newbeg是区间[beg,end)内的一个有效位置，否则会引起未定义行为。时间复杂度为numberOfElements次。

26、rotate_copy(sourcebeg,newbeg,sourceend,destbeg)。返回void。返回目标区间最后一个呗复制的下一个位置。需要保留足够的空间，否则使用插入迭代器。时间复杂度为numberOfElements次。

27、next_permutation(beg,end),prev(beg,end)排序元素。返回bool值。时间复杂度为numberOfElements次。

28、random_shuffle(beg,end),random_shuffle(beg,end,op)重排元素(搅乱次序)。注意op是一个non-const reference。时间复杂度为numberOfElements-1次。

29、partition(beg,end,op),stable_partition(beg,end,op)。op不应该在函数调用过程中改变自身状态。时间复杂度为numberOfElements*log(numberOfElements)次。

30、sort(beg,end),sort(beg,end,op),stable_sort(beg,end),stable_sort(beg,end,op)。返回void。sort()和stable_sort()的区别是，后者保证相等元素的原本相对次序在排序后保持不变。不可以对list调用这些算法。时间复杂度为numberOfElements*log(numberOfElements)次。

31、partial_sort(beg,sortend,end),partial_sort(beg,sortend,end,op)。op不应该在函数调用过程中改变自身状态。时间复杂度为numberOfElements*log(numberOfElements)次。

32、partial_sort_copy(sourcebeg,sourceend,destbeg,deskend),partial_sort_copy(sourcebeg,sourceend,destbeg,deskend,op)。时间复杂度为numberOfElements*log(numberOfElements)次。

33、nth_element(beg,nth,end),nth_element(beg,nth,end,op)。上述第一种采用operator<作为排序准则。时间复杂度为线性。

34、make_heap(),push_heap(),pop_heap(),sort_heap()。参数表(beg,end),(beg,end,op)。都返回void。

时间复杂度分别为：3*numberOfElements次,log(numberOfElements)次,2*log(numberOfElements)次,numberOfElements*log(numberOfElements)次。

35、binary_search(beg,end,value)binary_search(beg,end,value,op)。返回bool类型。调用者必须保证进入算法之际，该区间已序。随机存取迭代器为最多log(numberOfElements)+2次，非随机存取迭代器为线性的。

36、include(beg,end,searchbeg,searchend),include(beg,end,searchbeg,searchend,op)。时间复杂度为：2*numberOfElements+searchElements)-1次比较操作。

37、lower_bound(beg,end,value),lower_bound(beg,end,value,op)。返回第一个大于value的位置。

upper_bound(beg,end,value),upper_bound(beg,end,value,op)。返回第一个小于value的位置。

equal_range(beg,end,value),equal_range(beg,end,value,op)。返回两个位置（pair）。

时间复杂度为：log(numberOfElements)+1次(随机存取迭代器)，log(numberOfElements)+1次(随机存取迭代器)，2*log(numberOfElements)+1次（随机存取迭代器）。其他情况为线性复杂度。

38、merge(),set_union(),set_intersection(),set_difference(),set_symmetric_difference()inplace_merge()。合并元素接口。前面五个算法参数为（source1beg,source1end,source2beg,source2end,destbeg）和(source1beg,source1end,source2beg,source2end,destbeg,op)，返回最后一个被操作的元素的下一个位置,时间复杂度为2*(numberOfNumberElements1+numberOfNumberElements2)-1。最后一个算法返回void,参数为(beg,end1beg2,end2)和(beg,end1beg2,end2,op),时间复杂度为numberOfElements*log(numberOfElements)次比较操作，返回void。上面的算法分别是两个已序序列的总和，并集，交集，差集，异或集，合并两个集合。