JNI java本地开发接口

JNI 是一个协议

这个协议用来沟通java代码和外部的本地代码(c/c++).

通过这个协议,java代码就可以调用外部的c/c++代码

外部的c/c++代码也可以调用java代码

* 输出

#include <stdio.h> //standard input output
#include <stdlib.h>

main(){
       printf("小志的逗比精神永存\n");
       system("pause"); 
}

* C调用java的hello

public class Hello
{
    public static void main(String[] dd){
        System.out.println("hello from java");
    }
}
#include <stdio.h>
#include <stdlib.h>

main(){
       printf("hello from c\n"); 
       system("java Hello");
       system("pause"); 
}

* C的基本数据类型

char, int, float, double, long, short, signed, unsigned

C语言/指针_#include

#java的基本数据类型长度
* byte:1
* short:2
* int:4
* long:8
* boolean:1
* char:2
* float:4
* double:8

#c的基本数据类型长度
* short:2
* int:4
* long:4
* char:1
* float:4
* double:8

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

main(){
       //char, int, float, double, long, short, signed, unsigned
       
       int i =3;
       char c = 'a';
       long long ago = 12314324;
       short int i2 = 2;
       long int i3 = 3243;
       //printf("i的值为%d\n", i);
       
       printf("char的长度:%d\n", sizeof(char));
       printf("int的长度:%d\n", sizeof(int));
       printf("float的长度:%d\n", sizeof(float));
       printf("double的长度:%d\n", sizeof(double));
       printf("long的长度:%d\n", sizeof(long));
       printf("short的长度:%d\n", sizeof(short));
       printf("long long的长度:%d\n", sizeof(long long));
       printf("short int的长度:%d\n", sizeof(short int));
       printf("long int的长度:%d\n", sizeof(long int));
       
       system("pause"); 
}

* 输出函数

#include <stdio.h>
#include <stdlib.h>
/*
%d  -  int
%ld – long int
%hd – 短整型
%c  - char
%f -  float
%lf – double
%u – 无符号数
%x – 十六进制输出 int 或者long int 或者short int
%o -  八进制输出
%s – 字符串
*/
main(){
       int i = -3;
       long l = 34567;
       char c = 'a';
       float f = 3.1466666666;
       double d = 3.1466666666;
       char arr[] = "小志的二逼精神永存";
       printf("%c\n", c);
       printf("%d\n", i);
       printf("%f\n", f);
       printf("%lf\n", d);
       printf("%u\n", i);
       printf("%#x\n", l);
       printf("%#o\n", l);
       printf("%s\n", arr);
       system("pause"); 
}

 * 输入函数

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

main(){
       printf("请输入班级人数:\n");
       int number;
       //&:取出number的内存地址 
       scanf("%d", &number);
       
       printf("请输入班级名称:\n");
       char name[10];
       scanf("%s", &name);
      
       printf("number的地址%#x\n", &number);
       printf("name的地址%#x\n", &name);
       printf("班级人数为%d,名称为%s\n", number, name); 
       system("pause"); 
}

 “*”的三种用法

1. 乘法
2. int* p:定义一个指针变量p,p中存放一个内存地址,这个地址所存放的数据规定是int型
3. *p:取出p中保存的内存地址存放的数据

* 指针和指针变量的关系

  指针就是地址,地址就是指针

  地址就是内存单元的编号

  指针变量是存放地址的变量

  指针和指针变量是两个不同的概念

  但是要注意: 通常我们叙述时会把指针变量简称为指针,实际它们含义并不一样

* 为什么使用指针

  指针的重要性

  直接访问硬件 (opengl 显卡绘图)

  快速传递数据(指针表示地址)

  返回一个以上的值(返回一个数组或者结构体的指针)

  表示复杂的数据结构(结构体)

  方便处理字符串

  指针有助于理解面向对象

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

main(){
       int i = 3;
       //定义一个保存int类型数据的地址的指针变量 ,该变量的值是一个内存地址 
       int* p = &i;
       int** q = &p;
      
       printf("i的地址%#x\n", p);
       
       printf("i的值为%d\n", *p);
       printf("i的值为%d\n", **q);
       system("pause"); 
}
#include <stdio.h>
#include <stdlib.h>

