1.命名空间2.字符串3.容器（STL）4.迭代器

**1.命名空间2.字符串3.容器（STL）4.迭代器5
2016.7.5**
复习：
异常：throw（抛出异常）抛出异常后后面不会继续执行
try（捕获异常）有可能发生错误的代码放到try Block中
catch（处理异常）跟在try后边，带有一参数，可以有多个catch
…：默认（可以处理任何类型异常，不能判断出异常的 类型），一定放在catch最后
逻辑代码和判断区分
void func() throw(int , class){}
void func(){}
void func()throw(…){}
void func()throw(){}

函数模板：函数参数类型不同，实现过程相似，函数模板
template
void func(T n){}
调用函数T根据参数类型来确定自己的类型

函数和函数模板：函数（类型确定，值不确定），函数模板（类型不确定，值不确定）

类模板：类的成员变量类型不确定，每个成员函数都是函数模板。所以每个成员函数是现实需要template
注意：类名::print(){}
创建对象时未确定未实例化：

**1.namespace:命名空间，解决相同作用域同名函数或变量问题
要求：使用时必须 ’名字空间：：成员名称‘**

#include <iostream>using namespace std;namespace yong {    int count=100;    int size=200;    namespace in{//命名空间可嵌套        int a=10;        int size=20;//两个size不会冲突    }    void print(){        cout<<count<<endl;    }}int main(int argc, const char * argv[]) {    cout<<yong::count<<endl;    cout<<yong::size<<endl;    cout<<yong::in::a<<endl;    cout<<yong::in::size<<endl;    yong::print();    std::cout << "Hello, World!\n";    return 0;}

2.运行时类型识别：
类型转换：强制类型转换（向下转型）
a.动态类型转换：dynamic_cast，把父类指针转换成子类指针（如果转型成功，返回子类，如果失败返回NULL，向下转型安全）
使用格式: dynamic_cast<>(),用来检测父类指针是否可以转换成子 类指针。如果转型成功 ，返回子类，如果失败返回NULL

b.静态类型转换：static——cast和强制类型转换效果相同
动态类型转换：必须有virtual函数（多态）。

class Bace{public:    virtual void print(){        cout<<"virtual Bace.."<<endl;    }    void outB() const{        cout<<"Bace..."<<endl;    }};class D1:public Bace{public:    void print() const{        cout<<"virtual D1..."<<endl;    }    void outD1() const{        cout<<"D1.."<<endl;    }};class D2:public Bace{public:    void print()const {        cout<<"virtual D2..."<<endl;    }    void outD2()const{        cout<<"D2.."<<endl;    }};int main(){    D1 b1;    D2 b2;    const D1*p1=NULL;    const D2*p2=NULL;    Bace* p[2]={&b1,&b2};    for(int i=0;i<2;i++)    {        if((p1=dynamic_cast<D1*>(p[i])))        {            cout<<"a"<<endl;            p1->print();            p1->outD1();        }        else if((p2=dynamic_cast<D2*>(p[i])))        {            cout<<"b"<<endl;            p2->print();            p2->outD2();        }    }}

3.字符串
a.使用字符串初始化字符串对象
string str1(“holle~”);
cout<

#include <iostream>using namespace std;class Person{private:    string name;    int age;public:    Person(string _name,int _age){        name=_name;        age=_age;    }    void setName(string _name){        name=_name;    }    void print(){        cout<<"--------------"<<endl;        cout<<name<<endl;        cout<<age<<endl;    }};int main(){    //strin在类中的使用    Person p1("123",14);    Person p2("asd",16);    p1.print();    p2.print();    p1.setName("haha");    p1.print();    return 0；}

5.容器：存储同类型数据项的一个集合（相同数据类型的一个集合）
分类：1.顺序容器。2.关联容器。
a.顺序容器：
(1) 向量Vector: 随机访问任何一个元素,尾部增、删元素。 （系统做好了下标操作符重载；头部增、删元素消耗时间和容器中元素个数成正比；尾部增删元素消耗时间是一个const）
(2) 双端对列Deque: 随机访问,在头部和尾部增删元素。（系统做好了下标操作符重载；头部尾部增删元素时间都为const。）
(3) 链表List: 顺序访问,任意位置增删元素。

b.关联容器（key:value键值对形式）
(1)集合Set: 集合存储不能有重复元素。（key和value映射到一起，(key就是value,value就是key)）
(2)多集合MultiSet: 集合存储可以有重复元素。
(3)映射Map: 一对一的键值对(key,value),值可以通过指定的键检 索,其中键(key)不能重复
(4)多映射MultiMap: 一对多的键值对(key,value),其中键(key)可以重复

c.要使用容器类,包括下面的头文件(在命名空间中定义的) < deque >

