c++类型转换

//
// Created by Dream on 2016/11/12.
//
#include <iostream>
#include <android/log.h>

#include "com_tz_ndk_cpp_NDKCpp.h"

using namespace std;


//1.C++语言：模版类中重载运算符
//#include "Company.cpp"
//#include "Student.hpp"
//#include "Test.cpp"
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppTempClassOverloadOp
        (JNIEnv *, jobject){
//    Company<int> company(100);
//    Company<int> company1(200);
//    Company<int> company2 = company - company1;
//    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",company2.t);


//    Student<int> company(100);
//    Student<int> company1(200);
//    Student<int> company2 = company - company1;
//    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",company2.t);


//    Test<int> company(100);
//    Test<int> company1(200);
//    Test<int> company2 = company - company1;
//    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",company2.t);
}



//2.C++语言：模版类中使用static修饰符
#include "Company.h"

//注意：初始化静态变量
//template <typename T>
//T Company<T>::t = NULL;

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppTempClassStatic
        (JNIEnv *, jobject){
    //相同类型
    //静态变量属于类(共享)
    //总结：相同类型模版类共用静态属性
//    Company<int> company1(100);
//    company1.t++;
//    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",company1.t);
//
//    Company<int> company2(200);
//    company2.t++;
//    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",company1.t);
//    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",company2.t);

    //不同类型
    //总结：不同类型模版类不共享静态属性
//    Company<int> company1(100);
//    company1.t++;
//    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",company1.t);
//
//    Company<char> company2('A');
//    company2.t++;
//    __android_log_print(ANDROID_LOG_INFO,"main","值：%d",company1.t);
//    __android_log_print(ANDROID_LOG_INFO,"main","值：%c",company2.t);
}


//3.C++语言：模版类模拟Java中的List<T>集合
#include "ArrayList.h"
#include "Company.h"
JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppTempClassList
        (JNIEnv *, jobject){
//    ArrayList<int>* arrayList = new ArrayList<int>(5);
//    arrayList->add(0,100);
//    arrayList->add(1,200);
//    arrayList->add(2,300);
//    arrayList->add(3,400);
//    arrayList->add(4,500);
//
//    for (int i = 0; i < arrayList->size(); ++i) {
//        int result = arrayList->get(i);
//        __android_log_print(ANDROID_LOG_INFO,"main","第%d值：%d",i,result);
//    }
//
//
//    int result = arrayList->remove(2);
//    __android_log_print(ANDROID_LOG_INFO,"main","当前删除的元素：%d",result);
//    __android_log_print(ANDROID_LOG_INFO,"main","当前数组的大小：%d",arrayList->size());


    //重载运算符'='
//    ArrayList<int> arrayList = ArrayList<int>(5);
//    arrayList.add(0,100);
//    arrayList.add(1,200);
//    arrayList.add(2,300);
//    arrayList.add(3,400);
//    arrayList.add(4,500);
//
//    //拷贝
    ArrayList<int> array1 = arrayList;
    for (int i = 0; i < array1.size(); ++i) {
        int result = array1.get(i);
        __android_log_print(ANDROID_LOG_INFO,"main","第%d值：%d",i,result);
    }
//
//    //对象存在
//    ArrayList<int> array1 = ArrayList<int>(1);
//    array1 = arrayList;
//    for (int i = 0; i < array1.size(); ++i) {
//        int result = array1.get(i);
//        __android_log_print(ANDROID_LOG_INFO,"main","第%d值：%d",i,result);
//    }

    //保存对象
//    ArrayList<Company> arrayList = ArrayList<Company>(3);
//    Company company1 = Company("潭州教育",10);
//    Company company2 = Company("阿里巴巴",17);
//    Company company3 = Company("腾讯",17);
//    arrayList.add(0,company1);
//    arrayList.add(1,company2);
//    arrayList.add(2,company3);
//    for (int i = 0; i < arrayList.size(); ++i) {
//        Company result = arrayList.get(i);
//        __android_log_print(ANDROID_LOG_INFO,"main","第%d名字：%s",i,result.name);
//    }
//
//
//    //深拷贝-对象
//    ArrayList<Company> array1 = ArrayList<Company>(1);
//    array1 = arrayList;
}