main(){
       //野指针:没有赋值的指针 
       int* p;
       int i;
       double d = 3.14;
       p = &d; 
       //*p = 23;
       printf("%#x\n", p);
       printf("%lf\n", *p);
       system("pause"); 
}

* 值交换(值传递: 所有语言所有平台,都只有值传递,引用传递传递的值是内存地址

#include <stdio.h>
#include <stdlib.h>
void swap(int* p, int* q){
     int temp = *p;
     *p = *q;
     *q = temp;
}
main(){
       int i = 3;
       int j = 5;
       printf("i=%d\n", i);
       printf("j=%d\n", j);
       swap(&i, &j);
       printf("i=%d\n", i);
       printf("j=%d\n", j);
       system("pause"); 
}

* 主函数取子函数的值

#include <stdio.h>
#include <stdlib.h>
void function(int** p){
     int i = 3;
     printf("i的地址为%#x\n", &i);
     *p = &i;
}
main(){
       int* mainp;
       function(&mainp);
       printf("主函数中获取i的地址为%#x\n", mainp);
       
       //子函数执行完后,里面的局部变量就会销毁
       //数据幻影 (如果上面两个打印被注释掉,那么在i的值被销毁之前,还是利用那么0.几秒的时候打印出来)
       printf("主函数中获取i的值为%d\n", *mainp);
       system("pause"); 
}

 

* 数组入门

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

main(){
    //数组的内存地址是连续的,但要注意不同数据类型所占的字节是不一样的。
    //整个数组的内存地址就是第一个元素的内存地址,
   //char arr[] = "hello"; 
   int arr[] = {1,2,3,4,5};
   
   printf("%#x\n", &arr[0]);
   printf("%#x\n", &arr[1]);
   printf("%#x\n", &arr[2]);
   printf("%#x\n", &arr[3]);
   
   printf("数组名字的地址%#x\n", &arr);
   
   //char* p = &arr;
   int* p = &arr;
   //+1表示向右偏移一个单位 
   printf("%d\n", *(p+0));
   printf("%d\n", *(p+1));
   printf("%d\n", *(p+2));
   printf("%d\n", (p+2)-p); 
   system("pause"); 
}

 

* 指针长度

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

main(){
       char* cp;
       int* ip;
       short* lizhip;
       int i;
       char c;
       cp = &c;
       ip = &i;
       //指针的长度都是4个字节 
       printf("%d\n", sizeof(cp));
       printf("%d\n", sizeof(ip));
       printf("%d\n", sizeof(lizhip));
       printf("%d\n", cp-ip);
       system("pause"); 
}

 

* 堆 栈

##栈
* 系统自动分配和释放
* 保存全局、静态、局部变量
* 在栈上分配内存叫静态分配
* 大小一般是固定的
##堆
* 程序员手动分配(malloc/new)和释放(free/java不用手动释放)
* 在堆上分配内存叫动态分配
* 一般硬件内存有多大就有多大

C语言/指针_#include_02

堆和栈的区别:
1.申请方式
栈:   
由系统自动分配.例如,声明一个局部变量int  b; 系统自动在栈中为b开辟空间.例如当在调用涵数时,需要保存的变量,最明显的是在递归调用时,要系统自动分配一个栈的空间,后进先出的,而后又由系统释放这个空间. 
堆:   
需要程序员自己申请,并指明大小,在c中用malloc函数   
如char* p1  =  (char*) malloc(10);   //14byte
但是注意p1本身是在栈中的.
  2  申请后系统的响应   
 栈:只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。   
堆:首先应该知道操作系统有一个记录空闲内存地址的链表,当系统收到程序的申请时,    会遍历该链表,寻找第一个空间大于所申请空间的堆结点,然后将该结点从空闲结点链表中删除,并将该结点的空间分配给程序,另外,对于大多数系统,会在这块内存空间中的首地址处记录本次分配的大小,这样,代码中的delete语句才能正确的释放本内存空间。另外,由于找到的堆结点的大小不一定正好等于申请的大小,系统会自动的将多余的那部分重新放入空闲链表中。   
 
3.申请大小的限制   
栈:在Windows下,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在WINDOWS下,栈的大小是2M(vc编译选项中可以设置,其实就是一个STACK参数,缺省2M),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间较小。   
堆:堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。   
 
 4.申请效率的比较:   
栈:由系统自动分配,速度较快。但程序员是无法控制的。   
堆:由malloc/new分配的内存,一般速度比较慢,而且容易产生内存碎片,不过用起来最方便.   
 
 5.堆和栈中的存储内容   
栈:在函数调用时,第一个进栈的是主函数中后的下一条指令(函数调用语句的下一条可执行语句)的地址,然后是函数的各个参数,在大多数的C编译器中,参数是由右往左入栈的,然后是函数中的局部变量。注意静态变量是不入栈的。   
当本次函数调用结束后,局部变量先出栈,然后是参数,最后栈顶指针指向最开始存的地址,也就是主函数中的下一条指令,程序由该点继续运行。   
堆:一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。   
 
6.内存的回收
栈上分配的内存,编译器会自动收回;堆上分配的内存,要通过free来显式地收回,否则会造成内存泄漏。
  堆和栈的区别可以用如下的比喻来看出:   
使用栈就像我们去饭馆里吃饭,只管点菜(发出申请)、付钱、和吃(使用),吃饱了就走,不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作,他的好处是快捷,但是自由度小。   
使用堆就像是自己动手做喜欢吃的菜肴,比较麻烦,但是比较符合自己的口味,而且自由度大。

* 栈上分配的就是静态内存,堆上分配的就是动态内存

学号管理系统

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
main(){
       printf("请输入学生人数:");
       int count;
       scanf("%d", &count);
       
       //根据学生人数去动态申请堆内存 
       int* p = malloc(sizeof(int) * count);
       
       int i;
       for(i = 0; i < count; i++){
             printf("请输入第%d个学生学号:", i);
             scanf("%d", p+i);
       }
       
       printf("请输入新增的学生人数:");
       int newCount;
       scanf("%d", &newCount);
       p = realloc(p, sizeof(int) * (count + newCount));
       
       for(i = count; i < count + newCount; i++){
             printf("请输入第%d个学生学号:", i);
             scanf("%d", p+i);
       }
       
       for(i = 0; i < count + newCount; i++){
            printf("第%d个学生的学号是:%d\n", i, *(p+i)); 
       }
       system("pause"); 
}

 

* 多级指针

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

main(){
       int i = 3;
       int* p = &i;
       int** q = &p;
       int*** l = &q;
       
       printf("i的值为%d\n", ***l);
       system("pause"); 
}

 

* 结构体(长度会自动补齐)

#include <stdio.h>
#include <stdlib.h>
void study(){
     printf("吃饭睡觉打李志\n");
}
//定义一个结构体 
struct student{
       int age;
       int height;
       char sex;
       
       //结构体中不能定义函数,但可以定义函数指针
       void (*studyP)(); 
}

main(){
       //定义结构体的变量 
       struct student st = {20, 180, 'm', study};
       printf("%d\n", st.age);
       printf("结构体的长度%d\n", sizeof(st));
       
       //调用函数指针有三种写法 
       st.studyP();
       
       struct student* stp = &st;
       (*stp).studyP();
       
       stp->studyP();
       system("pause"); 
}

 

* 联合体(长度取最大的那个)

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

main(){
       //定义一个联合体 
       union{long long i; short s; char c} un;
       un.i = 3;
       printf("%d\n", un.i);
       printf("联合体的长度%d\n", sizeof(un));
       system("pause"); 
}

 

* 枚举

#include <stdio.h>

enum WeekDay
{
Monday = 10,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday
};

int main(void)
{
  //int day;
  enum WeekDay day = Sunday;
  printf("%d\n",day);
  system("pause");
  return 0;
}

 

* 自定义类型

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

typedef int haha;
main(){
       haha i = 3;
       printf("%d\n", i);
       system("pause"); 
}

 

NDK\platforms\android-19\arch-arm\user\include\jni.h中有C语言和JAVA语言之间的翻译