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

Android工程师为啥要学习c/c++呢？

首要仍是本身遇到瓶颈了吧，学习下c的常识，扩展下自己编写so的能力，不然许多框架的确也是看不明白，特别是涉及到跨端的组件，不明白点底层是真的难搞

爽性从头学一遍c的常识，顺便把开源库中喜欢用到的pthread，mmap，文件流等linux 操作也过一遍

基础环境建立

我是mac，大部分情况下下个clion 就能够直接写c言语了，可是考虑到Android 底层是linux，并不是mac的osx，所以理想情况下仍是期望咱们编写的c程序能直接跑在 linux上，

所以基础环境的建立便是根据docker 来建立一个linux ，然后让咱们的clion 直接远程到这个docker上即可

#
# Build and run:
#   docker build -t clion/centos7-cpp-env:0.1 -f Dockerfile.centos7-cpp-env .
#   docker run -d --cap-add sys_ptrace -p127.0.0.1:2222:22 clion/centos7-cpp-env:0.1
#   ssh-keygen -f "$HOME/.ssh/known_hosts" -R "[localhost]:2222"
#
# stop:
#   docker stop clion_remote_env
# 
# ssh credentials (test user):
#   user@password 
FROM centos:7
RUN sed -e 's|^mirrorlist=|#mirrorlist=|g' \
    -e 's|^#baseurl=http://mirror.centos.org|baseurl=https://mirrors.tuna.tsinghua.edu.cn|g' \
    -i.bak \
    /etc/yum.repos.d/CentOS-*.repo
RUN yum -y update \
    && yum -y install openssh-server \
    make \
    autoconf \
    automake \
    locales-all \
    dos2unix \
    ninja-build \
    build-essential \
    gcc \
    gcc-c++ \
    gdb \
    clang \
    cmake \
    rsync \
    tar \
    python \
    && yum clean all
RUN ssh-keygen -A
RUN ( \
    echo 'LogLevel DEBUG2'; \
    echo 'PermitRootLogin yes'; \
    echo 'PasswordAuthentication yes'; \
    echo 'Subsystem sftp /usr/libexec/openssh/sftp-server'; \
    ) > /etc/ssh/sshd_config_test_clion
RUN useradd -m user \
    && yes password | passwd user
CMD ["/usr/sbin/sshd", "-D", "-e", "-f", "/etc/ssh/sshd_config_test_clion"]

去clion 那儿设置一下 toolchians

然后再编译一下

再看下咱们引证的stdio 头文件，这儿能看出来引证的是 linux上的头文件了，有爱好的能够看下这个头文件linux的完成和 mac上的头文件完成有何不同

这儿有一点要注意，clion默认的cmake版别比较高，你要连centos7 ，默认的cmake版别低，会编译失败

这儿咱们只需设置一下版别号为centos的cmake 版别号就行了

别的便是假如一个project 下你有多个main函数入口需要额外设置一下cmake

cmake_minimum_required(VERSION 2.8.12.2)
project(cstudy C)
set(CMAKE_C_STANDARD 11)
#一个project 下面假如有多个main函数入口 需要设置多个add_executable()
add_executable(cstudy date_types.c)
add_executable(cstudy2 func_test.c)

说实话写多了java kotlin js 啥的，你会发现 cmake 这东西是真的蠢。。。。

函数的变长参数

#include <stdio.h>
#include <stdarg.h>
void HandleVarargs(int arg_count,...) {
  // 用于获取变长参数
  va_list args;
  // 开端遍历
  va_start(args, arg_count);
  int j;
  for ( j = 0; j < arg_count; ++j) {
    // 取出对应参数
    int arg = va_arg(args, int);
    printf("%d: %d \n", j, arg);
  }
  // 完毕遍历
  va_end(args);
}
int main() {
  HandleVarargs(4,1,2,5,6);
  return 0;
}

在c中写个变长参数的函数真的累。。。还要写这种模版代码

最坑的是，你在调用这个参数的时分，榜首个参数还有必要得是你参数的个数。。。

