第四章函数模板与异常处理

函数模板

using namespace std;
//模版就是实现代码重用机制的一种工具，它可以实现类型参数化，即把类型定义为参数，从而实现了真正的代码重用性。模版可以分为两类，一个是函数模版，另一个是类模板。
//假设想要编写一个求加法的函数，那么可能需要根据传入参数的数据类型的不同定义几个重要的函数，例如：
int add(int x,int y)
{
    return x + y;
}
double add(double x,double y)
{
    return x + y;
}
//他们拥有同一个函数名，相同的函数体，缺因为参数类型和返回值类型不一样，所以是2个不同的函数。即使它们是二元加法的重载函数，但是不得不为每一个函数编写一组函数体完全相同的代码。如果能有一个通用的方法就可以节省很多代码。  那么使用函数模版就可以解决这个问题。
//函数模版的写法如下：
//template是一个声明模板的关键字，类型参数一般用一个虚拟的标识符来表示这里用的是 “T” ，在使用时，会将参数类型自动转换为具体的参数类型。
//typename关键字，在早期的C++中是使用class，但是后来为了不与类混淆，添加了typename关键字。其作用是用来表示它们之后的参数是一个类型参数。
template <typename  T>
T add(T x, T y)
{
    return x + y;
}
int main(int argc, const char * argv[])
{
    int i = 10,y = 10;
    cout<<"i + y = "<<add(i, y)<<endl;
                                                                                                                                                                
    return 0;
}

代码下载地址：  http://pan.baidu.com/share/link?shareid=1239986509&uk=3189484501

函数模板重载

using namespace std;
//这里例子的意义在于说函数模板可以重载。
class myClass
{
public:
                                                                                                                               
    void code()
    {
        cout<<"调用code()方法"<<endl;
                                                                                                                                 
    }
    template <typename T>
    void code(T value)
    {
        cout<<"调用int code(T value) = "<<value<<endl;
                                                                                                                                    
    }
};
int main(int argc, const char * argv[])
{
    myClass c1;
    //因参数不同，因而调用不同的方法，实现了函数重载
    c1.code();
    c1.code(10);
    return 0;
}

代码下载： http://pan.baidu.com/share/link?shareid=1244974959&uk=3189484501

类模板

//这个例子是为了给大家说明什么是类模板。
using namespace std;
template <typename T>
class myClass
{
                                                                                          
public:
    void show(T temp)
    {
        cout<<"在类模板内实现show（）方法 temp = "<<temp<<endl;
    }
    void display(T temp);
};
//在类模板外实现函数的格式如下：
//template <typename T> 的意思：进行模板声明，
template <typename T>
//且在成员函数名之前加上“类名”<类型参数>::
void myClass<T>::display(T temp)
{
    cout<<"这个是在类模板外实现的函数 temp = "<<temp<<endl;
}
int main(int argc, const char * argv[])
{
    myClass<int> op;
    op.show(10);
    op.display(20);
    return 0;
}

代码例子：  http://pan.baidu.com/share/link?shareid=1403098135&uk=3189484501

异常捕获

using namespace std;
//这个例子用来说明异常处理
//如果在try语句块中发生了异常，则用throw抛出，用catch捕获
int main(int argc, const char * argv[])
{
    int b = 0;
                                                     
    try {
        if(b == 0)
            throw b;
       int i = 6 /b;
        cout<<i<<endl;
                                                       
    } catch (int n )
    {
        cout<<"异常b = "<<n<<endl;
    }
    return 0;
}

代码下载地址：  http://pan.baidu.com/share/link?shareid=1524475783&uk=3189484501

在构造函数中抛出异常

using namespace std;
//这个例子用来说明在构造函数中可以抛出异常
class MyClass
{
    int num;
public:
    MyClass(int _num)
    {
        num = _num;
        if (num == 0)
        {
            throw num;
        }
    }
};
int main(int argc, const char * argv[])
{
                
    try {
        MyClass mc(0);
    } catch (int num)
    {
        cout<<"捕获异常 num = "<<num<<endl;
    }
    //这是一个为说明在异常处理中调用析构函数的示例
    //构造函数可以抛出异常
    //C++标准指明析构函数不能、也不应该抛出异常。
    //(1)如果析构函数抛出异常，则异常点之后的程序不会执行，如果析构函数在异常点之后执行了某些必要的操作比如释放某些资源，则这些动作不会执行，会造成诸如资源泄露的问题。
    //(2)通常异常发生时，C++的机制会调用已经构造对象的析构函数来释放资源，此时若析构函数本身也抛出异常，则前一个异常尚未处理，又有新的异常，会造成程序崩溃的问题。
    return 0;
}

代码下载：   http://pan.baidu.com/share/link?shareid=1609785598&uk=3189484501

本文出自 “7087095” 博客，请务必保留此出处http://7097095.blog.51cto.com/7087095/1226293