1_c基础

NDK 学到什么程度，该怎么学 ?

c/c++ 少不了，基础，进阶，linux 内核，shell 脚本，cmake 语法
opencv ，fmpeg ,opengl,android native
android 开发:c/c++工程师开发(精通)，java 工程师(精通)，native 和 java 层互通 NDK 开发熟悉c++.熟悉android)
知道:有这么个东西，你模糊
熟悉:知道这个东西，讲明白，项目中也能直接用上
精通:知道这个东西，讲明白，项目中也能直接用上，知道原理( 四种启动模式，怎么解析的，怎么压栈弹栈，声明周期怎调用的)

fitst.cpp文件：

#include <stdio.h>
#include <stdlib.h>
//#include <unistd.h>
#include <Windows.h>
//01默认格式
// int main()
// {
//     printf("Hello World!\n");
//     system("pause");    // 防止运行后自动退出，需头文件stdlib.h
//     return 0;
// }

//02打印输出
// %d：用于输出整数。
// %f：用于输出浮点数。
// %c：用于输出字符。
// %s：用于输出字符串。
// %p：用于输出指针。
// %x：用于输出十六进制数。
//\n换行
// int main(){
//     int a=100;
//     double b=100.1;
//     float c=100.2;
//     long d=200;
//     short e=200;
//     char f='a';
    
//     printf("a=%d\n",a);  
//     printf("b=%f\n",b);
//     printf("c=%f\n",c);
//     printf("d=%d\n",d);
//     printf("e=%d\n",e);
//     printf("f=%c\n",f);
//     system("pause");
//     return 0;

//     //输出结果：
//     // a=100
//     // b=100.100000
//     // c=100.199997
       // d=200
       // e=200
       // f=a

// }

//03变量地址 &代表取变量的地址
// int main(){
//     int a=100;
//     printf("a=%d\n",a);//值
//     printf("a=%p\n",&a);//地址:a=000000000061FE1C
//     system("pause");
//     return 0;
// }

// 04 指针变量和获取地址的值
// int main(){
//     int a=100;
//    int* p =&a;
//     printf("p的值是：%d\n", *p);//获取值
//     printf("p的值是：%d\n", p);//获取地址
//     printf("p的值是：%d\n", *(&p));//获取地址
//     system("pause");
//     return 0;
// }

// 05 通过指针修改值 
// int main(){
//     int a=100;
//     int* p=&a;
//     printf("a=%d\n",a);
//     printf("*p=%d\n",*p);

//     *p=200;
//     printf("a1=%d\n",a); //a1=200
//     printf("p1=%d\n",*p);//p1=200
//     system("pause");
//     return 0;
// }

// 06 方法修改值和指针修改值
// void change(int i){// 通过方法修改值
// 	printf("change1 中i的地址是：%p\n",&i);
// 	i = 200;
// }

// void changePoint(int* p){// 通过地址来修改
// 	printf("change2中i的地址是：%p\n",p);
// 	*p = 300;
// }
// int main(){
// 	int i = 100;
// 	printf("i的地址是：%p\n", &i);
// 	printf("i的值是：%d\n", i);
// 	change(i);//方法内值改变不影响传入的变量本身
// 	changePoint(&i);//指针方式方法内值改变改变的就是值本身，地址一致
// 	system("pause");
// }

// 07 题目：写个方法对两个值进行交换 
// void change(int* a,int* b){ 
// 	int temp = *a;
// 	*a = *b;// a的值 = b 的值 
// 	*b = temp;
// }
// int main(){
// 	int a = 100;
// 	int b = 200;
// // 1 两个值进行交换 
// 	// change(&a,&b);
// 	// printf("就交换后ab的值分别是：%d,%d",a,b);
// // 2 面试题：对 a,b 两个值进行交换，但是不开辟额外的内存（不能用中间变量） 
// 	a = a + b;// a = 300 
// 	b = a - b;// b = 100 
// 	a = a - b;// a = 200 
// 	printf("就交换后ab的值分别是：%d,%d",a,b);
// 	system("pause");
// }

//08 指针地址改变
// int main(){
// 	int a = 100;
// 	int b = 200;
// 	// a = b 把b变量的值复制给a
// 	printf("a,b的地址分别是：%p,%p\n",&a,&b);
// 	//p1=a的地址,p2=b的地址
// 	int* p1 = &a;
// 	int* p2 = &b;
// 	printf("p1,p2的地址分别是：%p,%p\n", p1, p2);//打印指针不能加&号不然变成int **了
// 	p1 = p2;// 只是p1 的地址改了，并没有改动 a 的地址
// 	printf("a,b的值分别是：%d,%d\n", a, b);
// 	printf("p1,p2的值分别是：%d,%d\n", *p1, *p2);//打印指针的值
// 	system("pause");
// }

