stl 学习笔记

比眉伴天荒 2021-12-12 02:57 331阅读 0赞

[http://blog.csdn.net/tujiaw/article/details/7704203][http_blog.csdn.net_tujiaw_article_details_7704203] 原文出处

STL组件

1.打印容器内的所有元素

std::copy(vi1.begin(),vi1.end(), std::ostream\_iterator<int>(std::cout, ", "));

2.sort排序

struct comp

bool operator()(int x, int y) const // 由大到小

return x>y;

\};

std::sort(vi1.begin(), vi1.end(), comp());

3.find、find\_if

find成功返回指向查找到的元素的位置，失败返回end();容器区间\[     ), 左边闭区间右边开区间

std::vector<int>::iterator iter = std::find(vi1.begin(), vi1.end(), 9);

if (iter == vi1.end())

std::cout << "fail" << std::endl;

else

std::cout << "success" << std::endl;

find\_if如果容器中的元素可以让pred返回值为真则找到了，否则没有找到

bool pred(int x)

return (x % 3 == 0);

std::vector<int>::iterator iter = std::find\_if(vi1.begin(), vi1.end(), pred);

4.stack

push, pop, top, size, empty

初始化，默认用deque

std::deque<int> que(5, 200);

const int xx\[\] = \{3, 56, 45, 234\};

const int len = sizeof(xx) / sizeof(xx\[0\]);

std::vector<int> vec(xx, xx+len);

std::stack<int> sta1(que);

std::stack<int, std::vector<int> > sta2(vec);

std::cout << sta1.top() << std::endl;

5.equal

通常处理这种有多个区间的算法，你必须设定第一个区间的起点和终点，至于至于其它区间，你只需设定起点即可，终点是由第一区间的元素数量推导出来的。所以要注意两个区间的实际元素个数!

int x\[5\] = \{3, 5, 2, 5, 3\};

int y\[5\] = \{3, 5, 2, 4, 3\};

std::vector<int> vi1(x, x+5);

std::vector<int> vi2(y, y+5);

bool isEqual = std::equal(vi1.begin(), vi1.end(), vi2.begin());

6.迭代器

Insert iterators（安插型迭代器）

它可以解决算法的“目标空间不足”问题，它可以促使目标区间的大小按需要成长；

Stream iterators（流迭代器）

Reverse Iterators（逆向迭代器）

7.remove

注意remove后容器中的元素个数是不变的

int num\[6\] = \{3, 5, 56, 2, 5, 1\};

vector<int> coll(num, num+6);

copy(coll.begin(), coll.end(), ostream\_iterator<int>(cout, " "));

cout << endl;

vector<int>::iterator reEnd = remove(coll.begin(), coll.end(), 5);

coll.erase(reEnd, coll.end()); // ！！！

copy(coll.begin(), coll.end(), ostream\_iterator<int>(cout, " "));

cout << endl;

或者合成一条语句：

coll.erase(remove(coll.begin(), coll.end(), 5), coll.end());

8.set

struct Greater

bool operator()(const int &x, const int &y) const

return x > y;

\};

int main(void)

int xx\[\] = \{43, 54, 2, 6, 34\};

const int num = sizeof(xx) / sizeof(xx\[0\]);

std::cout << "小到大" << std::endl;

typedef std::set<int> IntSet;

IntSet intSet(xx, xx+num);

std::copy(intSet.begin(), intSet.end(), std::ostream\_iterator<int>(cout, "\\n"));

std::cout << "大到小" << std::endl;

typedef std::set<int, Greater > IntSet2;

IntSet2 intSet2(xx, xx+num);

std::copy(intSet2.begin(), intSet2.end(), std::ostream\_iterator<int>(cout, "\\n"));

system("pause");

9.multimap

void PrintMap(std::pair<int, std::string> pr)

std::cout << pr.first << ", " << pr.second << std::endl;

int main(void)

typedef std::multimap<int, std::string> IntStrMap;

IntStrMap intStrMap;

intStrMap.insert(make\_pair(3, "third"));

intStrMap.insert(make\_pair(2, "second"));

intStrMap.insert(make\_pair(4, "fourth"));

for\_each(intStrMap.begin(), intStrMap.end(), PrintMap);

system("pause");

10.ostream\_iterator自定义输出，在类型里面重载不行？

typedef struct

int x, y;

\}T;

std::ostream& operator<<(std::ostream &os, const T &t)

os << t.x << ", " << t.y;

return os;

int \_tmain(int argc, \_TCHAR\* argv\[\])

T x\[3\] = \{ \{1, 2\}, \{3, 4\}, \{5, 6\}\};

std::vector<T> vec(x, x+3);

std::copy(vec.begin(), vec.end(), std::ostream\_iterator<T>(std::cout, "\\n"));

system("pause");

return 0;

11.自定义泛型函数

template<class T>

inline void PrintElems(const T &coll, const char \*str = "")

typename T::const\_iterator pos;

std::cout << str;

for (pos=coll.begin(); pos!=coll.end(); ++pos)

std::cout << \*pos << ' ';

std::cout << std::endl;

