C++ 学习笔记----模版与标准模板库篇

 

（一）模板

 

1、模板的基本知识：

　　（1）定义模板：

template <class T>
class Array {
      //......
};

　　（2）实例：

template <class T>
class Array {
public :
    T& operator[](int);
    const T& operator[](int) const;
    Array(int);
    ~Array();
    int get_size() const {return size;}
private :
    T* a;
    int size;
    Array();
    T dummy_val;
};

template <class T>
T& Array<T>::operator[](int i){
    if(i<0 || i>=size)
    {
        cerr<<"index "<<i<<" out of bounds: ";
        return dummy_val;
    }
    return a[i];
}
template <class T>
const T& Array<T>::operator[](int i) const {
    if(i<0 || i>=size)
    {
        cerr<<"index "<<i<<" out of bounds: ";
        return dummy_val;
    }
    return a[i];
}
template <class T>
Array<T>::Array(int s) {
    a = new T[size = s];
}
template <class T>
Array<T>::~Array(){
    delete[] a;
}

 

　　（3）模板的函数式参数：

template <class T, int X, float Y>
class Sample {
     //......
};

 

（二）标准模板库（STL：Standard Template Library）

 

1、基本知识：

　　（1）容器：对象的集合；包括：vector、stack、queue、list、set、map等；可以理解为数据结构；

　　（2）算法：对容器进行处理的函数；可以理解为处理数据结构的函数；

　　（3）迭代器：访问容器中对象的一种机制，一次访问一个对象；

 

2、容器：

　　（1）容器分为两组：序列式容器（vector、deque、list）和关联式容器（set、multiset、map、multimap）；

list	序列式	双向链表
vector	序列式	可伸缩数组
deque	序列式	两端进行有效插入和删除的数组
set	关联式	不含重复键的集合
multiset	关联式	允许重复的set
map	关联式	用键访问的不含重复的集合
multimap	关联式	允许重复键的map

 

　　（2）vector：是一个双向链表；插入和删除操作在尾部进行效率比较高；

#include <iostream>
#include <vector>

using namespace std;

int main(int argc, char argv[])
{
    int i;
    vector<int> nums;
    nums.insert(nums.begin(), -999);
    nums.insert(nums.begin(), 14);
    nums.insert(nums.end(), 57);
    for(i = 0;i<nums.size(); i++)  //size返回vector的大小
        cout<<nums[i]<<endl;       //可以使用 [] 访问其中的元素，因为vector重载了 []
    nums.erase(nums.begin());
    nums.erase(nums.begin());
    for(i = 0;i<nums.size(); i++)
        cout<<nums[i]<<endl;
    system("PAUSE");
    return 0;
} 

　　　　说明：vector支持在两端插入元素，并提供begin和end成员函数，分别用来访问头部和尾部元素，两个函数都返回一个可随机访问的迭代器；

　　　　　　   begin返回的迭代器：容器不为空，指向容器的第一个元素，容器为空，指向容器尾部之后的位置；

　　　　　　   end返回的迭代器：仅指向容器尾部之后的位置；

 

　　（3）deque：不管是在头部还是在尾部操作，效率是固定的；其他和vector类似；

　　（4）list：注意它的实现是“双向链表”；例如：

#include <iostream>
#include <list>
#include <string>

using namespace std;

void dump(list<string>& l)
{
    //list<const string>::const_iterator it;// list iterator
    list <string>::iterator it;
    it = l.begin();
    while(it != l.end())
    {
        cout<<*it<<endl;
        it++;
    }
}

int main(int argc, char argv[])
{
    list<string> names;
    names.insert(names.begin(), "Hello");
    names.insert(names.begin(), "World");
    names.insert(names.end(), "!");
    dump(names);
    names.reverse();
    cout<<endl;
    dump(names);
    system("PAUSE");
    return 0;
}

 

　　（5）vector、deque、list的比较：

基本序列式容器操作的时间复杂度

操作	vector	deque	list
在头部插入或删除元素	线性	恒定	恒定
在尾部插入或删除元素	恒定	恒定	恒定
在中间插入或删除元素	线性	线性	恒定
访问头部的元素	恒定	恒定	恒定
访问尾部的元素	恒定	恒定	恒定
访问中间的元素	恒定	恒定	线性

 

　　（6）基本关联式容器：set、multiset、map、multimap

　　　　  set是一种集合，其中可包含0个或多个不重复和不排序的元素，这些元素被称为键值。

　　　　  map也是一种集合，其中可包含0个或多个不重复和不排序的元素对，一个元素是不重复的键值，另一个是与键相关联的值。

　　　　  multiset是容许有重复键值的set；

　　　　  multimap是容许有重复键值的map；

 

　　（7）容器适配器：是基本容器的衍生物，并利用基本容器来实现其特定的功能；

　　　　  种类：stack、queue、priority_queue；

　　　　  stack适用于LIFO（后进先出）列表；

　　　　  queue适用于FIFO（先进先出）列表；

             priority_queue用于创建带优先级的队列，其元素以某种优先顺序进行删除；

 

　　（8）其它容器：string、bitset；

 

3、STL算法：排序、搜索、数值处理、集合运算、拷贝等

 

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

void dump(int i)
{
    cout<<i<<endl;
}
bool odd(int i)
{
    return i%2 != 0;
}
bool cmp(const int& i1,const int& i2)
{
    return i1 > i2;
}

int main(int argc, char argv[])
{
    vector<int> v(10);
    generate(v.begin(), v.end(), rand);

    replace_if(v.begin(), v.end(), odd, 0);

    sort(v.begin(), v.end(), cmp);

    for_each(v.begin(), v.end(), dump);
    
    system("PAUSE");
    return 0;
}

 

 

4、其它STL组件：函数对象、函数适配器、STL allocator；

 

 

 

 

 

 

////////////////////////////////////////////////////////////////////////////////
//C++学习笔记
////////////////////////////////////////////////////////////////////////////////