android基础--JNI基础：C/C++语言

JNI简介
什么是JNI
JNI(Java Native Interface) java本地开发接口
JNI 是一个协议, 有了这个协议可以使Java代码和C/C++代码相互调用.
--C语言调用java是使用反射技术，C反射java.

为什么用JNI
* JNI扩展了java虚拟机的能力, 如wifi热点共享功能, wifi需要使用到硬件,而硬件需要驱动程序, 只有c语言可以开发驱动程序 
  游戏外挂就是用C写的，拿到别的玩家的某个参数的地址值并进行修改。
* c/c++代码执行效率高. c可以直接操控内存. c指针可以直接根据某个地址操控内存. 执行的效率和速度提升。
  在实时渲染的游戏上,音视频处理 (极品飞车,opengl,ffmpeg)上可以用C将数据直接推送到显卡内存显示，速率高，不会出现屏幕卡，用java写慢，可能会卡。
  windows系统中显卡内存范围是固定的，C用指针可以访问
* C语言开源库比java开源库还多。如ffmpeg(万能解码器，可以对90%以上的视频格式，如avi/wma等进行编码)，7zip等。
* 复用代码 (文件压缩,人脸识别…)
* 特殊的业务场景

C语言中System()方法的作用：
System("pause"); 给命令行一个暂停的命令，用于观察程序执行的结果。
---System方法会暂停程序运行，阻塞主程序，当前运行完成后，才会继续往下走。
System("mspaint");打开画画板。
System("java HelloWorld"); 运行java程序，HelloWorld.class需要在C程序当前目录中。

# C/C++语言

- 基本数据类型
- java的八大数据类型
 - byte 1个字节
 - boolean 1个字节
 - char 2个字节，是一个unicode，可以表示汉字
 - short 2个字节
 - int 4个字节
 - long 8个字节
 - float 4个字节
 - double 8个字节

- c语言的基本数据类型
 - char 1个字节，不能表示汉字
 - int 4个字节，
 - float 4个字节
 - double 8个字节
 - long 4个字节
 - short 2个字节
 - signed 有符号，表示的数值比较小，但是可以表示 负数
 - unsigned 无符号，表示 的数值较少。
 - void 任意类型, 类似于java中Object

 - 和java对比缺少两种类型
  - byte c中没有此类型
  - boolean 0代表是false, 非0代表是true.

---sizeof(int/long/char),获取基本数据类型占用的字节数。
---C语言中long占用4个字节，java中long占用8个字节，C与java中long数据传递时使用C中的long long类型，占用8个字节。

输出函数
printf，使用占位符输出数据。
占位符:
   
%d     -  int
%hd    – 短整型 short
%ld    -  long int
%c     -  char
%f     -  float
%lf    – double
%u     – 无符号数
%x     – 十六进制输出 int 或者long int 或者short int
%o     -  八进制输出
%s     – 字符串
---浮点数在输出时, 默认是以小数点后6位输出. 多出的6位会四舍五入.
---在%的后面加上.4(%.4f)，指定输出小数点后四位
---对应的类型, 就使用对应的占位符，否则可能损失精度。
---如int数据用%hd输出时只会输出后面2个8位：
   %hd: 24910
      二进制:  00000000  00000000  01100001  01001110
   %d: 12345678
      二进制:  00000000   10111100   01100001     01001110
   比较:
      24910:              00000000  00000000  01100001  01001110
      12345678:           00000000  10111100  01100001  01001110

---c语言中没有string类型, 用来表示字符串类型的是char数组
---c语言中定义数组时, 中括号不允许写在类型的后面, 应该写变量名的后面
---%x,%o，一般用来输出地址，输出结果中不带前缀0x/0，要想显示前缀，需要在中间加#号，%#x,%#o。

输入函数
--在变量名前边加一个&, 就是取地址
--scanf(占位符, 地址);

指针
内存，内存编号就是地址,内存分很多单元,每个单元对应一个编号.
地址，内存单元的编号。