其中pos被声明为“传入之容器型别”内的迭代器型别，关键词typename在此不可或缺，用以表明const\_iterator是型别T所定义的一个型别，而不是一个型别为T的值（类似如类里面的某个public成员值）。

12. for\_each

void print(int elem)

std::cout << elem << ' ';

int main()

int arr\[5\] = \{1, 4, 6, 3, 2\};

std::vector<int> coll(arr, arr+5);

std::for\_each(coll.begin(),coll.end(), print);

return 0;

13.仿函数，行为类似如函数的对象

class AddValue

public:

AddValue(int value)

: \_value(value)

void operator()(int &elem) const

elem += \_value;

private:

int \_value;

\};

int main()

int arr\[5\] = \{1, 4, 6, 3, 2\};

std::vector<int> coll(arr, arr+5);

std::copy(coll.begin(), coll.end(), std::ostream\_iterator<int>(std::cout, " "));

std::cout << std::endl;

AddValue addten(10);

AddValue addone(1);

std::for\_each(coll.begin(), coll.end(), AddValue(100));

std::copy(coll.begin(), coll.end(), std::ostream\_iterator<int>(std::cout, " "));

return 0;

14.容器元素的条件：必须能进行copy构造、assignment操作符、析构函数

序列式容器元素的default构造函数必须可用；

对于某些动作，必须定义operator==以执行相等测试。如果你有搜寻需求这一点特别重要；

在关联式容器中，元素必须定义出排序准则。缺省情况下是operator<，透过仿函数less<>被调用；

千万不要将auto\_ptr当做容器元素；

15.vector 动态数组

支持随机存取，可以在常数时间内存取任何一个元素，在末端附加或删除元素时性能相当好，可是如果在前端或者中端安插或删除元素，性能就不怎么样了，因为操作点之后的每一个元素都必须移到另一位置，而每一次移动都得调用assignment操作符。

capacity()函数会返回vector实际能够容纳的元素数量，如果超过这个数量，vector就有必要重新配置内部存储器，这里会造成两个问题：一旦内存重新配置，和vector元素相关的所有references、pointer、iterators都会失效（???）；内存重新配置很耗时间。

所以如果vector中的元素是references、pointer、iterators一定要注意内存重新配置的问题。你可以用reserver()保留适当容量，避免一再重新配置内存，当然这个操作也是很费时间的。

swap()方法也会带来references、pointer、iterators失效。

16.deque 双端队列

内部结构类似如vector，只是在两端插入、删除元素很快。

17.list 双向链表

不支持随机存取，遍历元素缓慢；安插、移除元素很快，可以在常数时间内完成。安插和删除动作并不会造成指向其他元素的各个pointers、references、iterators失效；

list对于异常的处理方式是：要么操作成功，要么什么都不发生；

18.set和multiset，通常有平衡二叉树完成

会根据特定的排序准则，自动将元素排序，两者不同处在于multiset允许元素重复而set不允许。

由于自动排序所以你不能直接改变元素值，因为这样会打乱原本正确的顺序。因此，要改变元素值，必须先删除旧元素，再插入新元素。

注意排序准则是型别的一部分，在要求型别一致的地方，即要求排序准则也要一致。

19.map和multimap，通常以平衡二叉树完成，将key/value pair（键值对）当做元素

根据元素key自动对元素进行排序，用key来搜寻某个元素时有很好的性能，用value则性能很糟糕。你不可以直接改变元素的key，但可以改变value，如果要修改一个key，必须要移除该key的元素，然后再插入新的key/value元素。

20.类似如shared\_ptr智能指针

\#include <iostream>

\#include <cstdlib>

\#include <cstring>

template<class T>

class CountedPtr

public:

explicit CountedPtr(T \*p = 0)

: \_ptr(p), \_count(new long(1))

~CountedPtr()

dispose();

CountedPtr(const CountedPtr<T> &p)

: \_ptr(p.\_ptr), \_count(p.\_count)

++\*\_count;

CountedPtr<T>& operator=(const CountedPtr<T> &p)

if (this != &p)

dispose();

\_ptr = p.\_ptr;

\_count = p.\_count;

++\*\_count;

return \*this;

T& operator\*() const

return \*\_ptr;

T\* operator->() const

return \_ptr;

private:

void dispose()

if (--\*\_count == 0)

delete \_count;

delete \_ptr;

private:

T \*\_ptr;

long \*\_count;

\};

int main(void)

CountedPtr<char> p(new char);

CountedPtr<char> p2(p);

\*p2 = 'A';

std::cout <<  \*p << std::endl;

21 std::map查找的时候不区分大小写

// 不区分大小写  
struct nocase\_less : public std::binary\_function<std::string, std::string, bool>  
\{  
    bool operator() (const std::string& left,  const std::string& right) const  
    \{  
        return \_stricmp(left.c\_str(), right.c\_str()) < 0;  
    \}  
\};  
  
typedef string RowKey;  
typedef map<RowKey, RowValue, nocase\_less> CodeFileContent;    // 每行的相对路径作为key，其他作为value

[http_blog.csdn.net_tujiaw_article_details_7704203]: http://blog.csdn.net/tujiaw/article/details/7704203