一、宏
C++ 宏定义将一个标识符定义为一个字符串，源程序中的该标识符均以指定的字符串来代替,比如定义常量。
C++编译的四大过程：预处理，预编译，汇编，链接；
预处理：预处理阶段主要处理include和define等。它把#include包含进来的.h 文件插入到#include所在的位置，把源程序中使用到的用#define定义的宏用实际的字符串代替，宏定义的展开，宏定义的替换。
预处理器不是编译器，预处理器主要完成文本替换的操作，预处理器都是用 #xxx 的写法。
#include 导入头文件
#if if判断操作 【if的范畴 必须endif】
#elif else if
#else else
#endif 结束if
#define 定义一个宏
#ifdef 如果定义了这个宏 【if的范畴 必须endif】
#ifndef 如果没有定义这个宏 【if的范畴 必须endif】
#undef 取消宏定义
#pragma 设定编译器的状态
1、宏定义示例
//宏定义示例：
#ifndef CLIONCPPPROJECT_T2_H // 如果没有定义这个宏 解决循环拷贝的问题
#define CLIONCPPPROJECT_T2_H // 我就定义这个宏
// 100 行代码
// 第一次能够进来
// 第二次 第n此进不来 直接 解决循环拷贝的问题了
// ---------------
#ifndef isRelease // 如果没有isRelease这个宏
#define isRelease 1 // 是否是正式环境下 【我就定义isRelease这个宏】
#if isRelease == true
#define RELEASE // 正式环境下 定义RELEASE宏
#elif isRelease == false
#define DEBUG // 测试环境下 定义DEBUG宏
#endif // 结束里面的if
#endif // 结束里面的if
#endif //CLIONCPPPROJECT_T2_H // 结束外面的if
#include
#include "T2.h"
using namespace std;
int main() {
// if 条件判断
// ifdef xxx 是否定义了xxx这个宏
#ifdef DEBUG // 是否定义了DEBUG这个宏
cout << "在测试环境下，迭代功能" << endl;
#else RELEASE
cout << "在正式环境下，功能上下中" << endl;
#endif // 结束IF
}
2、宏的取消
// 宏的取消 #undef 宏
#include
using namespace std;
int main() {
int i = 1
#ifndef DERRY // 如果没有定义这个宏
#define DERRY // 我就定义宏
#ifdef DERRY // 是否定义了这个宏
for (int i = 0; i < 6; ++i) {
cout << "Derry 1" << endl;
}
#undef DERRY // 取消宏的定义，下面的代码，就没法用这个宏了，相当于：没有定义过DERRY宏
#ifdef DERRY
cout << "你定义了Derry宏" << endl;
#else
cout << "你没有定义了Derry宏" << endl;
#endif
#endif
#endif
#endif
return 0;
}
3、宏函数
优点：文本替换，不会造成函数的调用开销(开辟栈空间，形参压栈，函数弹栈释放 ..)
缺点：会导致代码体积增大
// 宏函数 真实开发中：宏函数都是大写
#include
using namespace std;
#define VALUE_I 9527
#define VALUE_S "AAA"
#define VALUE_F 545.3f
#define SHOW(V) cout << V << endl; // 参数列表 无需类型 返回值 看不到
#define ADD(n1, n2) n1 + n2
#define CHE(n1, n2) n1 * n2 // 故意制作问题 ，宏函数的注意事项
// 复杂的宏函数
#define LOGIN(V) if(V==1) { \
cout << "满足 你个货输入的是:" << V << endl; \
} else { \
cout << "不满足 你个货输入的是:" << V << endl; \
} // 这个是结尾，不需要加 \
void show() {}
int main() {
int i = VALUE_I; // 预处理阶段 宏会直接完成文本替换工作，替换后的样子：int i = 9527;
string s = VALUE_S; // string s = "AAA";
float f = VALUE_F; // float f = 545.3f;s
SHOW(8);
SHOW(8.8f);
SHOW(8.99);
int r = ADD(1, 2);
cout << r << endl;
r = ADD(1+1, 2+2);
cout << r << endl;
// r = CHE(1+1, 2+2);
r = 1+1 * 2+2; // 文本替换：1+1 * 2+2 先算乘法 最终等于 5
cout << r << endl; // 我们认为的是8， 但是打印5
LOGIN(0);
LOGIN(0);
LOGIN(0);
// 会导致代码体积增大
show();
show();
// 普通函数，每次都会进栈 弹栈 ，不会导致代码体积增大
return 0;
}
二、JNI交互
1、JNI概述
定义：Java Native Interface，即 Java 本地接口
作用： 使得 Java 与 本地其他类型语言（如 C、C++）交互，JNI 是 Java 调用 Native 语言的一种特性，JNI 是属于 Java 的，与 Android 无直接关系，实际中的驱动都是 C/C++开发的,通过 JNI,Java 可以调用 C/c++实现的驱动，从而扩展 Java 虚拟机的能力。另外，在高效率的数学运算、游戏的实时渲染、音视频的编码和解码等方面，一般都是用 C 开发的（Java 代码 里调用 C/C++等语言代码 或 C/C++代码调用 Java 代码）；
实际使用中，Java 需要与 本地代码 进行交互，因为 Java 具备跨平台的特点，所以 Java 与 本地代码交互的能力非常弱，采用 JNI 特性 增强 Java 与 本地代码交互的能力。
NDK 与 JNI 关系？
JNI： Java 平台 JDK 提供的一套非常强大的框架 Java Native Interface
相互调用交互通信：C C++ Native < > Java / Kotlin
NDK： Android 平台提供的 Native 开发工具集开发包 Native Development Kit,后面把开始的 JNI，拿到 NDK 里面来并进行封装 （JNI，gcc，g++， ）
2、JNI交互实例
签名规则：javap -s -p MainActivity 必须是.class
Java的boolean --- Z 注意点
Java的byte --- B
Java的char --- C
Java的short --- S
Java的int --- I
Java的long --- J 注意点
Java的float --- F
Java的double --- D
Java的void --- V
Java的引用类型 --- Lxxx/xxx/xx/类名;
Java的String --- Ljava/lang/String;
Java的array int[] --- [I double[][][][] --- [[[D
int add(char c1, char c2) ---- (CC)I
void a() === ()V
javap -s -p xxx.class -s 输出xxxx.class的所有属性和方法的签名， -p 忽略私有公开的所有属性方法全部输出
//MainActivity.java
package com.derry.as_jni_project;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;
// 生成头文件：javah com.derry.as_jni_project.MainActivity
public class MainActivity extends AppCompatActivity {
static {
System.loadLibrary("native-lib");
}
public static final int A = 100;
public String name = "Derry"; // 签名：Ljava/lang/String;
public static int age = 29; // 签名：I
// Java 本地方法 实现：native层
public native String getStringPwd();
public static native String getStringPwd2();
// ------------- 交互操作 JNI
public native void changeName();
public static native void changeAge();
public native void callAddMethod();
// 专门写一个函数，给native成调用
public int add(int number1, int number2) {
return number1 + number2 + 8;
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// Example of a call to a native method
TextView tv = findViewById(R.id.sample_text);
changeName();
tv.setText(name);
changeAge();
tv.setText("" + age);
callAddMethod();
}
}
//头文件，解释相关细节
#include
#include
// 解决循环Copy的问题 第二次就进不来了
#ifndef _Included_com_derry_as_jni_project_MainActivity // 如果没有定义这个宏
#define _Included_com_derry_as_jni_project_MainActivity // 我就定义这个宏
#ifdef __cplusplus // 如果是C++环境
extern "C" { // 全部采用C的方式 不准你函数重载，函数名一样的问题
#endif
#undef com_derry_as_jni_project_MainActivity_A
#define com_derry_as_jni_project_MainActivity_A 100L
// 函数的声明
JNIEXPORT jstring JNICALL Java_com_derry_as_1jni_1project_MainActivity_getStringPwd
(JNIEnv *, jobject);
#ifdef __cplusplus
}
#endif
#endif
//native-lib.cpp
#include "com_derry_as_jni_project_MainActivity.h"
// NDK工具链里面的 log 库 引入过来
#include
#define TAG "Derry"
// ... 我都不知道传入什么 借助JNI里面的宏来自动帮我填充
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__)
// extern "C"： 必须采用C的编译方式，为什么，请看JNIEnv内部源码
// // 无论是C还是C++ 最终是调用到 C的JNINativeInterface，所以必须采用C的方式 extern "C"
// 函数的实现
extern "C"
JNIEXPORT // 标记该方法可以被外部调用（VS上不加入 运行会报错， AS上不加入运行没有问题）
// Linux运行不加入，不报错, Win 你必须加入 否则运行报错, MacOS 还不知道
jstring // Java <---> native 转换用的
JNICALL // 代表是 JNI标记，可以少
// Java_包名_类名_方法名 ，注意：我们的包名 _ native _1
// JNIEnv * env JNI：的桥梁环境 300多个函数，所以的JNI操作，必须靠他
// jobject jobj 谁调用，就是谁的实例 MainActivity this
// jclass clazz 谁调用，就是谁的class MainActivity.class
Java_com_derry_as_1jni_1project_MainActivity_getStringPwd
(JNIEnv * env, jobject jobj) {
}
// 静态函数
extern "C"
JNIEXPORT jstring JNICALL
Java_com_derry_as_1jni_1project_MainActivity_getStringPwd2(JNIEnv *env, jclass clazz) {
// TODO: implement getStringPwd2()
}
extern "C"
JNIEXPORT void JNICALL
Java_com_derry_as_1jni_1project_MainActivity_changeName(JNIEnv *env, jobject thiz) {
// 获取class
jclass j_cls = env->GetObjectClass(thiz);
// 获取属性 L对象类型 都需要L
// jfieldID GetFieldID(MainActivity.class, 属性名, 属性的签名)
jfieldID j_fid = env->GetFieldID(j_cls, "name", "Ljava/lang/String;");
// 转换工作
jstring j_str = static_cast(env->GetObjectField(thiz ,j_fid));
// 打印字符串 目标
char * c_str = const_cast(env->GetStringUTFChars(j_str, NULL));
LOGD("native : %s\n", c_str);
LOGE("native : %s\n", c_str);
LOGI("native : %s\n", c_str);
// 修改成 Beyond
jstring jName = env->NewStringUTF("Beyond");
env->SetObjectField(thiz, j_fid, jName);
}
extern "C"
JNIEXPORT void JNICALL
Java_com_derry_as_1jni_1project_MainActivity_changeAge(JNIEnv *env, jclass jcls) {
const char * sig = "I";
jfieldID j_fid = env->GetStaticFieldID(jcls, "age", sig);
jint age = env->GetStaticIntField(jcls, j_fid);
age += 10;
env->SetStaticIntField(jcls, j_fid, age);
}
extern "C"
JNIEXPORT void JNICALL
Java_com_derry_as_1jni_1project_MainActivity_callAddMethod(JNIEnv *env, jobject job) {
// 自己得到 MainActivity.class
jclass mainActivityClass = env->GetObjectClass(job);
// GetMethodID(MainActivity.class, 方法名, 方法的签名)
jmethodID j_mid = env->GetMethodID(mainActivityClass, "add", "(II)I");
// 调用 Java的方法
jint sum = env->CallIntMethod(job, j_mid, 3, 3);
LOGE("sum result:%d", sum);
}