Android JNI 编程 – C语言基础知识 (二)-六虎

C言语中的类型体系

结构体

// 声明一个结构体
struct Person{
  char *name;
  int age;
  char *id;
};
// 声明一个结构体变量
struct Person person={
  .name="hello",.age=10,.id="123"
};
// 声明一个结构体的指针
struct Person *p_person=&person;
PRINTFLINE("%d:",person.age);
// 结构体指针访问的 -> 操作符
PRINTFLINE("%s:",p_person->name);
// 每次都要struct Person 很麻烦 那直接界说一个 别名 就能够简化操作了
typedef struct Person Person;
PRINTFLINE("%lu:", sizeof(Person));

内存对齐

仍是前面的程序

咱们看下这个person的结构体究竟占用多少个byte，打印出来是24个byte

有人就觉得奇怪了，为啥？ 2个char 一共16个byte 一个int 4个byte 应该是 20个byte 才对啊，

多出来的4个byte 哪来的？

咱们看下内存快照，看一下这个person实践的存储

简略处理下这个问题

#pragma pack(2)

再试一下即可

联合体

union Operator{
  int a;
  double d;
};
union Operator op={.a=4,.d=1.0};
PRINTFLINE("%d %f",op.a,op.d);

看下执行成果

这个联合体别的言语应该是没有的，有个特点是他所占用的内存便是他内部字段最大的内存大小，

比如这儿占用的内存大小便是8，

此外由于是同享8个byte 内存大小，假如d有值，那么会覆盖掉a的区域，从而a的值就不是你设置的值了

这个特点以我浅薄的常识，java kotlin 是没有类似机制的

枚举

typedef enum FILE_IMAGE{
  PNG,JPEG,WEBP
}

枚举倒是和java 差异不大，本质上都是int值，上述的比如中便是 0 1 2 3个值

下面这个比如便是 0 5 6

typedef enum FILE_IMAGE{
  PNG,JPEG=5,WEBP
}

判别字节序

假定内存中有个4个字节别离存了4个值别离是 01 02 03 04，在内存中从左到右分布着这4个字节

关于cpu来说怎样读这4个字节就有意思了

0x04030201 这样便是小端序 (一般cpu都是小端读) 0x01020304 这样便是大端序（一般是网络传输用大端序）

既然环境是不一样的，那么有时分咱们需要来判别一下当时体系是大端仍是小端序

这个其实用union 来判别就很容易。咱们能够写个程序来验证一下

假定咱们要存一个值是 0x100 内存中的分布无非便是00 01 （小端）或者是 01 00（大端）

根据union 来表明一下

bool isSmallEndian() {
  union {
    char c[2];
    short s;
  } value = {.s=0x100};
  return value.c[0] == 0;
}

C言语中的字符串

这个末节个人觉得有个形象就能够了，需要用的时分直接谷歌搜一下api即可，没必要花时间去记（字符串比较，字符串查找，字符串拆分，字符串的衔接，字符串的仿制）

怎么判别一个字符是数字仍是字母

标准库都有现成的，有爱好的能够看下实现，这儿不多说了

#include <stdio.h>
#include <ioprint.h>
#include <ctype.h>
int main(){
  PRINTFLINE("%d:",isdigit('1'));
  return 0;
}

唯一要留意的是这儿面假如回来值是0 代表不是，>0 就代表是， 可是不一定是1

办法挺多的：

包括一些转化类的函数：

字符串的转化

c言语中转化主要是两种方法 atoX 简略场景用这个足够了 strtoX 更安全，功用更强大

stdlib.h 下：

字符串长度

strlen

字符串拆分

这儿有经验的老司机必定能猜到这个strtok 这个函数的写法，在多线程环境下必定是不安全的

