（原）android的JNI中使用C++的类

android的JNI代码中可以调用C++的类，但是不能直接调用，要加上一个类似于接口的java类，这个类内部调用C++的类。实际上和接口类直接调用C++中的函数差不多，只是稍微复杂了一点。

1. 写一个简单的类（一直都是用VS自动生成的类，很少自己写一个类，因而此处也是用VS生成类，然后复制到Eclipse工程的jni目录下。）该类包含4个函数：

a带参数的构造函数，用于初始化类中的变量。

b析构函数，用于释放类中的指针（数组）

c求和函数calcSum

d求平均值函数calcMean

下面的代码是VS转到JNI后编译通过的代码（VS生成的可能需要稍微修改一点）

 // myMeanSum.h文件
 #pragma once

 #include <stdio.h>
 #include <stdlib.h>

 class myMeanSum
 {
 public:
     myMeanSum();
     ~myMeanSum();
     myMeanSum(int* data, int num);

     double calcMean();
     int calcSum();

 private:
     int m_number;
     int* databuf;
     double m_mean;
     int m_sum;
 };

 // myMeanSum.cpp文件

 #include "myMeanSum.h"

 myMeanSum::myMeanSum()
 : m_mean()
 , m_sum()
 , m_number()
 {
     databuf = new int[];
 }

 myMeanSum::myMeanSum(int* data, int num)
 : m_mean()
 , m_sum()
 , m_number()
 {
     m_number = num;
     databuf = new int[m_number];
     memcpy(databuf, data, sizeof(int)*m_number);
 }

 myMeanSum::~myMeanSum()
 {
     if (databuf!=NULL)
     {
         delete[] databuf;
         databuf = NULL;
     }
 }

 double myMeanSum::calcMean()
 {
     m_sum = calcSum();
     return m_sum / 1.0 / m_number;  // / 1.0用来保证int类型自动转换成double类型。
 }

 int myMeanSum::calcSum()
 {
     m_sum = ;
     for (int i = ; i < m_number; i++)
     {
         m_sum += databuf[i];
     }
     return m_sum;
 }

2. 在Eclipse中创建新的android工程testClass。

3. 添加JNI文件AndroidClass.cpp。

4. 添加接口文件AndroidClass.java。

5. 在AndroidClass.java中添加long类型的指针，用于存储类的地址private long ptr_;

6. 在AndroidClass.java添加AndroidClass的构造函数：

 public AndroidClass(int[] data, int num)
 {
     ptr_=AndroidClassGen(data, num);
 }

7. 在AndroidClass.java添加6中函数调用的函数接口：

private native long AndroidClassGen(int[] data, int num);

8. 在AndroidClass.cpp添加7中调用class的接口函数。

 JNIEXPORT jlong JNICALL Java_com_example_testclass_AndroidClass_AndroidClassGen
   (JNIEnv *env, jobject obj, jintArray data, jint num)
 {
     jint *iAdata = env->GetIntArrayElements(data, );

     jlong ptr= reinterpret_cast<jlong>(new myMeanSum(reinterpret_cast<int*>(iAdata), num));

     env->ReleaseIntArrayElements(data, iAdata, );

     return ptr;
 }

9. 在AndroidClass.java添加释放内存的函数AndroidClassFree，感觉这两个函数名字不一定需要相同（相同没有错误，不相同没测试）。

 public void AndroidClassFree()
 {
     AndroidClassFree(ptr_);
 }

private native void AndroidClassFree(long ptr);

10. 在AndroidClass.cpp添加9中调用class的接口函数。

 JNIEXPORT void JNICALL Java_com_example_testclass_AndroidClass_AndroidClassFree
   (JNIEnv *, jobject, jlong ptr)
 {
     if(reinterpret_cast<myMeanSum*>(ptr))
     {
         delete reinterpret_cast<myMeanSum*>(ptr);
         ptr = ;
     }
 }

11. 在android.mk中添加需要编译的C++类的源文件（默认是LOCAL_SRC_FILES := AndroidClass.cpp）：

LOCAL_SRC_FILES := AndroidClass.cpp myMeanSum.cpp

12. 分别添加其他的代码，此处略去，详见工程：

https://github.com/darkknightzh/testClass

说明：AndroidClassGetPtr程序不使用，如果需要在外部的AndroidClass定义的对象A使用对象B，则使用这个函数传入 B的指针。

测试步骤：

1. 在VS中添加如下简单的测试代码：

 int number = ;
 int* data = new int[number];
 for (int i = ; i < number; i++)
 {
     data[i] = i;
 }
 myMeanSum temp(data, number);
 printf("%d\n", temp.calcSum());
 printf("%f\n", temp.calcMean());

输出为

4.500000

2. 在Eclipse的MainActivity.java的onCreate中添加如下测试代码：

 int number = ;
 int[] data = new int[number];
 for (int i = ; i < number; i++)
 {
       data[i] = i;
 }

 AndroidClass test=new AndroidClass(data,number);
 System.out.println("test-----"+test.calcSum());
 System.out.println("test-----"+test.calcMean());
 test.AndroidClassFree();

结果如下：

证明程序正确。

3. 为了证明class中的析构函数正确被调用，databuf申请的内存能正常释放，填写如下测试代码：

  int number = *;
 int[] data = new int[number];
 for (int i = ; i < number; i++)
 {
         data[i] = i;
 }

 for(int i=;i<;i++)
 {
      AndroidClass test=new AndroidClass(data,number);
      System.out.println("test-----"+i+"   "+test.calcSum());
      System.out.println("test-----"+i+"   "+test.calcMean());
       test.AndroidClassFree();
 }

程序执行完没有出错。证明析构函数能正确的执行，databuf申请的内存能正常释放。

4. 注释掉test.AndroidClassFree();后，程序跑到128次的时候崩溃，之后继续从0开始跑。证明AndroidClassFree函数正确的执行了析构函数。

5. 跑上面3的代码，但是myMeanSum类中的析构函数里面的代码全部注释掉，程序跑到128次后依旧崩溃，证明AndroidClassFree函数正确的执行了析构函数。

ps，上面程序只是一个简单的例子，可能有不完善的地方，同时代码写得也不是很好。

参考网址（貌似不能愉快的访问，感谢原作者，以及不能愉快的访问的搜索引擎）：

http://stylishtoupee.blogspot.jp/2011/07/jni-example-with-class-instantiation-c.html