宏

头文件

这个include 其实便是一个宏，和你直接用define 其实便是相同的

本质上便是在你编译的时分把其他函数/变量直接导入过来，好让编译器知道你这儿应该怎么调用一个函数

就这么简略

自己写头文件

这个也挺麻烦的，其实便是当你想对外供给一个功用，做一个模块的时分就会用到这个东西，相比java 的无脑，c里边实在是太麻烦了

能够新建include和src 2个途径，一个放完成，一个放头文件

然后咱们新建一个头文件：

//
// Created by 吴越 on 2023/2/18.
//
#ifndef CSTUDY_INCLUDE_FAC_H_
#define CSTUDY_INCLUDE_FAC_H_
int sum(int x,int y);
#endif //CSTUDY_INCLUDE_FAC_H_

再新建一个对应的完成 .c 文件

//
// Created by 吴越 on 2023/2/18.
//
#include "../include/fac.h"
int sum(int x,int y){
  return x+y;
}

此刻不要忘掉cmake文件要改一下

add_executable(cstudy3 hong_test.c src/fac.c)

最终调用一下

#include <stdio.h>
#include "include/fac.h"
int main() {
  printf("sum: %d \n", sum(3, 5));
  return 0;
}

就这么简略！

<> 和 ““ 的差异

前面的代码能够看到咱们都是用的”” 来引证的头文件，那么有么有办法像引证系统头文件相同就用括号呢？其实也是的能够的，可是要去cmake 里边添加一行代码

include_directories("include")

这个技巧要把握一下，不然许多开源代码你会搞晕的，换句话说拿到开源的代码仍是先看一下 cmake文件吧。

宏函数

#include <stdio.h>
#define MAX(a, b) a>b?a:b
int main() {
  printf("max : %d \n", MAX(1, 3));
  printf("max : %d \n", MAX(1, MAX(4,3)));
  return 0;
}

看下履行成果：

是不是和预想中的不太相同？

宏函数和普通函数仍是有差异的，他便是直接在编译的时分替换掉的

稍微改一下：

#define MAX(a, b) (a) >(b) ? (a) :(b)

应该就ok了

宏本质上便是代码替换，和函数是不相同的

个人认为，宏函数比函数好的地方就在于他没有类型约束

宏函数如何换行

#include <stdio.h>
#define MAX(a, b) (a) >(b) ? (a) :(b)
#define is_hex_char(c) \
     ((c)>='0'&& (c)<='9') || \
     ((c)>='a' && (c)<='f')
int main() {
  printf("max : %d \n", MAX(1, 3));
  printf("max : %d \n", MAX(1, MAX(4, 3)));
  printf("is hex : %d \n", is_hex_char('a'));
  return 0;
}

条件编译

看下之前写的代码：

这些黄色的代码代表啥意思？作用是什么？

其实你想一下，这个头文件里边声明晰一个函数

假如你的程序很大的情况下，假如有多处地方都include了这个头文件，等于你是不是有多个同名的函数？

那编译不是会报错嘛，这儿的黄色代码就代表是这个意思

条件编译在某些时分挺有用的，比方你想本地编译的时分打印调试信息，正式版别不打印

#include <stdio.h>
void dump(){
#ifdef DEBUG
  printf("debug info");
#endif
}
int main(){
  dump();
  return 0;
}

然后在cmake中写一下：

add_executable(cstudy5 macro_test2.c)
target_compile_definitions(cstudy5 PUBLIC DEBUG)

跑一下：

很有意思，你明明没有界说debug 这个宏，可是运行的成果却打印了调试信息，这个其实也是cmake 在发挥作用

一般咱们能够使用条件编译来判别咱们到底是在c仍是cpp，在mac，仍是在windows 仍是在linux的环境中

=printf 主动换行

供给了2个版别的完成，显着宏的完成更简练一些