为什么4G内存只显示3G？
地址是从0开始的非负整数，0000~FFFF
XP操作系统 为神马只能显示3G内存：
常用的XP系统都是32位的系统，就是说在所有程序（包括）系统本身运行的时候，最多能使用2的32次方的地址，
可以自己算一下2的32次方就是4G，但问题是，系统里面除了内存还有其它设备啊，显卡硬盘之类的都是需要地址的，
所以，留给内存使用的地址只有3G多一点，剩下的要保留给其它设备。

指针说明
--当说一个指针中存储的是值时, 当前所说的指针就是：　内存地址.
--当说一个指针中存储的xx变量的地址时, 当前所说的指针就是:　指针变量．

*号的三种含义;
1. 作为数学运算符: 乘号
2. 当*号写在某个类型的后面时, 这时作为声明指针变量的类型出现.
3. 当*号写在指针变量的前面时, 这时作为取出指针变量中存储的地址对应在内存中的值.

变量i和*p的关系
 int i = 335;
 int* p;
 p = &i; // 把i变量的地址赋值给了指针变量p
 // 修改p的值会影响i的值吗 不会
 //printf("修改前i的值为: %d\n", i);
 //int j = 56;
 //p = &j;
 //printf("修改后i的值为: %d\n", i);
 // 修改*p的值会影响i的值吗 会
 printf("修改前i的值为: %d\n", i);
 *p = 8888; // 把p变量中存储的i的地址在内存中对应的值修改为: 8888
 printf("修改后i的值为: %d\n", i);

多级指针.
 /*
 多级指针 
 一级指针变量的地址, 只能由二级指针变量地址存储. 依此类推.  
 多级指针时, 加*号取值时, 不要以变量名去查找上一个变量.  
 */
 main() {
    int i = 168;    
    int* p1 = &i;          
    int** p2 = &p1;    
    int*** p3 = &p2;    
    int**** p4 = &p3;   
    // 通过p4取i的值   
    printf("****p4=%d\n", ****p4);    
    system("pause");      
 }

数组
指针变量就是数组, 数组就是指针变量
 // 使用指针的方式定义数组，cPoint中存储的是首地址.
 char* cPoint = "nihaoa!!!";
 // cArray中存储的也是首地址.
 char cArray[] = {'n', 'i', 'h', 'a', 'o', 'a', '!', '!'};

C中数组其实是一块连续的内存区域，每一个元素占用着自己的类型的字节长度。
首地址(第0个元素的地址)
         1. 数组变量名的地址就是首地址
         2. 数组变量中存储的也是首地址
         3. 数组中第0个元素的地址也是首地址.

如果采用指针变量的方式定义数组: char* cPoint = "nihaoya!!!!";
                                指针变量中存储的地址就是首地址.

指针的长度和运算.
--不管什么类型的指针都是4个字节.
--C语言为了方便指针运算, 定义各种基本类型的指针, 每种类型的指针运算时所偏移量的值是根据类型的长度决定的.

注：
---C中不存在数组角标越界，超出数组长度时会取出后面地址中的内容。
---C语言中for循环中的循环变量不能定义在for()语句内，只能定义在外面，否则违反C99标准。
   C99是C语言的一种语法约束标准。

指针和指针变量的关系
--指针就是地址，地址就是指针
--地址就是内存单元的编号
--指针变量是存放地址的变量
--指针和指针变量是两个不同的概念
--但是要注意： 通常我们叙述时会把指针变量简称为指针，实际它们含义并不一样
--我的指针里边的值为: 123;   指针(地址)
--我的指针里边存的是xxx变量的地址, 指针(指针变量)

指针的重要性
--直接访问硬件 (opengl 显卡绘图)
--快速传递数据(指针表示地址)
--返回一个以上的值(返回一个数组或者结构体的指针)
--表示复杂的数据结构(结构体)
--方便处理字符串
--指针有助于理解面向对象