#include <stdio.h>
#include <stdlib.h>
#include <ioprint.h>
#include <ctype.h>
#include <string.h>
int main() {
  char string[] = "c,1972;c++,1983;java,1995;Rust,2010;Kotlin,2011";
  typedef struct {
    char *name;
    int year;
  } Language;
  const char *language_break = ";";
  const char *fieled_break = ",";
  int language_cap = 3;
  int language_size = 0;
  // 动态请求一块内存，由于不知道输入的字符串究竟有多长 天然也不知道这个结构体会有几个，索性先动态请求一块
  // 长度为3 size的 内存
  Language *languages = malloc(sizeof(Language) * language_cap);
  // 假如检索不到 则回来null 不然回来检索到的第一个字符串
  char *next = strtok(string, fieled_break);
  while (next) {
    Language language;
    language.name = next;
//    strtok函数的第一个参数是要切割的字符串，第二个参数是用于指定分隔符的字符串。在第一次调用strtok时，
//    咱们需要即将切割的字符串作为第一个参数传递给它。之后，咱们能够在后续调用中将第一个参数设置为NULL，
//    以表明继续运用上一次调用回来的状况来切割同一字符串
    next = strtok(NULL, language_break);
    if (next) {
      language.year = atoi(next);
      // 判别是否要扩大内存
      if (language_size + 1 >= language_cap) {
        language_cap *= 2;
        languages = realloc(languages, language_cap);
      }
      languages[language_size++] = language;
      next = strtok(NULL, fieled_break);
    }
  }
  PRINTFLINE("langeuages :%d",language_size);
  int i;
  for (i = 0; i < language_size; ++i) {
    PRINTFLINE("name=%s,year=%d",languages[i].name,languages[i].year);
  }
  free(languages);
  return 0;
}

常见的内存操作函数

mem最初的部分函数 str最初的都有

差异便是 mem最初的这几个函数多了一个size函数，原因很简略 mem不知道你要操作啥类型天然不知道究竟要多少size了，而str清晰知道你是字符串知道你最后是null结尾， mem最初的并不知道这些

还记得前面一个章节说的请求一个数组的时分要做初始化嘛，现在memset更加便利做初始化了

int main() {
  char *mem = malloc(10);
  memset(mem,0,10);
  PRINT_INT_ARRAY(mem ,10);
  free(mem);
  return 0;
}

在 C 言语中，memmove() 和 memcpy() 都用于在内存中移动一段数据。它们的功用类似，但有一些差异。

memmove() 函数能够在堆叠的内存区域中移动数据，而 memcpy() 函数则不能。假如源和意图内存区域堆叠，而且需要在堆叠的内存区域中移动数据，就必须运用 memmove() 函数，不然可能会发生不行猜测的成果。

#include <stdio.h>
#include <stdlib.h>
#include <ioprint.h>
#include <ctype.h>
#include <string.h>
int main() {
  char src[] = "helloworld";
  char *dest = malloc(11);
  memset(dest, 0, 11);
  memcpy(dest, src, 11);
  puts(dest);
  memmove(dest + 3, dest + 1, 4);
  puts(dest);
  return 0;
}

宽字符串和窄字符串

总结一下： 假如你要处理的字符串是用数字+英文，那么窄字符串就能够，假如包括中文那就宽字符串

窄字符字符串运用的是 ASCII 或 ANSI 字符集，而且每个字符只占用一个字节（8 位）。它们一般运用 char 类型表明。

宽字符字符串运用的是 Unicode 字符集，而且每个字符占用两个字节（16 位）。它们一般运用 wchar_t 类型表明。

当需要处理一些特殊字符集（如中文、日文、韩文等）时，宽字符字符串一般更加便利和实用。

// 宽字符字符串的界说
wchar_t* wstr = L"Hello, world!";
// 窄字符字符串的界说
char* str = "Hello, world!";

文件的输入输出

clion中作业区的概念

随便翻开一个文件吧，看看基本操作

#include <stdio.h>
int main() {
  FILE *file = fopen("CMakeLists.txt", "r");
  if (file) {
    puts("open file success");
    fclose(file);
  } else {
    perror("fopen txt");
  }
  return 0;
}

到这儿的时分运转大概率是要报错的

由于你编译成功今后的可执行文件的途径是在这儿

而你fopen传递的是一个相对途径，所以必然会报错了，

简略的修正办法便是修正一下clion的作业区装备即可

让他默许在这个途径下作业即可

文件流的缓冲

#include <stdio.h>
int main() {
  FILE *file = fopen("CMakeLists.txt", "r");
  // 缓冲区的内存 生命周期要和文件流保持一致
  char buf[8192];
  if (file) {
    setvbuf(file, buf, _IOLBF, 8192);
    puts("open file success");
    fclose(file);
  } else {
    perror("fopen txt");
  }
  return 0;
}

这儿的3个宏稍微解释一下， FBF一般是读二进制文件用的，LBF 读文本文件用的， NBF 就不解释了

读取文件内容