#include <stdio.h>
#include <stdarg.h>
#define PRINTFLINE(format, ...) printf(format"\n",##__VA_ARGS__)
void Printf(const char *format, ...) {
  va_list args;
  va_start(args, format);
  vprintf(format, args);
  printf("\n");
  va_end(args);
}
int main() {
  Printf("hello");
  PRINTFLINE("world");
  return 0;
}

有的人觉得 c言语打印个变量也太麻烦了，还要写百分号，有没有更简略的

#define PRINT_INT(value) PRINTFLINE(#value": %d",value)

还有更进一步的：

咱们期望打印的时分能够主动把咱们的行号，所属的文件，文件名都打印出来，这样打印调试信息的就很清晰了大型工程的时分特别有用

#define PRINTFLINE(format, ...) printf("("__FILE__":%d) %s : "format"\n",__LINE__, __FUNCTION__, ##__VA_ARGS__)

字符串

字符串基本常识

c 言语中的字符串有必要以 null 也便是\0 为结尾

#include <stdio.h>
#include <ioprint.h>
int main(){
  char string[5]="wuyue";
  char string2[6]="wuyue";
  PRINTFLINE("string: %s",string);
  PRINTFLINE("string2: %s",string2);
  return 0;
}

来看下履行成果：

榜首行的成果肯定是不对的，其实问题便是没有多拓荒一个元素方位用来放\0 这一点和其他言语又不相同

指针

指针的只读

这儿能够看到编译报错了， cp的地址是不能改的，可是值能够修正

反过来看一下：

这儿便是地址能够改，可是值不能修正

还有一种写法能够看出来，这儿甚至连值都不能改了，

首要仍是看 *的方位总结起来便是：

const 假如润饰的是指针，则地址不能修正 const 假如润饰的是值，则值不能修正

其实便是看const的左边有没有*

左右值问题

先看下下面这段代码：

#include <stdio.h>
#include <ioprint.h>
int main() {
  int array[4] = {0};
  int *pa= array;
  *pa=2;
  *(pa++)=3;
  *(pa+2)=4;
  PRINT_INT_ARRAY(array,4);
  return 0;
}

履行成果：

要搞清楚一个概念，等号右边永远是取出来的值，而等号左边永远是一块地址空间

榜首次是把2 这个值赋给方位为0的元素

第二次是 pa这个指针的方位的值也便是方位为0的元素改为3，然后这个pa的指针挪后了一位

第三次便是pa这个指针再挪两位

指针参数作为返回值

这个务必要搞清楚了，许多开源项目都是很多运用这个技巧

比方说咱们前面求和的这个函数

假如你在main函数中调用他会产生什么呢？

首先在sum这个函数把成果计算出来之后， 是先把这个成果从内存中拷贝到cpu的寄存器中

第二步： 再从cpu的寄存器中将这个值拷贝到内存中

这儿是不是就涉及到两次拷贝了？假如你这个函数很复杂，是个结构体，这个开销仍是有的，

所以许多时分咱们会这么写：

void sum2(int x, int y, int *result) {
  *result = x + y;
}

函数的最终1个或者n个参数作为接纳函数的返回值，能够完成函数多返回值，而且省略内存拷贝的开销

动态分配内存

别的言语动态声明1个数组是能够的，可是在c言语就比较麻烦了，需要像下面的程序相同才能够办到

#include <stdio.h>
#include <ioprint.h>
#include <malloc.h>
int main() {
  int size = 10;
  int *array = malloc(sizeof(int) * size);
  int i;
  for (i = 0; i < size; ++i) {
    array[i]=i;
  }
  PRINT_INT_ARRAY(array,size)
  free(array);
  return 0;
}

这儿要注意2点，榜首 malloc和free 要成对呈现

第二 malloc分配的内存块最好要榜首时间初始化，由于malloc是在堆区上分配的一块内存，你不知道这块内存上是什么值，所以你申请完以后榜首时间要做初始化

注意了，这儿有一个大坑，比方咱们想把这个初始化的过程作为一个函数来便利调用, 许多人会这么写：

