NDK2 C++基础，模板编程、类型转换、异常

模板编程(java中的泛型)

template关键字
T，不确定类型；
class，类泛型
using namespace std; 使用匿名空间 下面的string就不需要写成 std::string了
栈中实例化的对象可以 . 在堆中实例化的对象用 ->

//使用匿名空间	下面的string就不需要写成 std::string了
using namespace std;

// TODO 普通的模板
template <class T>
T getMax(T num,T num2){
    return num > num2 ? num : num2;
}
// TODO 类模板，这里我们定义了三个类泛型
template <class CLASS1,class CLASS2,class CLASS3>
class TestClass{
public:	//记得公开
    CLASS1 getType(CLASS1 c){
        return c;
    }
    CLASS2 getType(CLASS2 c){
        return c;
    }
    CLASS3 getType(CLASS3 c){
        return c;
    }
};

int main(){
    // TODO java的泛型 == C++的模板编程
    // 使用普通的模板
    getMax(9,8);
    getMax(999.22,811.22);
    getMax(999.22,811);
     //使用类模板 确定对应的类型
    TestClass<int,string,double> testClass; //栈中实例化对象 可以用 .
    testClass.getType(100);
    testClass.getType("KAIZI");
    testClass.getType(111.2);
    //堆中实例化对象    用->
    TestClass<int,string,double> *t = new TestClass<int,string,double>;
    t->getType(100);
}

类型转换

普通类型转换

const 等于是常量级别的；
括号里面 const_cast<需要转换后的类型>；

int main(){
	// 普通类型的转换
    //const 等于是常量级别的
    const char * c1 = "#x121314121";
    //将上面的const char *  转换成 普通的 char * 类型
    //括号里面   const_cast<需要转换后的类型>
    char * c2 = const_cast<char *>(c1);
    char * c3 = "#x124443322";
    //将上面的char *  转换成 普通的 const char * 类型
    //括号里面   const_cast<需要转换后的类型>
    const char * c4 = const_cast<const char * >(c3);
}

静态类型转换

静态类型的转换(涉及的是指针类型相关的转换操作)；
括号里面 static_cast<需要转换后的类型>；
记得释放 回收的规则,一定是谁 new了 , 就需要回收释放谁；

class FuClass{
public:
    void show(){
        LOGD("FuClass=====show");
    }
};

class ZiClass : public FuClass{
public:
    void show(){
        LOGD("ZiClass=====show");
    }
};

int main(){
    // 静态类型的转换(涉及的是指针类型相关的转换操作)
    FuClass *fuClass = new FuClass;
    //将上面FuClass * 类型转换成 ZiClass * 类型
    //括号里面   static_cast<需要转换后的类型>
    ZiClass *ziClass = static_cast<ZiClass *>(fuClass);
    //虽然show方法不是虚函数,但是FuClass被转换成ZiClass * 类型了,所以这类的show方法调用的是子类的
    //父类show是个虚函数，就会调用到父类的show方法
    ziClass->show();
    //记得释放  回收的规则,一定是谁 new了 , 就需要回收释放谁
    delete fuClass;
}

动态类型转换

动态类型的转换—运行时期

动态多态 一定是在运行的时候，确定父类函数中是否有虚函数；注意这里有一个virtual 关键字

class FuClass{
public:
    virtual void show(){
        LOGD("FuClass=====show");
    }
};

class ZiClass : public FuClass{
public:
    void show(){
        LOGD("ZiClass=====show");
    }
};

转换失败