#include <stdio.h>
int main() {
  FILE *file = fopen("CMakeLists.txt", "r");
  // 缓冲区的内存 生命周期要和文件流保持一致
  char buf[8192];
  if (file) {
    puts("open file success");
    setvbuf(file, buf, _IOLBF, 8192);
    // 读文件 留意getc回来的是int类型 绝对不是char
    int next_char = getc(file);
    while (next_char != EOF) {
      putchar(next_char);
      next_char = getc(file);
    }
    fclose(file);
  } else {
    perror("fopen txt");
  }
  return 0;
}

仿制文件的多种实现方法

第一种写法（功率低，可是能够仿制二进制文件）：

//
// Created by 吴越 on 2023/2/28.
//
#include <stdio.h>
#include "ioprint.h"
#define COPY_ILLEGAL_ARGUMENTS (-1) // 参数过错
#define COPY_SRC_OPEN_ERROR (-2) // 源文件翻开失利
#define COPY_DEST_OPEN_ERRPR (-3) // 方针文件翻开失利
#define COPY_SRC_READ_ERROR (-4) // 源文件读取失利
#define COPY_DEST_WRITE_ERROR (-6) // 方针文件写入过错
#define COPY_UNKNOWN_ERROR (-5) // 不知道过错
#define COPY_SUCCESS (1) // 拷贝成功
int CopyFile(char const *src, char const *dest) {
  if (!src || !dest) {
    return COPY_ILLEGAL_ARGUMENTS;
  }
  FILE *src_file = fopen(src, "r");
  if (!src_file) {
    return COPY_SRC_OPEN_ERROR;
  }
  FILE *dest_file = fopen(dest, "w");
  if (!dest_file) {
    // 不要忘掉把源文件给关闭掉
    fclose(src_file);
    return COPY_DEST_OPEN_ERRPR;
  }
  int result;
  while (1) {
    // 一次读一个文字 其实功率很低
    int next = fgetc(src_file);
    if (next == EOF) {
      // 留意读取文件中 各种过错的判别
      if (ferror(src_file)) {
        result = COPY_SRC_READ_ERROR;
      } else if (feof(src_file)) {
        result = COPY_SUCCESS;
      } else {
        result = COPY_UNKNOWN_ERROR;
      }
      break;
    }
    if (fputc(next, dest_file) == EOF) {
      // 写入文件的过错 判别就很简略
      result = COPY_DEST_WRITE_ERROR;
      break;
    }
  }
  fclose(src_file);
  fclose(dest_file);
  return result;
}
int main() {
  int result = CopyFile("file/test.jpeg","file/test2.jpeg");
  int result2= CopyFile("file/1.txt","file/2.txt");
  PRINTFLINE("result: %d,result2 :%d",result,result2);
}

第二种写法，虽然加了缓存，读写功率更高，可是无法仿制二进制文件，只能仿制文本文件由于fgets fputs 都是按行读写，二进制文件里边是没有行这个概念的，这儿一定要谨记哟

#define  BUFFER_SIZE 512
int CopyFile2(char const *src, char const *dest) {
  if (!src || !dest) {
    return COPY_ILLEGAL_ARGUMENTS;
  }
  FILE *src_file = fopen(src, "r");
  if (!src_file) {
    return COPY_SRC_OPEN_ERROR;
  }
  FILE *dest_file = fopen(dest, "w");
  if (!dest_file) {
    // 不要忘掉把源文件给关闭掉
    fclose(src_file);
    return COPY_DEST_OPEN_ERRPR;
  }
  int result = COPY_SUCCESS;
  char buffer[BUFFER_SIZE];
  char *next;
  while (1) {
    next = fgets(buffer, BUFFER_SIZE, src_file);
    if (!next) {
      if (ferror(src_file)) {
        result = COPY_SRC_READ_ERROR;
      } else if (feof(src_file)) {
        result = COPY_SUCCESS;
      } else {
        result = COPY_UNKNOWN_ERROR;
      }
      break;
    }
    if (fputs(next, dest_file) == EOF) {
      result = COPY_DEST_WRITE_ERROR;
      break;
    }
  }
  fclose(src_file);
  fclose(dest_file);
  return result;
}

终极版别（直接二进制读写）