C语言内存，栈内存，堆内存
1. 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。
2. 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
3. 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多.
堆和栈的区别:
1. 申请方式
栈:
由系统自动分配.例如,声明一个局部变量intb;系统自动在栈中为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来显式地收回,否则会造成内存泄漏。
堆和栈的区别可以用如下的比喻来看出：
使用栈就像我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。
使用堆就像是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。

静态内存和动态内存
静态内存, 默认情况下就是静态内存. 当某个方法执行完毕之后, 此方法内声明的变量都是采用静态内存分配得来的, 当方法执行完毕之后, 就会把方法里声明的变量的内存回收了.
--静态内存回收机制, 在回收的时候有一定的过程, 在另一个方法中立刻的取一下值, 还是可以取到的.

 /*
 pAddress中存储的是: main函数中p的地址.
 */
 func(int** pAddress) {
     int a = 543;     
     printf("a的地址为: %#x\n", &a);     
     // 把a地址赋值给main函数中p变量
     *pAddress = &a;
 }
 
 main() {
     int* p; // 定义一个指针变量p, 用于接收子函数func中a变量的地址.     
     func(&p);     
     printf("*p=%d\n", *p);
     printf("*p=%d\n", *p); // 第二次取值,就取不到了,被回收掉了.
     printf("p中存储的地址是: %#x\n", p);
     system("pause");      
 }

--动态内存, 可以长期在另一个方法中保留子方法中的变量.
  malloc(申请的长度);  申请一块内存空间, 返回的是申请出来的地址.
  free(地址); 把给定的地址所在的内存给回收掉.
  realloc，重新内存空间
 func(int** pAddress) {
     int i = 168;           
     // 手动申请一块内存, 并且把i变量的值, 拷贝进去.     
     int* temp; // 定义一个临时指针变量temp
     // temp中存储的是申请出来的地址
     temp = malloc(sizeof(int)); // 申请一块内存空间: 4个字节, 此方法返回的是申请出来那块内存空间的地址.     
     *temp = i;    
     // 把main中的p变量中的值, 赋值为申请出来的地址
     *pAddress = temp;
 }
 
 /*
 动态内存分配: 手动申请一块内存空间. 需要手动释放掉.    
 free(地址); 把给定的地址的内存给回收掉.
 */
 main() {
     int* p;    
     func(&p);
     printf("*p=%d\n", *p);
     printf("*p=%d\n", *p);
     printf("*p=%d\n", *p);    
     free(p); // 把手动申请出来的内存空间回收掉
     printf("回收后: *p=%d\n", *p);
     printf("回收后: *p=%d\n", *p);
     printf("回收后: *p=%d\n", *p);    
     system("pause");      
 }

注：要使用malloc函数，
--必须添加malloc.h这个头文件
--malloc函数只能返回第一个字节的地址
--int * p = (int *)malloc(4);这句代码分配了8个字节, p变量占4个字节， p所指向的内存也占4个字节
--p本身所占的内存是静态分配的， p所指向的内存是动态分配的  

案例: 用户手动创建数组, 再扩展数组.

  // 1. 让用户输入一个长度.
  printf("请输入数组的长度: ");
  int length;
  scanf("%d", &length);
  printf("长度为: %d\n", length);

  // 2. 根据用户输入的长度, 申请一块内存空间.  长度 * sizeof(int) = 总内存空间. 
  int* iArray; // 定义一个指针变量 
  iArray = malloc(length * sizeof(int)); // 把数组的首地址给了iArray 

  // 3. 依次让用户把每一个元素的值填进去.
  int i;
  for(i = 0; i < length; i ++) {
     printf("请输入第%d个元素的值: ", i);
     scanf("%d", iArray + i);
  }

  // 4. 再让用户输入一个扩展的长度
  printf("请输入扩展的长度: ");
  int supportLength;
  scanf("%d", &supportLength);
  printf("扩展的长度为: %d\n", supportLength); 

  // 5. 重新申请内存空间: (第一次输入的长度 + 扩展的长度) * sizeof(int) = 总内存空间.
  iArray = realloc(iArray, (length + supportLength) * sizeof(int));

  // 6. 把扩展后新增的几个元素一个一个赋值. 
  for(i = length; i < (length + supportLength); i ++) {
     printf("请输入第%d个元素的值: ", i);
     scanf("%d", iArray + i);
  }

  // 7. 把数组打印输出了. 
  for(i = 0; i < (length + supportLength); i ++) {
     printf("第%d个元素的值: %d\n", i, *(iArray + i));      
  }
  // 8. 回收内存
  free(iArray);