// 09 二级指针和多级指针
// int main(){
// 	int num = 12;
// 	// int* 指针  & 取地址
// 	int* p = &num;
// 	int** s_p = &p;// 对一级指针取地址
// 	printf("num 的地址是：%p\n",&num);//0023fe40
// 	printf("p 的地址是：%p\n",p);//0023fe40
// 	printf("s_p 的地址是：%p\n",s_p);//0061FE08
// 	printf("s_p 的地址是：%p\n",*s_p);//0023fe40,二级指针取地址
// 	printf("s_p 的地址是：%p\n",**s_p);//0000000C
// 	printf("获取最终的值是：%d", **s_p);//12，二级指针取值
// 	system("pause");
// } 

// 10 数组与数组指针 
// int main(){
// 	int arr[] = {1,2,3,4};
// 	// 遍历数组, linux 就有问题
// 	for (int i = 0; i < 4;i++){
// 		printf("%d\n",arr[i]);
// 	}
// 	// for循环在 c 和 C++ 中的正确写法
// 	int i = 0;
// 	for (; i < 4; i++){
// 		printf("%d\n", arr[i]);
// 	}
// 	// 看一种现象: arr 地址的值 = arr[0]的地址的值（首地址）
// 	printf("arr& = %p\n", &arr);//000000000061FE00
// 	printf("arr[0]& = %p\n", &arr[0]);//000000000061FE00
// 	printf("arr[1]& = %p\n", &arr[1]);//000000000061FE04
		
// 	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

// 	system("pause");
// }

//11 采用指针遍历数组循环赋值
// int main(){
// 	int arr[] = {1,2,3,4};
// 	int* arr_p = arr;
// 	int i = 0;
// 	for (; i < 4;i++){
// 		printf("位置%d的值是：%d\n", i, *(arr_p+i));
// 	}
// 	system("pause");
// }
// int main(){
// 	int arr[4];// 指定数组[4]
// 	int* arr_p = arr;
// 	int i = 0;
// 	for (; i < 4; i++){
// 		*(arr_p + i) = i;
// 	}
// 	i = 0;
// 	for (; i < 4; i++){
// 		printf("位置%d的值是：%d\n", i, arr[i]);
// 	}
// 	system("pause");
// }

// 12 指针为什么要有类型? 指针其实就是一块地址而且他的值都差不多
// int main(){
// 	//原因是取值的时候我要知道怎么取，按4字节取，还是8字节或16字节去取，不同字节取出的值不一样；
// 	int num = 12;
// 	int* num_p = &num;
// 	printf("num_p=%d\n",*num_p);//12
// 	double* num_p_d = num_p;
// 	printf("num_p=%d\n",*num_p);//12
// 	system("pause");
// }

// 13函数指针
// void add(int num1,int num2){
// 	printf("num1 + num2 = %d\n",(num1+num2));
// }
// void mins(int num1, int num2){
// 	printf("num1 - num2 = %d\n", (num1 - num2));
// }
// // 方法指针，传两个数 
// void opreate(void(method)(int,int),int num1,int num2){
// 	method(num1, num2);
// }
// int main(){
// 	// add(1,2);
// 	// 方法指针怎么定义？方法的返回(*方法的名称)(方法的参数)
// 	opreate(add, 1, 2);
// 	opreate(mins, 1, 2);
// 	system("pause");
// }

// 14 监听数据压缩回调
// void call_back(int current,int total){
// 	printf("压缩的进度是：%d/%d",current,total);
// }
// void compress(char* file_name,void(*callback)(int,int)){
// 	callback(12,24);
// }

// int main(){
// 	void(*call)(int, int);// 声明了一个函数
// 	call = call_back;// 给函数指针赋值
// 	// call(1,2);// 通过函数指针间接的调用call_back
// 	compress("1.png", call);
// 	system("pause");
// }

// day08 
// 15 生成随机数

// int main(){
// 	// 可以随机但是每次运行，随机数都一致，解决的方式就是初始化发生器
// 	// 初始化随机发生器, 每次发生器都是当前时间，啰嗦，实用场景，在 C 层生成秘钥（安全）
// 	srand((unsigned)time(NULL));//初始化发生器
// 	int i;
// 	for (i = 0; i<10; i++)
// 		printf("%d\n", rand() % 100);
// 	system("pause");
// }
       
//16 静态内存开辟
// void staticlloc(){
// 	int arr[5];// 静态开辟，静态开辟内存内存大小无法更改，使用后自动回收
// 	int i = 0;
// 	for (; i < 5; i++)
// 	{
// 		arr[i] = i;
// 		printf("%d, %p\n", *(arr + i), arr + i);
// 	}
// }

