C++学习笔记3--一些应用

【模板】
函数模板定义的一般形式：
template <类型形式参数表>

返回类型 函数名(形式参数表)
{
    ...     //函数体
}

范例：
定义一个求和的函数模板

template <class type>
type Sum(type xvar, type yvar) {
    return xvar + yvar;
}

在定义完函数模板后，需要在程序中调用函数模板。下面的代码演示了Sum函数模板的调用。
int iRet = Sum(10, 20);
int dRet = Sum(1.2, 3.45);
消除模板调用产生歧义的方法-->在调用函数模板时显示标识模板类型。如：
int iRet = Sum(10.5, 20);
double dret = Sum<double>(10, 20.5);
用函数模板生成实际可执行的函数又称为模板函数。
例：使用数组作为模板参数

#include <iostream>
using namespace std;
template <class type,int len>   //定义一个模板类型
type Max(type array[len]) {     //定义函数模板
    type ret = array[0];
    for(int i=1;i<len;i++) {
        ret = ret > array[i] ? ret : array[i];
    }
    return ret;
}
int main(int argc,char* argv[]) {
    int array[5] = {1,2,3,4,5}; //定义一个整型数组
    int iret = Max<int,5>(array);   //调用函数模板Max
    double dset[3] = {1.2, 3.45, 6.789}; //定义实数数组
    double dret = Max<double,3>(dset);  //调用函数模板Max
    cout << dret << endl;
    return 0;
}

重载函数模板举例：

#include <iostream>
#include <cstring>
using namespace std;
template<class type>
type Min(type a, type b) { //定义函数模板
    return a < b ? a : b;
}
char* Min(char* a, char* b) { //重载函数模板
    if(strcmp(a, b) < 0) return a;
    return b;
}
int main(int argc, char* argv[]) {
    cout << Min(10, 3) << endl;
    cout << Min('a','b') << endl;
    cout << Min("lasolmi","hello world") << endl;
    return 0;
}

类模板的定义形式:
template<类型形式参数表>
class 类模板名
{
    ... //类模板体
};
类模板成员函数的定义形式:
template<类型形式参数表>
返回类型 类模板名 <类型名表>::成员函数名(形式参数列表)
{
    ... //函数体
}
生成类的形式如下：
类模板名<类型实在参数表>
用新生成的类定义对象的形式如下:
类模板名<类型实在参数表> 对象名
在类模板定义中，类型形式参数表中的参数也可以是其他类模板。例如:

template<template<class A> class B>
class CBase {
private:
    B<int> m_n;
};

类模板也可以进行继承。例如：
t

emplate<class T>
class CDerived : public T
{
public:
    CDrived();
};
template<class T>
CDerived<T>::CDerived(): T() {
    cout << :: <<endl;
}
int main(int argc,char* argv[]) {
    CDerived<CBase1> D1;
    return 0;
}

例：简单类模板

#include <iostream>
using namespace std;
template<class T1, class T2>
class MyTemplate {
    T1 t1;
    T2 t2;
public:
    MyTemplate(T1 tt1, T2 tt2) {t1 = tt1; t2 = tt2;}
    void display() {cout << t1 << " " << t2 <<endl;}
};
int main(int argc, char* argv[]) {
    int a = 123;
    double b = 3.14159;
    MyTemplate<int,double> mt(a, b);
    mt.display();
    return 0;
}

默认模板参数,例：
template<class T1, class T2=int>
为具体了女性的参数提供默认值，例：
template<class T1, class T2, int num=10>
有界数组模板：

#icnlude <cassert>
template<class T, int b>
class Array {
    T& operator[] (int sub) {
        return sub >=0 && sub < b;
    }
};

模板的定制：定义完模板后如果想扩展模板新类的功能，需要对类模板进行覆盖，是模板类能


够完成功能。覆盖操作可以针对整个类模板、部分类模板以及类模板的成员函数。这种覆盖操


作成为定制。
对于同一类型的模板实例，其静态数据成员是共享的。
【STL标准模板库】
序列容器：
 向量类模板
 双端队列类模板
 链表类模板
结合容器
  set类模板
  multiset类模板
  map类模板
  multimap类模板
算法
  非修正序列算法
  修正序列算法
  排序算法
  数值算法
迭代器
  输出迭代器
  输入迭代器
  前向迭代器
  双向迭代器
  随机访问迭代器
【RTTI与异常处理】
运行是类型识别(Run-time Type Identification, RTTI)是在只有一个指向基类的指针或引用


