（十一）异常处理，函数模板，类模板

（十一）异常处理，函数模板，类模板
2016.7.4

1.异常处理

#include <iostream>

using namespace std;
int func1(int n1,int n2){
    if(n2==0)
    {   throw "f";}
    else

        return n1/n2;

}
void func2(int n1,int n2){//函数调用函数异常依然可以抛出。
    func1(n1,n2);}
void  func3() throw(int ,float){//抛出异常类型为int，float.
}
void func4(){//可抛出任何异常。
}
void func5() throw(...){//可抛出任何异常。
}
void func6() throw (){//不抛出任何异常。
}
int main(int argc, const char * argv[]) {
    int num1=200;
    int num2=0;
    try{
        //存放有可能发生错误的代码。
        //func1(num1,num2);
        func2(num1,num2);
    }//try与catch之间不能有其他代码。
    catch(const char *error){//catch只能有一个参数。
        cout<<"出现异常"<<endl;
        cout<<error<<endl;
    }
    catch(int error){
        cout<<"出现整型异常"<<endl;
        cout<<error<<endl;
    }
    catch(...){//default      要写时，要把它放最后。放最前报错。
        //...的好处：能匹配任何类错误。
        //...的弊端:不能判断出错误的类型。
        cout<<"发生错误"<<endl;
    }

        return 0;
}

2.函数模板

#include <iostream>
using namespace std;
/*
 函数模板：函数参数不同，函数实现相似，通用函数被称为函数模板
 模板关键字：templaate
 */

//第一层封装
void func1(int *array,int size){
    cout<<""<<endl;
    for(int i=0;i<size;i++)
    {
        cout<<array[i];
    }
}
//函数：参数类型确定，值不确定。
//函数模板；参数类型不确定，值也不确定。
template <class T>
void func4(T *array ,int size){
    for(int i=0;i<size;i++)
        cout<<array[i];
    cout<<endl;
}

template <class M,class N,class K>//一个模板只能绑定一个函数。
//函数模板可以有多个未实例化参数。
void func5(M n1,N n2,K n3){

    if(n1>n2)
        cout<<(n3>n1?n3:n1)<<endl;
    else
        cout<<(n3>n2?n3:n2)<<endl;


}
/*
 类模板
 */
template <class P>
class point {
private:
    P a;
public:
    point(P _a){
        a=_a;
    }
    void print();
};
template <class P>      //在类模板中每一个成员函数都是函数模板。
void point<P>::print()  //请注意成员函数的书写格式。
{
    cout <<a<<endl;
}

int main(int argc, const char * argv[]) {

    const int max=5;
    int array1[max]={6,7,8,9,0};
    char array2[max]={'a','s','d','f','g'};
    float array3[max]={1.2f,1.3f,1.4f,1.5f,1.6f};

    func4(array1, 5);//函数模板。
    func4(array2, 5);
    func4(array3, 5);

    int n1=1;
    int n2=3;
    int n3=3;

    float f1=1.1f;
    float f2=1.2f;
    float f3=1.3f;

    char c1='a';
    char c2='r';
    char c3='k';

    func5(n1,n2,n3);//求最大值。
    func5(f1, f2, f3);//只有一种类型的参数。
    func5(c1,c2,c3);
    func5(n1,f1,c1);//多种类型的参数。

    point<int> p(3);//类模板构造对象，用int来实例化P。
    p.print();

    return 0;
}

3.类模板

#include <iostream>
using namespace std;
template <class T>
class Stack {
private:
    int size;
    int top;
    T * stackPtr;
public:
    Stack(int s=10);
    ~ Stack();
    int push(const T&);
    int pop( T&);
    int isEmpty()const;
    int isFull()const;
    void printOn(ostream& output);
};
template <class T>
Stack<T>::~Stack(){
    delete [] stackPtr;
}
template <class T>
 Stack<T>::Stack(int s){
    size=s;
    top=-1;
    stackPtr=new T[size];
}
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()const
{
    return top==-1;
}
template <class T>
int Stack<T>::isFull()const
{
    return size==-1;
}
template<class T>
void Stack<T>::printOn(ostream & output)
{
    output<<"Stack(";
    for(int i=0;i<=top;i++)
       output<<stackPtr[i]<<",";
    output<<")\n";
}
int main(int argc, const char * argv[]) {

    Stack<int> stack;
    for(int i=0;i<5;i++){
        stack.push(i*10);
    }
    stack.printOn(cout);
    std::cout << "Hello, World!\n";
    return 0;
}