// int main(){
// 	// Stack overflow 栈溢出 如何判断一块内存中有没有写入数据，判 NULL？，判越界
// 	// int arr[10*1024*1024];// 占用内存是多少？ 大小？10M数组大小， int占用4字节，40M空间

// 	// c 有分区，四驱模型，栈，堆
// 	// 栈：占用内存空间最大值 2M ，开辟内存的方式是静态内存开辟 int arr[10*1024*1024]，方法结束会自动回收
// 	// 堆：占用内存空间最大值 80% ，开辟内存的方式是动态内存开辟 ，不会自动回收必须手动回收（内存不再使用的时候一定要手动回收）
//        while (true)
// 	{
// 		Sleep(500);
// 		staticlloc();
// 	}
// 	system("pause");
// }

//17 动态内存开辟
// void dynamiclloc(){//malloc动态开辟内存
// 	int* arr = (int*)malloc(1 * 1024 * 1024 * sizeof(int)); // 40M
// 	// 第二个重要的方法，手动释放 free , 释放arr这一块内存
// 	free(arr);
// }

// int main(){
// 	// int arr[10 * 1024 * 1024];
// 	// 操作
// 	while (true)
// 	{
// 		Sleep(100);
// 		dynamiclloc();
// 	}

// 	system("pause");
// }

// 18 改变内存空间大小，新开辟的内存地址会复制旧的内存地址内的东西并释放旧的内存地址；
// int main(){
// 	int num;
// 	printf("请输入数的个数：");
// 	// 获取用户输入的值
// 	scanf("%d", &num);
// 	// 5 个值
// 	int* arr = (int*)malloc(sizeof(int)*num);
// 	int i = 0;
// 	int print_num;
// 	for (; i < num; i++){
// 		arr[i] = i;// arr[i] = *(arr+i)
// 	}
// 	printf("开辟内存的指针：%p\n",arr);
// 	// 再加点内存
// 	printf("请输入新增的个数：");
// 	// 获取用户输入的值
// 	int new_num;
// 	scanf("%d", &new_num);// 5 
// 	// 原来那块内存的指针，总的大小（原来的大小+新的大小）
// 	int* new_arr = (int*)realloc(arr, sizeof(int)*(num+new_num));

// 	if (new_arr){// = if(new_arr != NULL)
// 	i = new_num;
// 	for (; i < (num + new_num); i++){
// 		arr[i] = i;// arr[i] = *(arr+i)
// 	}

// 	printf("新开辟内存的指针：%p\n", new_arr);

// 	// 打印数组
// 	i = 0;
// 	for (; i < num + new_num; i++){
// 		printf("%d, %p\n", *(arr + i), arr + i);
// 	}

// 	}
// 	if (new_arr){
// 		// 如果成功了，只要释放新的地址就行
// 		free(new_arr);
// 		new_arr = NULL;
// 	}
// 	else{
// 		// 如果没有成功，释放原来的内存
// 		free(arr);
// 	}

// 	// 不要反复去释放,那块地址一旦被释放，就有可能会被新的应用占用，不要去再次释放
// 	// free(new_arr);
// 	system("pause");
// }

//day09
// 19 字符串定义
// int main(){
// 	// 第一种 字符串数组
// 	char str[] = {'D','a','r','r','e','n','\0'};
// 	str[2] = 'y';
// 	printf("%s\n",str);// 字符串结尾是 '\0'
// 	// 第二种
// 	char *str1 = (char*)"Darren";
// 	str1[2] = 'y';//不能修改会报错
// 	printf("%s", str1);
// 	// 区别，一个能修改一个不能修改
// 	system("pause");
// }

// 20字符串长度获取
// int strlen_(char *str){
// 	// 怎么获取字符串的长度？ 不断读取字符，判断末尾 '\0'
// 	int len = 0;
// 	while (*str != '\0')
// 	{
// 		len++;
// 		str++;
// 	}
// 	return len;
// }
// int main(){
// 	char *name = "Darren is";
// 	char str[] = { 'D', 'a', 'r', 'r', 'e', 'n', '\0','i','s' };
// 	// 怎么获取长度？有一种方式计算（不好使）
// 	// printf("length is %d",sizeof(str)/sizeof(char));
// 	printf("name length is %d\n", strlen(str));
// 	// 自己来写一个方法读取字符串的长度
// 	// strlen_(name);
// 	printf("name length is %d", strlen_(str));
// 	system("pause");
// }

//21 字符串的转换
// int main(){
// 	// char * num = "1"; -> int float double
// 	char *num_str = "12.0xxx";
// 	int number0 = atoi(num_str);// 如果不能转换就是 0 ，后面如果有其他不是数字的就会被剔除 12xxx->12 , xx12->0
// 	printf("number0 is %d\n",number0);//12