#include <iostream>#include<vector>using namespace std;//容器：存储同类型数据项的一个集合（相同数据类型的一个集合）void func(){    vector<int> v;//向量    v.push_back(100);    v.push_back(200);    v.push_back(300);    v.push_back(400);    cout<<v[2]<<endl;//访问（不会给出越界提示）    cout<<v.at(2)<<endl;//访问（会给出越界提示）    v.insert(v.begin(), 500);//在某个位置插入元素    cout<<v[0]<<endl;    cout<< v.front()<<endl;//获取容器中第一个元素    cout<<v.back()<<endl;//获取容器中最后一个元素    cout<<v.max_size()<<endl;//容器的最大容量    cout<<v.capacity()<<endl;//容器当前大小    cout<<v.size()<<endl;//元素个数    v.clear();    cout<<v.size()<<endl;}int main(){    func();//容器功能的调用return 0;}//自定义类class Point{public:    Point(int _x,int _y){        x=_x;        y=_y;    }    void print(){        cout<<"x="<<x<<endl;        cout<<"y="<<y<<endl;    }private:    int x;    int y;};void func2(){    Point p1(10,20);    Point p2(30,40);    Point p3(50,60);    Point p4(70,80);    vector<Point> p;        //    p.push_back(p1);    p.push_back(p2);    p.push_back(p3);    p.push_back(p4);    cout<<p.size()<<endl;    p.at(0).print();    vector<Point*> v;       //    v.push_back(&p1);    v.push_back(&p2);    cout<<v.size()<<endl;    v.at(0)->print();       //}int main(){    func2();return 0;}

6.迭代器:用来遍历容器iterator
使用迭代器,对容器进行元素枚举,使用迭代器也定义在头文件< iterator >
一个迭代器被用来“指向”容器中的元素(虽然不是指针)。迭代器也可以解引用 (*)和进行算术运算。
迭代器可以声明如下格式:
(1)iterator:前向遍历,可读可写
(2)const_iterator:前向遍历,只读
(3)reverse_iterator:后向遍历,可读可写
(4)const_reverse_iterator:后向遍历,只读
迭代器函数:
(1)函数began()返回一个迭代器指向容器的第一个元素。
(2) 函数end()返回一个迭代器指向容量的最后一个元素的下一位置后。
(3)函数rbegin()返回一个迭代器指向容量的最后一个元素。
(4)函数rend()返回一个迭代器指向容量的第一个元素之前的位置。

#include <iostream>#include<vector>using namespace std;class Point{public:    Point(int _x,int _y){        x=_x;        y=_y;    }    void print(){        cout<<"============"<<endl;        cout<<"x="<<x<<endl;        cout<<"y="<<y<<endl;    }private:    int x;    int y;};void func3(){    Point p1(10,20);    Point p2(30,40);    Point p3(50,60);    Point p4(70,80);    vector<Point> po;    po.push_back(p1);    po.push_back(p2);    po.push_back(p3);    po.push_back(p4);   //创建一个迭代器，指向第一个元素    vector<Point>::iterator itor=po.begin();//迭代器：遍历    while(itor!=po.end())    {        (*itor).print();        itor++;    }}int main(){    func3();return 0;}

7.容器list的使用

#include <iostream>#include<list>using namespace std;typedef list<int> l;//重新定义类型名字int main(){    l lst;//list<int> lst    for(int i=0;i<5;i++)    {        lst.push_front(i);        lst.push_back(i);    }    l::iterator itor=lst.begin();    while(itor!=lst.end()){        cout<<*itor++<<endl;        //itor++;     }    cout<<endl;return 0;}

8.set

int main(){//set容器    set<int> s;    s.insert(100);    s.insert(200);    s.insert(300);    s.insert(100);//已经输入一个相同元素，再次输入时，自动忽略。    cout<<s.size()<<endl;    set<int>::iterator itor=s.begin();    while(itor!=s.end()){        cout<<*itor++<<endl;    }    cout<<endl;    multiset<int> ss;    ss.insert(100);    ss.insert(200);    ss.insert(300);    ss.insert(100);//已经输入一个相同元素，再次输入时依然可以存入。    cout<<ss.size()<<endl;    multiset<int>::iterator itor2=ss.begin();    while(itor2!=ss.end()){        cout<<*itor2++<<endl;    }    cout<<endl;return 0;}

9.map

#include <iostream>#include<map>using namespace std;int main(){    //map容器    map<string,char> m;    //调用value_type构造函数创建对象后直接插入容器中    m.insert(map<string,char>::value_type("key1",'a'));    m["key5"]='c';//插入数据到容器中（与上一行是等同的功能）    m.insert(map<string,char>::value_type("key1",'f'));//key与value一一映射，key1    m["key3"]='k';    map<string,char>::iterator itor=m.begin();    while(itor!=m.end()){        cout<<itor->first<<endl;        cout<<itor->second<<endl;        itor++;    }    cout<<endl;    cout<<m["key1"]<<endl;    return 0;}