int CopyFile3(char const *src, char const *dest) {
  if (!src || !dest) {
    return COPY_ILLEGAL_ARGUMENTS;
  }
  // windows体系一定要 加b后缀 linux和mac 无所谓
  FILE *src_file = fopen(src, "rb");
  if (!src_file) {
    return COPY_SRC_OPEN_ERROR;
  }
  FILE *dest_file = fopen(dest, "wb");
  if (!dest_file) {
    // 不要忘掉把源文件给关闭掉
    fclose(src_file);
    return COPY_DEST_OPEN_ERRPR;
  }
  int result = COPY_SUCCESS;
  char buffer[BUFFER_SIZE];
  while (1) {
    size_t bytes_read = fread(buffer, sizeof(buffer[0]), BUFFER_SIZE, src_file);
    // 这儿读多少字节 就要写多少字节，写的少了那就必定过错了
    if (fwrite(buffer, sizeof(buffer[0]), bytes_read, dest_file) < bytes_read) {
      result = COPY_DEST_WRITE_ERROR;
      break;
    }
    if (bytes_read < BUFFER_SIZE) {
      if (ferror(src_file)) {
        result = COPY_SRC_READ_ERROR;
      } else if (feof(src_file)) {
        result = COPY_SUCCESS;
      } else {
        result = COPY_UNKNOWN_ERROR;
      }
      break;
    }
  }
  fclose(src_file);
  fclose(dest_file);
  return result;
}

序列化与反序列化

先推荐装一个插件，比较容易看二进制

#include <stdio.h>
#include <stdlib.h>
#include <ioprint.h>
#include <string.h>
#include <wchar.h>
#define ERROR 0
#define OK 1
typedef struct {
  int visibility;
  int allow;
  int rate;
  int font_size;
} Settings;
int SaveSettings(Settings *settings, char *settings_file) {
  FILE *file = fopen(settings_file, "wb");
  if (file) {
    // 二进制写文件了， 
    fwrite(&settings->visibility, sizeof(settings->visibility), 1, file);
    fwrite(&settings->allow, sizeof(settings->allow), 1, file);
    fwrite(&settings->rate, sizeof(settings->rate), 1, file);
    fwrite(&settings->font_size, sizeof(settings->font_size), 1, file);
    fclose(file);
    PRINTFLINE("save success");
    return OK;
  } else {
    perror("fuck Failed to save settings");
    return ERROR;
  }
}
void LoadSettings(Settings *settings, char *settings_file) {
  FILE *file = fopen(settings_file, "r");
  if (file) {
    fread(&settings->visibility, sizeof(settings->visibility), 1, file);
    fread(&settings->allow, sizeof(settings->allow), 1, file);
    fread(&settings->rate, sizeof(settings->rate), 1, file);
    fread(&settings->font_size, sizeof(settings->font_size), 1, file);
    fclose(file);
  } else {
    perror("Failed to read settings");
    settings->visibility = -1;
    settings->allow = -1;
    settings->rate = -1;
    settings->font_size = -1;
  }
}
void PrintSettings(Settings *settings) {
  PRINTFLINE("visibility:%d , allow:%d, rate:%d,font_size:%d",
             settings->visibility, settings->allow, settings->rate, settings->font_size);
}
#define FILE_NAME "settings.bin"
int main() {
  Settings settings;
  LoadSettings(&settings, FILE_NAME);
  PrintSettings(&settings);
  settings.visibility = 5;
  settings.allow = 6;
  settings.rate = 7;
  settings.font_size = 8;
  SaveSettings(&settings, FILE_NAME);
  LoadSettings(&settings, FILE_NAME);
  PrintSettings(&settings);
  return 0;
}

然后看一下这个文件的16进制

Android JNI 编程 – C语言基础知识 (二)

C言语中的类型体系

结构体

内存对齐

联合体

枚举

判别字节序

C言语中的字符串

怎么判别一个字符是数字仍是字母

字符串的转化

字符串长度

字符串拆分

常见的内存操作函数

宽字符串和窄字符串

文件的输入输出

clion中作业区的概念

文件流的缓冲

读取文件内容

仿制文件的多种实现方法

序列化与反序列化

作者信息

推广

Android JNI 编程 – C语言基础知识 (二)

C言语中的类型体系

结构体

内存对齐

联合体

枚举

判别字节序

C言语中的字符串

怎么判别一个字符是数字仍是字母

字符串的转化

字符串长度

字符串拆分

常见的内存操作函数

宽字符串和窄字符串

文件的输入输出

clion中作业区的概念

文件流的缓冲

读取文件内容

仿制文件的多种实现方法

序列化与反序列化

相关文章

搞懂登录流程，新手看这篇就够了

转转客户端持续交付—鲁班的构建管理

2023 Flutter Forward 大会回顾，快来看看 Flutter 的未来会有什么

Elasticsearch（ELK）集群环境部署

作者信息

推广