// 	char *num_str1 ="12.5f";
// 	float number1 = atof(num_str1);// 如果不能转换返回的是默认值 0.000000 
// 	printf("number1 is %lf\n",number1);//12.500000

// 	char *num_str2 = "12.5xx";
// 	double number2 = strtod(num_str2, NULL);
// 	printf("number2 is %lf",number2);//12.500000
// 	system("pause");
// }

// 22字符串的比较
// int main(){
// 	char* str1 = "Darren";
// 	char* str2 = "darren";
// 	// 大于小于等于 
// 	int rc = strcmp(str1, str2);// 区分大小写比较
// 	printf("rc=%d\n",rc);//-1，=0相等

// 	int rc1 = _strcmpi(str1, str2);//不区分大小写比较
// 	printf("rc1=%d\n",rc1);//0
// 	// 比较前几个
// 	char* str3 = "Darren";
// 	char* str4 = "Darren is";
// 	int rc2 = strncmp(str3, str4,7);// count 代表的是比较字符串前几个是否相等
// 	int rc3 = _strnicmp(str3, str4, 6);
// 	printf("rc2=%d\n",rc2);//0
// 	printf("rc3=%d\n",rc3);//0
// 	// if (rc == 0){
// 	// 	printf("相等");
// 	// }
// 	// else{
// 	// 	printf("不相等");
// 	// }
// 	system("pause");
// }

// 23 字符串查找，包含
// int main(){
// 	char* str = "name is Darren";
// 	char *substr = "is";
// 	char* pos = strstr(str, substr);// 返回的是字符串第一次出现的位置（位置指针）, 如果没有找到返回的是空
// 	// 求一下位置 int 怎么办？ strstr 
// 	int postion = pos - str;
// 	printf("第一次出现的位置是：%d\n",postion);
// 	// 包含？pos 是不是空就可以了
// 	if (pos){
// 		printf("%s", "包含");
// 	}
// 	else{
// 		printf("%s\n", "不包含");
// 	}
// 	system("pause");
// }

// 24拼接，截取，大小写转换
// int main(){
// 	// strcpy(); copy进来
// 	char* str = "darren";
// 	char *str1 = " is";
// 	int len = strlen(str);// cpy[len] android studio 是可以的
// 	printf("len:%d\n",len);//6
// 	char cpy[len];
// 	// str 会 copy 到 cpy 里面
// 	strcpy(cpy, str);
// 	printf("%s\n",cpy);//darren
// 	// 拼接
// 	strcat(cpy,str1);
// 	printf("%s", cpy);//darren is
// 	system("pause");
// }

// 25字符串的截取
// char * substr(char * str,int start,int end){
// 	// 开辟一个字符串去存储我们的数据，开辟多大计算
// 	// char sub[end-start];
// 	int len = end - start;
// 	char* sub = (char*)malloc(len*sizeof(char)+1);// 记得加上1 ，在 NDK 一般会采用静态的数组存储 char sub[len]
// 	// malloc 一定要 free 
// 	// 遍历赋值
// 	str += start;
// 	for (int i = 0; i < len; i++)
// 	{
// 		sub[i] = *str;
// 		str++;// 指针往后逻一位 
// 	}
// 	// 标记字符串结尾，否则 print 无法判断结尾
// 	sub[len] = '\0';
// 	printf("%p\n",sub);
// 	// free(sub);
// 	return sub;
// }

// int main(){
// 	char *str = "Darren is";
// 	// 截取第三个位置到第五个位置 3，5
// 	char *sub = substr(str,0,5);
// 	printf("%p\n", sub);
// 	printf("%s\n",sub);
// 	// 一定要 free ，因为你的 substr 有动态开辟内存，但是真正开发过程中并不会这么做，自己的方法尽量要自己处理好内存
// 	free(sub);
// 	system("pause");
// }


//26大小写转换
// dest 用来存放结果，大小自己指定,source 需要转换的字符串
// void lower(char* dest,char* source){
// 	while (*source != '\0'){
// 		// 拿当前字符
// 		char ch = *source;
// 		// 转完赋值给 dest
// 		*dest = tolower(ch);// a -> a A -> a
// 		// 接着指针 ++ ，遍历下一个
// 		source++;
// 		dest++;
// 	}
// 	// 标记字符串结尾
// 	*dest = '\0';
// }
// int main(){
// 	char* name = "daRRen";
// 	char dest[20];
// 	lower(dest,name);
// 	printf("%s",dest);
// 	system("pause");
// }