//4.C++语言：类型转换
//4.1 静态类型转换:static_cast
//使用场景:static_cast
//4.1.1 用于类层次结构（继承）,基类和子类之间指针和引用转换
//4.1.2 用于基本数据类型的转换(例如：int、double......)
//4.1.3 把void指针转成目标类型的指针(不安全)
//注意：大类型转小类型，数据会丢失

//4.2 常量类型转换:const_cast
//使用场景:主要用于常量指针转成非常量指针

//4.3 强制类型转换:reinterpret_cast
//使用场景：允许任何指针类型转为其他类型指针
//void funcCompany(Company* company){
//    TzCompany* tzCompany = reinterpret_cast<TzCompany*>(company);
//    __android_log_print(ANDROID_LOG_INFO,"main","名称：%s",tzCompany->name);
//}

//4.4 动态类型转换
//使用场景：主要用于类的继承体系中（类层次结构）,还可以用于类之间的交叉转换
//void func(TzCompany* tzCompany){
//    Company* company = dynamic_cast<Company*>(tzCompany);
//    if(company != NULL){
//        __android_log_print(ANDROID_LOG_INFO,"main","姓名：%s",company->name);
//    }
//}

//上一课写法
//void func1(Company* company){
//    TzCompany* tzCompany = dynamic_cast<TzCompany*>(company);
//    if(tzCompany != NULL){
//        __android_log_print(ANDROID_LOG_INFO,"main","姓名：%s",tzCompany->name);
//    }
//}

void func(const Company *company){
    //常量指针不能够修改值(只读)
//    company->name = "";
    //将常量指针转成非常量指针
    Company* company1 = const_cast<Company*>(company);
    company1->name = "阿里巴巴";
}

JNIEXPORT void JNICALL Java_com_tz_ndk_cpp_NDKCpp_callCppTypeConversion
        (JNIEnv *, jobject){
    //普通写法
//    int a = 100;
//    //自动转换(系统自动帮助转类型)
//    double b = a;
//    //强制类型转换
//    double d = (double)a;

    //采用C++中提供函数库
    //4.1 静态类型转换
//    int a = 100;
//    double b = 10.5;
//    b = static_cast<double>(a);

    //4.1.1 用于类层次结构（继承）,基类和子类之间指针和引用转换
//    Company company = TzCompany("潭州教育",9);
//    //TzCompany&:代表引用
//    TzCompany tzCompany = static_cast<TzCompany&>(company);
//    //报错
    tzCompany = company;
//    __android_log_print(ANDROID_LOG_INFO,"main","名称：%s",tzCompany.name);


    //4.2 常量类型转换
//    int a = 100;
//    int b = 1200;
//    //常量指针和指针常量
//    //常量指针：指针指向的地址对应的值不能够修改，但是指针指向的地址可以修改
//    //指针常量：
//    const Company *company = new Company("潭州",9);
//    //一下写法报错
    Company* company1 = company;
//    Company* company1 = const_cast<Company*>(company);

    //补充：
    const Company *company = new Company("潭州",9);
    func(company);
    __android_log_print(ANDROID_LOG_INFO,"main","公司名称：%s",company->name);


    //4.3 强制类型转换:reinterpret_cast
    //使用场景：允许任何指针类型转为其他类型指针
//    Company* company = new Company("潭州",9);
//    funcCompany(company);
//    //自己手动强制类型转换
//    student = (Student*)company;


    //4.4 动态类型转换
    //使用场景：主要用于类的继承体系中（类层次结构）,还可以用于类之间的交叉转换
    //语法需要注意
    //下一节课解决：童鞋们可以课后试一下
    //上一次课的写法
    //解决：方法的参数必须是多态类
//    TzCompany* company = new TzCompany("潭州",20);
//    func(company);

//    TzCompany* company = new TzCompany("潭州",20);
//    func(company);


}

整理自示例代码