时确定的一个对象的类型。
范例：CBint类和CBString类都继承与CBase类，这3个类存在一个公共方法GetName(),而CBint


类有自己的特有方法GetInt()，CBString类有自己的特有方法GetString()。如果想通过CBase


类的指针调用CBint类或CSString类的特有方法时就必须确定指针的具体类。字啊面的代码完成


了这样的功能。

#include <cstdio>
class CBase {   //基类
public:
    virtual char * GetName() = 0;   //虚方法
};
class CBint : public CBase {
public:
    char * GetName() {return "CBint";}
    int GetInt() {return 1;}
};
class CBString : public CBase {
public:
    char * GetName() {return "CBString";}
    char * GetString() {return "Hello";}
};
int main(int argc, char* argv[]) {
    CBase* B1 = (CBase*)new CBint();
    printf(B1->GetName());
    CBint* B2 = static_cast<CBint*>(B1);    //静态替换
    if(B2) printf("%d" , B2->GetInt());
    CBase* C1 = (CBase*)new CBString();
    printf(C1->GetName());
    CBString* C2 = static_cast<CBString*>(C1);
    if(C2) printf(C2->GetString());
    return 0;
}

从上面代码可以看出基类CBase的指针B1和C1分别指向了CBint类与CBString类的对象，并且在


程序运行时基类通过static_cast进行了转换，这样就形成了一个运行时类型是别的过程。
RTTI与引用
 #include <typeinfo>
 typeid(p); //p是某类型指针
 typeid()获取的指针是基类类型，而不是子类类型或派生类类型，typeid()获取的引用是子类


类型。
【RTTI映射语法】
dynamic_cast：用于安全类型的向下映射。
例如，通过dynamic_cast实现基类指针的向下转型。
const_cast：用于映射常量和变量。
例如，在常方法中修改成员变量和常量的值。
static_cast：为了行为良好和行为较好使用的映射，如向上转型和类型自动转换。
例如，通过static_cast将子类指针向上转成基类指针。
reinterpret_cast：将某一类型映射回原有类型时使用。
例如，将整型转成字符型，再由reinterpret_cast转换回原类型。
【异常处理】
抛出异常：
例：将错误ID和错误信息以类对象的形式进行异常抛出。

#include <iostream>
#include <cstring>
using namespace std;
class CCustomError {
private:
    int m_ErrorID;
    char m_Error[255];
public:
    CCustomError(int ErrorID, char* Error) {
        m_ErrorID = ErrorID;
        strcpy(m_Error, Error);
    }
    int GetErrorID() {return m_ErrorID;}
    char* GetError() {return m_Error;}
};
int main(int argc, char* argv[]) {
    try {
        throw (new CCustomError(1,"出现异常!"));
    } catch(CCustomError* error) {
        //输出异常信息
        cout << "异常ID:" << error->GetErrorID() <<endl;
        cout << "异常信息:" << error->GetError() << endl;
    }
    return 0;
}

异常捕获：
异常抛出信号发出后，一旦被异常处理器接收到就被销毁。异常处理器应具备接受任何异常的


能力。异常处理器紧随try块之后，处理的方法由关键字catch引导。
有时并不一定在列出的异常处理中包含所有可能发生的异常类型，所以C++提供了可以处理任何


类型异常的方法，就是在catch后面的括号内添加“...”代码如下：

int main(int argc, char* argv[]) {
    try {
        throw "字符串异常";
    } catch (CCustomError* error) {
        //输出异常信息
        cout << "异常ID:" << error->GetErrorID() <<endl;
        cout << "异常信息:" << error->GetError() << endl;
    } catch (char* error) {
        cout << "异常信息:" << error << endl;
    } catch (...) {
        cout << "未知异常信息" << endl;
    }
    return 0;
}

异常匹配：
能匹配到基类，而不能匹配到其派生类。
为了正确的进入指定的异常处理器，在对异常处理器进行排列时应将派生类排在前面，而将基


类排在后面。
标准异常：
下面给出了C++提供的一些标准异常：

namespace std
{
    //exception 派生
    class logic_error;
    //logic_error 派生
    class domain_error;
    class invalid_argument;
    class length_error;
    class out_of_range;
    class bad_cast;
    class bad_typeid;
    //exception 派生
    class runtime_error;
    //runtime_errot 派生
    class range_error;
    class overflow_error;
    class bad_alloc;
}

【程序调试】
程序错误常见的4种类型：语法错误、连接错误、运行时错误 和 逻辑错误。