函数指针

 int increment(int x, int y) {
  return x + y;
 }
 
 main() {
     int (*funcPoint)(int x, int y); // 定义一个函数指针: 接收两个int的参数, 返回是int的类型.
     
     funcPoint = increment; // 把方法赋值给函数指针. 
     
     int result = funcPoint(10, 25);  // 使用函数指针调用方法. 
     
     printf("结果为: %d\n", result);
     
     system("pause");       
 } 

结构体

 struct Student {
     int age;
     float score;
     char sex;       
 }; 
 
 main() {
     struct Student stu = {20, 99.5, 'M'};
     
     printf("stu.age=%d\n", stu.age);
     printf("stu.score=%.1f\n", stu.score);
     printf("stu.sex=%c\n", stu.sex);
     
     stu.age = 25;
     stu.score = 100.00;
     stu.sex = 'W';
     printf("stu.age=%d\n", stu.age);
     printf("stu.score=%.1f\n", stu.score);
     printf("stu.sex=%c\n", stu.sex);
     
     // 定义一个结构体指针变量
     struct Student* stuPoint;
     stuPoint = &stu; // 把结构体stu的地址赋值给stuPoint结构体的指针变量
     
     printf("(*stuPoint).age=%d\n", (*stuPoint).age );
     printf("(*stuPoint).score=%.1f\n", (*stuPoint).score);
     printf("(*stuPoint).sex=%c\n", (*stuPoint).sex);
     
     (*stuPoint).age = 30;
     (*stuPoint).score = 110.5;
     (*stuPoint).sex = 'M';
     
     printf("(*stuPoint).age=%d\n", (*stuPoint).age );
     printf("(*stuPoint).score=%.1f\n", (*stuPoint).score);
     printf("(*stuPoint).sex=%c\n", (*stuPoint).sex);
     
     //  stuPoint->age  等价于 (*stuPoint).age
     
     stuPoint->age = 50;
     printf("stuPoint->age=%d\n", stuPoint->age);
     
 
     system("pause");       
 }

联合体

 /*
 只有一遍变量会被赋值. 特点: 多个变量采用的是同一块内存空间. 
 后赋值的会把先赋值的给覆盖掉. 
 */
 union Result {
    long l;
    int i;
    char c;
 };
 
 
 main() {
     
     union Result result; 
     result.l = 123;
     result.i = 888;
     
     printf("result.l=%ld\n", result.l);
     printf("result.i=%d\n", result.i);
     
     system("pause");       
 }

枚举

 enum WeekDay {
   Monday = 10,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday
 };
 
 main() {
     enum WeekDay day; // 定义枚举对象
     
     day = Sunday;
     
     printf("day=%d\n", day);
     
     system("pause");       
 } 

typedef 给某个类型起个别名

typedef double db; // 给某个类型起个别名:  给double起个别名: db 
 typedef int i;
 typedef float ft;

   db d = 3.14159234234;
   printf("%lf\n", d);
   
   ft f = 3.1415;
   printf("%f\n", f);

int数组的指针方式定义

C中可随意调用sleep().

services.msc，打开系统中所有服务

msconfig，打开系统配置。

C中注释与java中相同。

代码优化，int数据换成byte.