0704第五讲异常处理

0704第五讲异常处理
1、异常：处理错误
好处：把错误代码和逻辑代码分开，便于管理
使用异常关键字：try、throw、catch
1）throw：抛出异常
2）try：检查异常
3）catch：捕获处理异常
4）…：默认（可以处理任何类型异常，不能判处出来异常的类型）一定放到所有catch最后
throw expo（字符串，基本数据类型，Object）;
try｛
FUNC();//有可能发生错误的函数
exp2；//有可能发生错误的代码
｝
catch（参数（不同类型的数据，仅有一个参数））{
//参数：处理错误类型
//catch一定在try后面
}
eg:

#include <iostream>
using namespace std;
void func(int a,int b,int &c){
    if(b == 0){
        throw "Divided by zero”;//后面的代码不被执行
        //exp2；//有可能发生错误的代码
    }
    else c = a/b;
}
int main(int argc, const char * argv[]) {
    int a = 0,b = 0,c = 0;
    cout<<"please input a and b:"<<endl;
    cin>>a>>b;
    try {
        func(a,b,c);//有可能发生错误的函数
    }  catch (const char* error) {//参数（不同类型的数据，仅有一个参数）//参数：处理错误类型//catch一定在try后面
        cout<<"处理抛出字符串类型的错误"<<endl;//处理抛出字符串类型的错误
        cout<<error<<endl;
    }catch(int error){
        cout<<"处理抛出整数类型的错误"<<endl;/处理抛出整数类型的错误
        cout<<error<<endl;/
    }
    cout<<"c = "<<c<<endl;
    return 0;
}catch(...){//…   default默认，好处是能匹配任何类型错误，弊端是不能判断出错误的类型
        cout<<"发生错误。。。"<<endl;
    }

增加程序可读性，限定函数抛出异常的类型
void func() throw(int ,float)//该程序只会抛出int或float类型的异常
void func1()//可以抛出任何类型的异常
void func2() throw(…)//可以抛出任何类型的异常
void func3() throw()//不抛出任何异常

函数模版：函数参数不同，函数是想过程相似，通用函数被称为函数模版
模版关键字：template
eg:
(1)//函数： 参数类型确定，值不确定
//函数模版： 参数类型不确定，值也不确定

template<class T>//未被实例化的模型
void func(T* array,int size)
{
    for(int i = 0;i < size; ++i){
        cout<<array[i];
    }
    cout<<endl;
}
int main(int argc, const char * argv[]) {
    int array1[] = {1,2,3,4,5};
    float array2[] = {1.1f,2.2f,3.3f,4.4f,5.5f};
    double array3[] = {1.111111,2.222222,3.333333,4.444444,5.555555};
    //调用函数，根据参数类型来市里话T类型
    func(array1, 5);
    func(array2, 5);
    func(array3, 5);
    return 0;
}

(2)可以实例化返回值

template <class T>
T func(T x,T y,T z){
    return x>y?(x>z?x:z):(y>z?y:z);
}
int main(int argc, const char * argv[]) {
    int x1 = 3,y1 = 2, z1 = 1;
    float x2 = 1.1,y2 = 2.2, z2 = 3.3;
    double x3 = 1.111111,y3 = 3.333333, z3 = 2.222222;
    char x4 = 'a',y4 = 'b',z4 = 'c';
    cout<<func(x1,y1,z1)<<endl;
    cout<<func(x2,y2,z2)<<endl;
    cout<<func(x3,y3,z3)<<endl;
    cout<<func(x4,y4,z4)<<endl;
    return 0;
}

(3)可以有多个未实例化类型

template <class I>//一个template 只能绑定一个函数
I funcI(I x,I y,I z){
    return    x>y?(x>z?x:z):(y>z?y:z);
}
template <class I,class F,class D>
void func(I x,F y,D z){
    cout<<x<<endl;
    cout<<y<<endl;
    cout<<z<<endl;
}
int main(int argc, const char * argv[]) {
    int x1 = 1;
    float x2 = 1.1;
    double x3 = 1.111111;
    func(x1,x2,x3);
    return 0;
}

类模版：成员变量类型不确定，成员函数对成员变量的操作相似。
1、成员函数：在类模版中，所有的成员函数都是一个函数模版，所有在实现成员函数时加template
2、格式：类名::函数名
3、编写注意：声明实现放在一个文件中
(1)