静态 和 动态多态的区别
静态多态 编译时期，只看左边是谁，就调用谁的方法；
动态多态 一定是在运行的时候，确定父类函数中是否有虚函数；
动态类型转换的时候，在运行时期 fuClass 是父类new出来的，就会转换失败，就不能转子类；

 	    //静态 和  动态多态的区别
    //静态多态  编译时期，只看左边是谁，就调用谁的方法
    //动态多态  一定是在运行的时候，确定父类函数中是否有虚函数
    //动态类型的转换---运行时期
    //动态类型转换的时候，在运行时期 fuClass 是父类new出来的，就会转换失败，就不能转子类
    FuClass *fuClass = new FuClass;
    ZiClass *ziClass = dynamic_cast<ZiClass *>(fuClass);
    //在运行的时候,使用多态关键字转换操作后,会返回一个值,这个值就是转换后的值
    if(ziClass){    //不为空的情况下 转换成功
        LOGD("ziClass 转换成功");
        ziClass->show();
    }else{  //为空的情况下 转换失败  上面这样转换的情况下，一定是转换失败
        LOGD("ziClass 转换失败");
    }

转换成功

静态 和 动态多态的区别
静态多态 编译时期，只看左边是谁，就调用谁的方法；
动态多态 一定是在运行的时候，确定父类函数中是否有虚函数；
转换成功的原因：因为new出来的是子类，所以在动态转换的时候能转换成功；
show方法调用的是子类的show方法，因为有虚函数；

     //静态 和  动态多态的区别
    //静态多态  编译时期，只看左边是谁，就调用谁的方法
    //动态多态  一定是在运行的时候，确定父类函数中是否有虚函数
    //动态类型的转换---运行时期
    //因为new出来的是子类，所以在动态转换的时候能转换成功
    FuClass *fuClass = new ZiClass;
    ZiClass *ziClass = dynamic_cast<ZiClass *>(fuClass);
    //在运行的时候,使用多态关键字转换操作后,会返回一个值,这个值就是转换后的值
    if(ziClass){    //不为空的情况下 转换成功
        LOGD("ziClass 转换成功");
        ziClass->show();	//调用的是子类的show方法，因为有虚函数
    }else{  //为空的情况下 转换失败
        LOGD("ziClass 转换失败");
    }

异常

“出现异常了…” == const char * (内部会自动转换成这个类型)；
c语言中字符串都是用 char * 来接收的；
如果抛出异常，不捕获，在运行的时候，会发生崩溃
VS CLion 和 AS兼容上有点问题，编译上AS很多通不过
AS里面可以用throw logic_error(“出现异常了”);

void exceptMethod(){
    //"出现异常了..."    ==   const char *  (内部会自动转换成这个类型)
    // c语言中 "xxxxxx" 默认用 const char *
    // c语言中字符串都是用  char * 来接收的
    char * s = "啊啊啊啊啊";
    throw "出现异常了...";
}

void exceptMethod2(){
    //在 VS CLion上可以这样写
//    throw exception("出现异常了");
//    throw logic_error("出现异常了");	//AS里面可以用这个logic_error

    //在AS上，传出异常信息尝试无效  编译不通过
    throw exception();
}

//下面这种自定义exception   在VS CLion上可以这样写，在AS上面 编译不通过
//自定定义一个exception异常，继承exception==========start===========
//class CustomException : exception{
//public:
//    //重写what方法，注意是   返回值都得一样
//    const char * what() const {
//        return "自定义的CustomException异常";
//    }
//};
//void exceptMethod3(){
//    CustomException c;
//    throw c;
//}
//自定定义一个exception异常，继承exception==========end===========

int main(){
    //TODO 异常
    //如果抛出异常，不捕获，在运行的时候，会发生崩溃
    try {
        exceptMethod();
    }catch (const char * excmsg){
        LOGD("捕获到异常：%s",excmsg);
    }

    try {
        exceptMethod2();
    }catch (exception &e){
        //e.what()  也是 const char *   类型
        e.what();
        LOGD("捕获到异常2：%s",e.what());
    }
//    try {
//        exceptMethod3();
//    }catch (exception &e){
//        //e.what()  也是 const char *   类型
//        e.what();
//        LOGD("捕获到异常2：%s",e.what());
//    }
}

辛苦各位童鞋观看到最后，如果博客中有不对的地方望指出，大神勿喷，谢谢~~