Android JNI--C语言基础

1, #include

相当于java的导包操作例如：#include <stdio.h>

<> 代表寻找系统的资源

“” 代表寻找我们自己写的资源

.h .hpp(声明文件 头文件)

.c  .cpp （实现文件）

2，代码结构

int main() {  // 函数的主入口printf("哈喽!");//打印getchar(); // 阻塞程序return 0;
}

3，基本数据类型

 int i = 100;double d = 200;float f = 200;long l = 100;short s = 100;char c = 'd';
上面这些基本数据类型与java一致
需要注意的是 字符串类型 java中是String  而C语言中是  char * str = "我是字符串";

sizeof获取字节数 下面是每个基本类型所占用的字节数 可以通过此api获取

sizeof(int)//int 占几个字节  == 4
sizeof(double)//double 占几个字节 == 8
sizeof(char)//char 占几个字节 ==1
sizeof(long)//long占几个字节 == 4
sizeof(short)//short占几个字节 == 2
sizeof(float)//float占几个字节 == 4bit——计算机的最小单位byte——1byte = 8bit       （byte就是字节）kb——1kb = 1024bytemb——1mb = 1024kbgb——1gb = 1024mbtb——1tb = 1024gbpb——1pb = 1024tb

4，打印

打印需要注意的是，不和java一样随便打印的，需要占位符

    printf("i的值是：%d\n", i); // d == 整形printf("d的值是:%lf\n", d); // lf == long floatprintf("f的值是:%f\n", f); // f == floatprintf("l的值是:%d\n", l); // d == 整形printf("s的值是:%d\n", s); // s == shortprintf("c的值是:%c\n", c); // c == charprintf("字符串:%s\n", str); // s == String

5，指针地址

在java中，万物皆对象。

在Linux中，万物皆文件

在C 语言中，万物皆指针

指针其实可以理解为地址

& 代表取出地址例如：

int number = 10;
printf("此number变量的地址是:%p\n", &number); // 地址 == 00B3FE90

* 代表取出地址所对应的值 例如：

int number = 100;
printf("number的值是:%d\n", *(&number));//100 &number代表number所对应的地址  *(&number)代表取number地址所对应的值 所以输出100

int * 代表int类型的指针 说明定义的是一个指针变量，就是一个变量而已，只不过是指针的变量而已

例如：

int a = 100;
int * b = &a;
printf("a的值是:%d\n", *b);输出100  因为b是a的指针，也就是a地址，
*b代表取地址所对应的值，也就是取a的地址所对应的值100

只要记住一句话，内存地址就是指针，指针就是内存地址

下面看一个错误的用法：

int i = 100;
int * p = i;这种写法是错误的，因为p只能接收指针，给它传一个100，显然是不行的

正确的写法应该是：

int i = 100;
int * p = &i;
指针变量 只能接收指针

如何通过指针修改变量值呢？举个例子：

int i = 100;
int * p = &i;
i = 200;
printf("*p的值是:%d\n", *p);输出200，因为i变为了200，p指向i，*p取得是i的值*p = 300;printf("i的值是:%d\n", i);输出300，因为*p代表i的地址所对应的值修改成300

6，函数

C语言不允许函数重载，Java可以，C++可以

函数需要先声明，再实现。函数不能写在main函数的下面，会报错

下面来看一个简单的函数例子：

#include <stdio.h> //引入标准库void change(int * i); // 先声明  参数为指针变量int main() {int i = 100;change(&i);//传入指针printf("%d\n", i);//输出666return 0;//main函数返回值 也可以写为NULL
}// 再实现
// 使用指针 来修改
void change(int * i) {*i = 666;
}

由于C语言不支持函数重载，所以声明的函数，不需要写参数

例如：

void change();//不需要填写参数int main() {int a = 100;int b = 200;change(&a, &b);printf("交换完成后的效果：%d,%d\n", a, b);//200  100}// 只接收指针(内存地址)
void change(int * a, int * b) {int temp = *a;*a = *b;*b = temp;
}

7，多级指针：

直接看例子：

int num = 20;int * num_p = &num; // 取出num的内存地址给 num_p（一级指针）int ** num_p_p = &num_p; // 取出num_p的内存地址给  num_p_p（二级指针）int *** num_p_p_p = &num_p_p;//取出num_p_p的内存地址给 num_p_p_p （三级指针）printf("获取最终的值：%d\n", **num_p_p);//输出20printf("获取最终的值：%d\n", *** num_ppp);//输出20是几级指针，取值时，前面就加几个*

8，数组与数组指针

 定义数组int [] arr = {1,2,3,4}; 错误的写法int arr[]  = {1,2,3,4}; 正确写法

遍历数组
int i = 0;
for (i = 0; i < 4; ++i) {printf("%d\n", arr[i]); // 取值
}

数组的内存地址等于第一个元素的内存地址，不是其他元素的地址

上面数组的内存地址可以写为：arr &arr &arr[0]

既然数组就是一个内存地址，那么

int * arr_p = arr;

数组可以用地址变量赋值

操作数组，就是对数组的指针进行操作。

int arr[]  = {1,2,3,4};将数组地址赋值给指针变量arr_p  此时指针默认指向第一个元素
int * arr_p = arr; printf("%d\n", *arr_p); //输出1 因为此时指针指向第一个元素的内存地址arr_p ++; // 指针挪动   此时指向元素二的内存地址了printf("%d\n", *arr_p); // 输出2 因为此时指针指向第二个元素的内存地址arr_p += 2;printf("%d\n", *arr_p); // 输出4 因为此时指针指向第四个元素的内存地址