//day10
// 27.结构体的定义和使用
//第一种方式
// struct Worker{// 定义一个结构体，相当于 java 的 class
// 	char name[10];
// 	int age;
// 	double salary;
// };
//  第二种方式，可以直接取名字
// struct Worker{// 定义一个结构体，相当于 java 的 class
// 	char name[10];
// 	int age;
// 	double salary;
// }darren = {"Darren",23,1000}, jack;
// 第三种方式，结构体嵌套
// struct Work{
// 	char name[10];
// 	char grade[10];
// };
// struct Worker{// 定义一个结构体，相当于 java 的 class
// 	char name[10];
// 	int age;
// 	double salary;
// 	// 工作， name grade
// 	Work work;
// };
// 第四种方式，结构体嵌套
struct Worker{// 定义一个结构体，相当于 java 的 class
	char name[10];
	int age;
	double salary;

	struct Work{
		char name[10];
		char grade[10];
	}work;
	// 工作， name grade
	// Work work;
};
// int main(){
       //第一种方式
	// struct Worker worker;// 初始化 , 没有初始化的情况下，那么里面所有的属性都是没有初始值的
	// 赋值
	// worker.age = 24;
	// worker.name = "Darren";////没有初始化不能直接修改
	// strcpy_s(worker.name,"Jack");
       // worker.salary=1.1;
       // printf("name = %s, age = %d, salary = %lf", worker.name, worker.age, worker.salary);//name = Jack, age = 24, salary = 1.100000请
	//  第二种方式
       // printf("name = %s, age = %d, salary = %lf", darren.name, darren.age, darren.salary);//name = Darren, age = 23, salary = 1000.000000
       // jack.name = "Jack";//没有初始化不能直接修改
	// strcpy_s(jack.name, "Jack"); 
	// jack.age = 24;
       // jack.salary=2.2;
	// printf("name = %s, age = %d, salary = %lf", jack.name, jack.age, jack.salary);//name = Jack, age = 24, salary = 2.200000
	//  第三种方式
       // struct Worker worker = { "Darren", 23, 1000, {"Android","中级"} };// 嵌套的初始
       // printf("name = %s, grade = %s", worker.work.name, worker.work.grade);//name = Android, grade = 中级
       //  第四种方式
       // struct Worker worker = { "jeck", 20, 100, {"JAVA","中级"} };// 嵌套的初始
       // printf("name = %s, grade = %s", worker.work.name, worker.work.grade);//name = JAVA, grade = 中级
//        system("pause");
// }

// 28 结构体指针
// int main(){
// 	struct Worker worker = {"Darren",23};
// 	Worker* worker_p = &worker;
// 	// 通过结构体指针去操作数据
// 	// worker.age = 24;
// 	worker_p->age = 24;// 结构体操作的另外一种方式，一般这种比较常用
// 	strcpy_s(worker_p->name,"Jack");
// 	printf("name = %s, age = %d", worker_p->name, worker_p->age);
// 	system("pause");
// }

// 29 动态内存开辟
// struct Worker{// 定义一个结构体，相当于 java 的 class
// 	char name[10];
// 	int age;
// 	double salary;
// };
// int main(){
// 	// Worker* worker;// 创建了一个结构体指针 , 不能直接使用,因为没有初始化
// 	Worker* worker = (Worker*)malloc(sizeof(Worker));
// 	worker->age = 24;
// 	strcpy_s(worker->name, "Jack");
// 	printf("name = %s, age = %d", worker->name, worker->age);
// 	// 释放
// 	if (worker){
// 		free(worker);
// 		worker = NULL;
// 	}
// 	system("pause");
// }

// 30 结构体的数组
// struct Worker{// 定义一个结构体，相当于 java 的 class
// 	char name[10];
// 	int age;
// 	double salary;
// };
// int main(){
// 	// 动态内存开辟
// 	// Worker worker[10] = { {"Darren",23,1000},{},{},{},{} };// 创建了 10 个 ，静态开辟
// 	// worker[9] = {"Darren9",24,200};
// 	// printf("name = %s, age = %d\n", worker[9].name, worker[9].age);

// 	// 动态内存开辟 Worker* 结构体的指针
// 	Worker* worker = (Worker*)malloc(sizeof(Worker)*10);
// 	strcpy_s(worker->name,"Darren0");
// 	worker->age = 10;
// 	// 对第十个数据进行操作？
// 	worker += 9;
// 	strcpy_s(worker->name, "Darren9");
// 	worker->age = 9;
// 	printf("name = %s, age = %d", worker->name, worker->age);
// 	system("pause");
// }

// 31 结构体大小计算（字节对齐）
// struct Worker{// 定义一个结构体，相当于 java 的 class
// 	char name[18]; // 10 
// 	int age; // 4
// 	double salary;// 8
// };

// int main(){
// 	int size = sizeof(Worker);// 16 字节
// 	// 计算的规则：
// 	// 1. 按照最大的字节去计算 
// 	// 2. 算得时候只会按照基本数据类型去算
// 	// 3. 首先会把所有字节数加起来，是否能够整除最大属性的字节数，如果不够为网上累加，一直加到能整除位置
// 	printf("size = %d", size);
// 	system("pause");
// }