void InitIntArray(int *a, int size, int defaultValue) {
  a = malloc(sizeof(int) * size);
  int i;
  for (i = 0; i < size; ++i) {
    a[i] = defaultValue;
  }
}
int main() {
  int size = 10;
  int *a;
  InitIntArray(a,size,0);
  PRINT_INT_ARRAY(a, size)
  free(a);
  return 0;
}

看上去好像这段代码没什么问题可是你运行起来就会报错了, 来看下正确的代码应该怎么写：

void InitIntArray2(int **aparams, int size, int defaultValue) {
  *aparams = malloc(sizeof(int) * size);
  int i;
  for (i = 0; i < size; ++i) {
    (*aparams)[i] = defaultValue;
  }
}
int main() {
  int size = 10;
  int *a;
  InitIntArray2(&a,size,0);
  PRINT_INT_ARRAY(a, size)
  free(a);
  return 0;
}

能够体会一下这2个写法的差异，咱们首先看一下榜首个写法为什么不对，

在c言语中，函数都是值传递，什么是值传递？

也便是关于榜首种写法来说，

虽然你在办法内部成功malloc了一块内存，可是指向这块内存的是你函数的参数，并不是main函数中的指a

一定要切记，函数都是值传递的。

那第二种写法为什么正确？

首先你传入的是一个指针的地址

也便是说 aParams = &a

那么 *aParams 就等于 a

别的也能够关注下 calloc这个函数，这是主动初始化值的，还有一个realloc 从头分配一段内存，一般能够用于动态扩展数组的巨细

// 主动初始化
int *b = calloc(size, sizeof(int));
// 在之前的基础上，从头拓荒一段空间，等于是扩展了
b = realloc(b, size * 2);
if (b != NULL) {
  PRINTFLINE("分配成功");
  PRINT_INT_ARRAY(b, size);
} else{
  PRINTFLINE("分配失败");
}
return 0;

函数指针

在c言语中是能够界说一个函数指针的，很意外吧 , 比方说上面那个小节的比如，还能够这么写

void (*func)(int **aparams, int size, int defaultValue) = &InitIntArray2;
size = 30;
func(&a, size, 30);
PRINT_INT_ARRAY(a, size);

这儿真的很容易利诱能够看下下面的几种写法

// f1是一个函数，这个函数的返回值 是一个int * 指针
int *f1(int,double );
// f2是一个函数指针，指向一个 参数为int，double 返回值是int的 函数
int (*f2) (int,double );
// f3和f2 相同，只不过返回值 是一个 int * 的函数
int *(*f3) (int,double );
// 函数的指针能够界说数组，可是函数不能界说数组
int (*f5[]) (int,double);

当然还能够指定别号

// 界说这个函数指针的别号
typedef int (*Func)(int, int);
int Add(int x, int y) {
  return x + y;
}

然后去调用他

Func func_1 = &Add;
PRINTFLINE("result : %d" ,func_1(3, 4));

这儿有点绕，可是不要紧咱们能够在觉得看不明白代码的时分仿制一下类型到下面的网站让他给你答案即可

到这儿看一下到底是啥类型

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

Android工程师为啥要学习c/c++呢？

基础环境建立

函数的变长参数

宏

头文件

自己写头文件

<> 和 ““ 的差异

宏函数

宏函数如何换行

条件编译

=printf 主动换行

字符串

字符串基本常识

指针

指针的只读

左右值问题

指针参数作为返回值

动态分配内存

函数指针

作者信息

推广

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

Android工程师 为啥要学习c/c++呢？

基础环境建立

函数的变长参数

宏

头文件

自己写头文件

<> 和 ““ 的差异

宏函数

宏函数如何换行

条件编译

=printf 主动换行

字符串

字符串基本常识

指针

指针的只读

左右值问题

指针参数作为返回值

动态分配内存

函数指针

相关文章

分布式的计算框架之Spark（python第三方库视角学习PySpark）

基于qemu的kdump与crash环境搭建与实例解析

深入浅出 Pytorch 系列 — 参数初始化(1)

深入了解 Flutter 中的 BuildContext

作者信息

推广

Android工程师为啥要学习c/c++呢？