数组是连续的内存空间，数组每次挪动4个字节

通过循环给数组赋值：

定义数组
int arr[4];赋值给指针变量arrP
int * arrP = arr;循环赋值操i作
int i = 0;
for (i = 0; i < 4; ++i) {// 1.拿到 元素一 元素二 元素三 元素四 的内存地址   (arrP + i)// 2.取出 元素一 元素二 元素三 元素四 的内存地址 所对应的值 * (arrP + i)* (arrP +i) = (i + 10001);
}

9,函数指针

void(*methid)(int,int) 函数指针

void 返回值

(*methid) 函数名

（int,int）参数可以随便写这里只是举个例子

下面来看具体用法:

void add(int num1, int num2); // 先声明void opreate(void(*method)(int,int), int num1, int num2) {method(num1, num2);
}int main() { opreate(add,  10, 10);printf("main函数的 add指针是多少：%p\n", add);// &add和add是一样的值吗printf("%p, %p\n", add, &add); //  一样的return 0;
}// 再实现 使用
void add(int num1, int num2) {printf("num1 + num2 = %d\n", (num1 + num2));
}

10,C语言中的布尔类型

C语言和Java的不同就是，C语言没有true和false 只有0和非0

只要记住一句话即可，非0即true 0就是false

11，静态开辟

在函数局部内，创建的数据，在执行函数的时候会进栈操作，函数执行完毕，会执行弹栈。因此会释放栈内的成员，栈内的数据也称之为栈内成员，这种方式开辟的内存，称为静态开辟，执行完会弹栈。不会占用内存空间。

静态开辟，即在栈区开辟内存 
int a;
int arr[6];
char 'c';
等等操作都属于静态开辟内存

进栈
void staticAction() {int arr[5]; // 静态开辟 栈区 （栈成员）
} 
函数的末尾会弹栈（隐士）：执行完毕会弹栈  会释放所有的栈成员

栈区：占用内存大小 最大值： 大概 2M  大于2M会栈溢出  平台有关系的
堆区：占用内存大小 最大值： 大概80%  40M没有任何问题，基本上不用担心 堆区很大的
大概80%： Windows系统 给我们的编译器给予的空间  的 百分之百八十

12，动态开辟

使用malloc函数，可以动态开辟内存，这种方式的空间属于在堆中开辟，函数执行完毕之后，不会释放堆空间，因此我们一定要手动释放free，并把指针指向NULL。避免悬空指针。

悬空指针：指针指向一块内存，如果这块内存稍后被操作系统回收（被释放），但是指针仍然指向这块内存，那么，此时该指针就是“悬空指针”

void *p = malloc(size);
assert(p);
free(p); 
// 现在 p 是“悬空指针”

正确的写法

void *p = malloc(size);
assert(p);
free(p); 
// 避免“悬空指针”
p = NULL;

野指针：是没有被初始化过的指针，所以不确定指针具体指向

void *p;  // 此时 p 是“野指针”

因为“野指针”可能指向任意内存段，因此它可能会损坏正常的数据，也有可能引发其他未知错误。在实际的C语言程序开发中，定义指针时，一般都要尽量避免“野指针”的出现，可通过赋初值方式解决：

void *p = NULL;
void *data = malloc(size);

下面再来讲讲动态开辟：

 int * arr = malloc(1 * 1024 * 1024); // 堆区开辟 4Mfree(arr); // 释放掉arr = NULL; // 重新指向一块内存地址00000

realloc:前面已经开辟的空间，使用realloc可以扩展空间大小，举例如下：

动态开辟一个大小为5的数组
int * arr = (int *) malloc(5);
for (int i = 0; i < 5; ++i) {arr[i] = (i + 10001); 
}//使用realloc 将arr扩展为大小为11的数组
int * new_arr = (int *) realloc(arr, 5+6);int j = 5; // 5开始
for (; j < (5+ 6); j++) { arr[j] = (j + 10001);
}别忘了释放
free(new_arr);
new_arr = NULL;

13，结构体

在C语言中，结构体相当于 java中的类

结构体的定义形式为


struct 结构体名
{成员列表（可以是基本的数据类型，指针，数组或其他结构类型）
};

例如：

struct Dog {// 成员char name[10];int age;char sex;};
必须要在最后写;

struct Dog dog;
这样写完，成员是没有任何初始化的，成员默认值 是系统值，乱码赋值操作strcpy(dog.name, "旺财");
dog.age = 3;
dog.sex = 'G';

第二种写法：

struct Person {// 成员char * name; // 字符指针 = "赋值"int age;char sex;
} ppp = {"zhangsan", 33, 'W'};

结构体指针

struct Cat {char name[10];int age;
};int main() { // 栈// 结构体struct Cat cat = {"小花猫", 2};// 结构体 指针    -> 调用一级指针成员struct Cat * catp = &cat;catp->age = 3;strcpy(catp->name, "小花猫2");printf("name:%s, age:%d \n", catp->name, catp->age);return 0;
}

结构体指针与动态内存开辟

struct Cat {char name[10];int age;
};int main() { // 堆// VS的写法：Cat * cat = (Cat *) malloc(sizeof(Cat));struct Cat *cat = malloc(sizeof(struct Cat));strcpy(cat->name, "金色猫");cat->age = 5;printf("name:%s, age:%d \n", cat->name, cat->age);// 堆区的必须释放free(cat);cat = NULL;return 0;
}

14，结构体取别名

struct Student_{char name[10];int age;char sex;
};typedef struct Student_Student_; // 给结构体取别名typedef Student_* Student; // 给结构体指针取别名