// 32结构体大小计算（字节对齐）
// struct date{ // 12
// 	int year;
// 	int month;
// 	int day;
// };
// struct student{
// 	int number;// 4
// 	char sex;// 1
// 	int age;// 4
// 	char name[10];// 10 
// 	struct date birthday;// 12
// 	// 31%4  
// };

// int main(){
// 	int size = sizeof(student);// 36 字节
// 	// 计算的规则：
// 	// 1. 按照最大的字节去计算 
// 	// 2. 算得时候只会按照基本数据类型去算
// 	// 3. 首先会把所有字节数加起来，是否能够整除最大属性的字节数，如果不够为网上累加，一直加到能整除位置
// 	// 4. 进阶，留一个思考
// 	printf("size = %d", size);
// 	system("pause");
// }


//33 结构体和结构体指针取别名
// struct Worker_{// 定义一个结构体，相当于 java 的 class
// 	char name[10];
// 	int age;
// 	double salary;
// };
// typedef Worker_ Worker_;
// // 对结构体的指针取别名
// typedef Worker_* Worker;
// int main(){
// 	Worker worker = (Worker_*)malloc(sizeof(Worker_));
// 	printf("%s,%d,%lf",worker->name,worker->age,worker->salary);
// 	system("pause");
// }

//34 联合体
// union Person{
// 	// 最能出现一个 ，不用累加，找最大值 10，12字节
//  	//联合体大小计算 （不用累加，取的最大值，最终是否够基本数据类型整除）
// 	char name[10]; // 10 
// 	int age; // 4 
// 	double salary;// 8
// };
// // 联合体的定义和使用，联合体只能存在一个，要么是 age ，要么是 name 
// int main(){
// 	Person person = {"Darren"};
// 	// Person person;
// 	// strcpy_s(person.name,"Darren");
// 	// person.age = 24;
// 	// printf("name = %s,age = %d",person.name,person.age);
// 	printf("%d", sizeof(Person));
// 	system("pause");
// }

// 35 枚举的定义和使用 枚举有点类似于 int
// enum CommentType
// {
// 	TEXT = 10,TEXT_IMAGE,IMAGE
// };
// int main(){
// 	CommentType commentType = TEXT;
// 	CommentType commentType1 = TEXT_IMAGE;
// 	CommentType commentType2 = IMAGE;
// 	printf("%d,%d,%d", commentType, commentType1, commentType2);
// 	system("pause");
// }

//day11 
// 36文件读取
// int main(){
// 	// 打开文件 （文件名，模式）mode r(读) w(写) rb(作为二进制读) wb(作为二进制写)
// 	// FILE *fopen( const char *filename, const char *mode );
// 	char* fileName = "C:\\Users\\11046\\OneDrive\\桌面\\test.txt";
// 	FILE *file = fopen(fileName, "r");
// 	if (!file){
// 		printf("文件打开失败");
// 		exit(0);// 退出程序
// 	}
// 	char buffer[10];
// 	// 缓冲区buffer，长度10 ，文件指针
// 	while (fgets(buffer, 10, file)){
// 		printf("%s",buffer);
// 	}
// 	// 关闭文件
// 	fclose(file);
// 	system("pause");
// }

// 37文件写入
// int main(){
// 	char* fileName = "C:\\Users\\11046\\OneDrive\\桌面\\test.txt";
// 	FILE *file = fopen(fileName, "w");
// 	if (!file){
// 		printf("文件打开失败");
// 		exit(0);// 退出程序
// 	}
// 	fputs("I am tyl",file);
// 	// 关闭文件
// 	fclose(file);
// 	system("pause");
// }

//38 文件复制，当做二进制文件来操作
// int main(){
// 	char* fileName = "C:\\Users\\hcDarren\\Desktop\\android\\NDK\\image.jpg";
// 	char* fileCopyName = "C:\\Users\\hcDarren\\Desktop\\android\\NDK\\image_copy.jpg";
// 	FILE *file = fopen(fileName, "rb");// 流指针
// 	FILE *file_copy = fopen(fileCopyName, "wb");// 新建一个文件 0kb 
// 	if (!file || !file_copy){
// 		printf("文件打开失败");
// 		exit(0);// 退出程序
// 	}
// 	// size_t fread(void          *buffer, size_t size, size_t count, FILE          *stream);
// 	int buffer[512];// 2048 = 4*514
// 	int len;
// 	printf("%d",sizeof buffer);
// 	while ((len = fread(buffer, sizeof(int), 512, file))!=0){
// 		fwrite(buffer, sizeof(int), len, file_copy);
// 	}
// 	fclose(file);
// 	fclose(file_copy);
// 	system("pause");
// }