class Test {
    T a;//使用模版参数T 声明成员变量
public:
    void print();
    Test(T _a = 20){
        a = _a;
    }
};
template <class T>
void Test<T>::print() {
    cout<<"a = "<<a<<endl;
}
int main(int argc, const char * argv[]) {
    //类模版必须在声明该模版对象（实例化类对象）时，明确的对模版参数实例化
    Test<int> t1(10);//实例化T为int类型
    t1.print();

    Test<char*> t2((char*)"abc");
    t2.print();

    Test<double> t3(1.23456);
    t3.print();

    Test<> t4;//未填写类型，T将使用默认类型int
    t4.print();
    return 0;
}

(2)

template <class T>
class Stack {
    int size;
    int top;
    T *stackPtr;
public:
    Stack(int s = 10);
    ~Stack();
    int push(const T&);
    int pop(T&);
    int isEmpty();
    int isFull();
    void printOn(ostream& out);
};
template <class T>
void Stack<T>::printOn(ostream& out){
    out<<"Stack( ";
    for (int i = 0; i <=top; ++i) {
        out<<stackPtr[i]<<",";
    }
    out<<")\n";
}
template <class T>
Stack<T>:: Stack(int s):top(-1){
    size = s;
    stackPtr = new T[size];
}
template <class T>
Stack<T>:: ~Stack() {
    if (stackPtr != NULL) {
        delete [] stackPtr;
        stackPtr = NULL;
    }
}
template <class T>
int Stack<T>::push(const T & item){
    if (!isFull()) {
        stackPtr[++top] = item;
        return 1;
    }
    return 0;
}
template<class T>
int Stack<T>::pop(T& item){
    if (!isEmpty()) {
        item = stackPtr[top--];
        return 1;
    }
    return 0;
}
template<class T>
int Stack<T>::isEmpty(){
    return top == -1;
}
template <class T>
int Stack<T>:: isFull() {
    return top == size-1;
}
int main(int argc, const char * argv[]) {
    Stack<int> s1;
    for (int i = 0; i<5; ++i) {
        s1.push(i);
    }
    s1.push(5);
    s1.printOn(cout);
    int num = 0;
    s1.pop(num);
    cout<<num<<endl;
    s1.printOn(cout);
    return 0;
}

作业：
Set:T* element;
构造函数、析构函数、add函数、remove最后元素函数、nextElement函数

#include <iostream>
using namespace std;
template <class T>
class elementSet{
    template <class U >
    friend ostream& operator<<(ostream& out,const elementSet<U> & e);
private:
    int size;
    int capacity;
    int index;
    T **element;
public:
    elementSet(int initial = 4);
    ~elementSet();
    void addElement(T&);
    T& removeElement();
    T& nextElement();
//    T& getElement();
};
//T& getElement();
template <class U >
 ostream& operator<<(ostream& out,const elementSet<U> & e){
    for(int i = 0; i < e.size; i++)
    {
        out<<*(e.element[i]);
    }
    return out;
}
template <class T >
elementSet<T>::elementSet (int initial):size(0),capacity(initial),index(0){
    element = new T*[capacity];
}
template <class T>
elementSet<T>::~elementSet() {
    if (element != NULL) {
        delete [] element;
        element = NULL;
    }
}
template<class T>
void elementSet<T>::addElement(T& item){
    if (size == capacity) {
        T** temp = element;
        element = new T*[capacity*=2];
        for (int i = 0; i < size; ++i) {
            element[i] = temp[i];
        }
        delete []temp;
    }
    element[size++] =&item;
}
template <class T>
T& elementSet<T>::removeElement() {
    size--;
    T *p=element[size];
    if (size == capacity/2) {
        T **temp = element;
        element = new T*[capacity/=2];
        for (int i = 0; i < size; ++i) {
            element[i] = temp[i];
        }
        delete []temp;
    }
    return *p;
}
template <class T>
T& elementSet<T>::nextElement() {

    if (index == size) {
        index = 0;
    }
    return *element[index++];
}

int main(int argc, const char * argv[]) {
    elementSet<char*> e1;
    elementSet<int> e2;
    char* str1 =(char*)"1";
    char* str2 =(char*)"2";
    char* str3 =(char*)"3";
    char* str4 =(char*)"4";
    int i1 = 5,i2 = 6;
    e1.addElement(str1);
    e1.addElement(str2);
    e1.addElement(str3);
    e1.addElement(str4);
    e2.addElement(i1);
    e2.addElement(i2);
    cout<<e1<<endl;
    return 0;
}