STL组件

打印容器内的所有元素

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

sort排序

struct comp
{
    bool operator()(int x, int y) const // 由大到小
        {
            return x>y;
        }
};
std::sort(vi1.begin(), vi1.end(), comp());

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);

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;

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());

迭代器

Insert iterators(安插型迭代器) 它可以解决算法的“目标空间不足”问题,它可以促使目标区间的大小按需要成长;

Stream iterators(流迭代器)

Reverse Iterators(逆向迭代器)

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());

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");
}

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");
}

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;
}

自定义泛型函数

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成员值)。

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;
}

仿函数,行为类似如函数的对象

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;
}

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

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

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

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

千万不要将auto_ptr当做容器元素;

vector 动态数组

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

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

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

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

deque 双端队列

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

list 双向链表

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

list对于异常的处理方式是:要么操作成功,要么什么都不发生;

set和multiset,通常有平衡二叉树完成

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

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

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

map和multimap,通常以平衡二叉树完成,将key/value pair(键值对)当做元素

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

类似如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;
}

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

发表评论

电子邮件地址不会被公开。 必填项已用*标注

鄂ICP备17003086号. Copyright © 2016. All Rights Reserved.