//39 获取文件的大小
// int main(){
// 	char* fileName = "C:\\Users\\hcDarren\\Desktop\\android\\NDK\\image.jpg";
// 	FILE *file = fopen(fileName, "rb");// 流指针
// 	if (!file){
// 		printf("文件打开失败");
// 		exit(0);// 退出程序
// 	}
// 	// 没有一个函数是可以直接拿文件大小
// 	// 思路：将文件的指针移动到最后，然后再去计算偏移量
// 	// 三个参数  SEEK_SET（开头）, SEEK_CUR（当前）, SEEK_END（移动到最后）
// 	fseek(file, 0, SEEK_END);
// 	// 计算偏移的位置,ftell 从 0 开始统计到当前（SEEK_END）
// 	long file_size = ftell(file);
// 	printf("文件大小：%ld",file_size);
// 	fclose(file);
// 	system("pause");
// }

// 40文件加密
// 图片服务器（使用第三方的），为了防止图片泄密，图片进行加密
// int main(){
// 	char* fileName = "C:\\Users\\hcDarren\\Desktop\\android\\NDK\\image.jpg";
// 	char* fileEncrpyName = "C:\\Users\\hcDarren\\Desktop\\android\\NDK\\image_en.jpg";
// 	FILE *file = fopen(fileName, "rb");// 流指针
// 	FILE *file_encrpy = fopen(fileEncrpyName, "wb");// 新建一个文件 0kb 
// 	if (!file || !file_encrpy){
// 		printf("文件打开失败");
// 		exit(0);// 退出程序
// 	}
// 	// 破坏文件，还原
// 	// 思路：把每一个字节都拿出来，对每一个字节都处理，把某部分字节拿出来，进行处理
// 	// 10^5 异或  加密过程 
// 	//  1010  
// 	// ^0101
// 	//  1111  加密

// 	// 解密 同样的去异或 5 
// 	//  1111
// 	// ^0101
// 	//  1010    解密后 10
// 	int c;// EOF end of file
// 	while ((c = fgetc(file))!=EOF){
// 		fputc(c ^ 5, file_encrpy);
// 	}
// 	system("pause");
// }

// 41文件的解密
// int main(){
// 	char* fileEnName = "C:\\Users\\hcDarren\\Desktop\\android\\NDK\\image_en.jpg";
// 	char* fileDeName = "C:\\Users\\hcDarren\\Desktop\\android\\NDK\\image_de.jpg";
// 	FILE *file = fopen(fileEnName, "rb");// 流指针
// 	FILE *file_decrpy = fopen(fileDeName, "wb");// 新建一个文件 0kb 
// 	if (!file || !file_decrpy){
// 		printf("文件打开失败");
// 		exit(0);// 退出程序
// 	}
// 	// 思路：把每一个字节都拿出来，对每一个字节都处理，把某部分字节拿出来，进行处理
// 	// 10^5 异或  加密过程
// 	//  1010  
// 	// ^0101
// 	//  1111  加密
// 	// 解密 同样的去异或 5 
// 	//  1111
// 	// ^0101
// 	//  1010    解密后 10
// 	int c;// EOF end of file
// 	while ((c = fgetc(file)) != EOF){
// 		fputc(c ^ 5, file_decrpy);
// 	}
// 	system("pause");
// }

// 42 就改一个字节, 过不去
// int main(){
// 	char* fileEnName = "C:\\Users\\hcDarren\\Desktop\\android\\NDK\\image.jpg";
// 	// rwb 
// 	FILE *file = fopen(fileEnName, "wb"); // 流指针，创建文件? 有没有其他办法 支付宝人脸识别 Mat 矩阵
// 	// file 流的头指针
// 	fputc(5, file);
// 	fclose(file);
// 	system("pause");
// }

//43字符串密码进行加密
// int main(){
// 	char* fileName = "C:\\Users\\hcDarren\\Desktop\\android\\NDK\\image.jpg";
// 	char* fileEncrpyName = "C:\\Users\\hcDarren\\Desktop\\android\\NDK\\image_en.jpg";
// 	char* passWord = "123456";// 轮流进行^操作
// 	FILE *file = fopen(fileName, "rb");// 流指针
// 	FILE *file_encrpy = fopen(fileEncrpyName, "wb");// 新建一个文件 0kb 
// 	if (!file || !file_encrpy){
// 		printf("文件打开失败");
// 		exit(0);// 退出程序
// 	}
// 	int c;// EOF end of file
// 	int index = 0;
// 	int pass_len = strlen(passWord);
// 	while ((c = fgetc(file)) != EOF){
// 		fputc(c ^ passWord[index%pass_len], file_encrpy);
// 		index++;
// 	}
// 	system("pause");
// }

// 44字符串密码解密
// int main(){
// 	char* fileName = "C:\\Users\\hcDarren\\Desktop\\android\\NDK\\image_en.jpg";
// 	char* fileDeName = "C:\\Users\\hcDarren\\Desktop\\android\\NDK\\image_de.jpg";
// 	char* passWord = "123456";// 轮流进行^操作
// 	FILE *file = fopen(fileName, "rb");// 流指针
// 	FILE *file_decrpty = fopen(fileDeName, "wb");// 新建一个文件 0kb 
// 	if (!file || !file_decrpty){
// 		printf("文件打开失败");
// 		exit(0);// 退出程序
// 	}
// 	int c;// EOF end of file
// 	int index = 0;
// 	int pass_len = strlen(passWord);
// 	while ((c = fgetc(file)) != EOF){
// 		fputc(c ^ passWord[index%pass_len], file_decrpty);
// 		index++;
// 	}
// 	fclose(file);
// 	fclose(file_decrpty);
// 	system("pause");
// }

// 45 文件的切割，思路类似于断点下载
// int getFileSize(char* fileName){
// 	FILE* file = fopen(fileName,"rb");
// 	if (!file){
// 		return 0;
// 	}
// 	fseek(file,0,SEEK_END);
// 	int file_size = ftell(file);
// 	fclose(file);
// 	return file_size;
// }

// int main(){
// 	// 百度云 不大于4G的文件？ 8G 文件，扔进去
// 	// 大文件（断点续传）
// 	// 文件切割，把文件合作为一个思考
// 	// 计算每个文件需要写入多少？
// 	char* fileName = "C:\\Users\\hcDarren\\Desktop\\android\\NDK\\image.jpg";
// 	FILE* file = fopen(fileName,"rb");
// 	int file_size = getFileSize(fileName);
// 	// 定义 切多少，计算大小，指定文件名
// 	int file_number = 3;
// 	// 二维数组，char[] char*
// 	// image_0.jpg
// 	// image_1.jpg
// 	// image_2.jpg
// 	// char* file_name
// 	// char* 
// 	char** file_names = (char**)malloc(sizeof(char*)*file_number);
// 	int preFileSize = file_size / file_number;
// 	// 进行复制
// 	int i = 0;
// 	for (; i < 3; i++)
// 	{
// 		file_names[i] = (char*)malloc(sizeof(char)*100);// '\0'
// 		sprintf(file_names[i], "C:\\Users\\hcDarren\\Desktop\\android\\NDK\\image_%d.jpg", i);
// 		printf("%s\n", file_names[i]);
// 	}
// 	i = 0;
// 	for (; i < file_number; i++)
// 	{
// 		// 从源文件中往切割文件写入数据
// 		FILE* cur_file = fopen(file_names[i],"wb");
// 		// 写多少？
// 		int start = i*preFileSize;
// 		int end = (i + 1)*preFileSize;
// 		if (i == file_number - 1){
// 			end = file_size;
// 		}
// 		// 第一个循环 file 读，第二个循环还是从 file 里面
// 		for (int j = start; j < end; j++)
// 		{
// 			// 从file 里面读，写如到 cur_file
// 			fputc(fgetc(file),cur_file);
// 		}
// 		fclose(cur_file);
// 		free(file_names[i]);
// 	}
// 	fclose(file);
// 	free(file_names);
// 	system("pause");
// }

//day12
// p45-p53课开始jni的开发流程，没看懂，用的工具和自己用的不一样

//46 常量指针/指针常量
// 常量变量:被常量修饰的变量，不能再次被赋值 (Java )
// 常量指针:const 在*之前，指针的地址是可以被再次赋值的( 可以修改的)，指针地址上面的值(变量)是不能被修改，常量指针的常量是
		不能被改变的,
// 指针常量:const 在*之后，指针的地址是不可以被再次赋值的(不可以修改的)，指针地址上面的值(变量)能被修改的，指针常量的指针地
		址是不能被改变的。
//const在谁前面谁就不能修改；
//int main(){
//	// 常量，不能去修改
//	const int number = 100;
//	// number = 200;
//	int number1 = 100;
//	int number2 = 200;
//	// 常量指针
//	// int const * n_p = &number2;
//	// n_p = &number1;
//	// printf("n_p = %p",n_p); // 地址是可以重新被赋值的
//	// *n_p = 300; 值是不能改的
//
//	// 指针常量
//	int * const n_p = &number2;
//	// n_p = &number1; 地址是不能被重新赋值
//	*n_p = 300;
//	printf("number2 = %d", number2);
//	system("pause");
//}

//p54-p57面试题没看懂，太啰嗦
//day14