• 类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。
• 类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

• 友元函数是一种定义在类外部的普通函数，它不属于任何类，但它需要在类体内进行说明，为了与该类的成员函数加以区别，在说明时前面加以关键字 friend。
• 友元函数不是成员函数，但是它可以访问类中的私有成员。
• 一个函数可以是多个类的友元函数，只需要在各个类中分别声明。
• 友元的作用在于提高程序的运行效率（即减少了类型检查和安全性检查等都需要的时间开销），但是，它破坏了类的封装性和隐藏性，使得非成员函数可以访问类的私有成员。
• 友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。
• 当希望一个类可以存取另一个类的私有成员时，可以将该类声明为另一类的友元类。定义友元类的语句格式如下：friend class 类名 （friend和class是关键字，类名必须是程序中的一个已定义过的类）。

class INTEGER { private: int num; public: friend void Print(const INTEGER& obj); //声明友元函数 }; void Print(const INTEGER& obj)//不使用friend和类：： { //函数体 } void main() { INTEGER obj; Print(obj); //直接调用 } 复制代码

#include using namespace std; class girl { private: char *name; int age; friend classboy; //声明类boy是类girl的友元 public: girl(char *n,int age):name(n),age(age){}; }; class boy { private: char *name; int age; public: boy(char *n,int age):name(n),age(age){}; void disp(girl &); }; void boy::disp(girl &x)//该函数必须在girl类定义的后面定义，否则girl类中的私有变量还是未知的 { cout<<"boy's name is:"<
1.8 单例对象、操作符重载

• 我们可以重定义或重载大部分 C++ 内置的运算符。这样就能使用自定义类型的运算符。重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表。

#include using namespace std; class Box { public:double getVolume(void) { return length * breadth * height; } void setLength( double len ) { length = len; }void setBreadth( double bre ) { breadth = bre; }void setHeight( double hei ) { height = hei; } // 重载 + 运算符，用于把两个 Box 对象相加 Box operator+(const Box& b) { Box box; box.length = this->length + b.length; box.breadth = this->breadth + b.breadth; box.height = this->height + b.height; return box; } private: double length; // 长度 double breadth; // 宽度 double height; // 高度 }; // 程序的主函数 int main( ) { Box Box1; // 声明 Box1，类型为 Box Box Box2; // 声明 Box2，类型为 Box Box Box3; // 声明 Box3，类型为 Box double volume = 0.0; // 把体积存储在该变量中// Box1 详述 Box1.setLength(6.0); Box1.setBreadth(7.0); Box1.setHeight(5.0); // Box2 详述 Box2.setLength(12.0); Box2.setBreadth(13.0); Box2.setHeight(10.0); // Box1 的体积 volume = Box1.getVolume(); cout << "Volume of Box1 : " << volume <

打印结果：

Volume of Box1 : 210 Volume of Box2 : 1560 Volume of Box3 : 5400
1.9 继承多态、虚函数 1.9.1 继承

• 一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名：class derived-class: access-specifier base-class ；
• 其中，访问修饰符 access-specifier 是 public、protected 或 private 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。
• 派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。
• 一个派生类继承了所有的基类方法，但下列情况除外：

基类的构造函数、析构函数和拷贝构造函数。

基类的重载运算符。 基类的友元函数。

• 当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。
  
• 我们几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：
  

公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。

保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。 私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

#include using namespace std; // 基类 class Shape { public: void setWidth(int w) { width = w; } void setHeight(int h) { height = h; } protected: int width; int height; }; // 派生类 class Rectangle: public Shape { public: int getArea() { return (width * height); } }; int main(void) { Rectangle Rect; Rect.setWidth(5); Rect.setHeight(7); // 输出对象的面积 cout << "Total area: " << Rect.getArea() << endl; return 0; } 复制代码

打印结果：

Total area: 35
1.9.2 虚函数

定义一个函数为虚函数，不代表函数为不被实现的函数。

定义他为虚函数是为了允许用基类的指针来调用子类的这个函数。 定义一个函数为纯虚函数，才代表函数没有被实现。 定义纯虚函数是为了实现一个接口，起到一个规范的作用，规范继承这个类的程序员必须实现这个函数。

class A { public: virtual void foo() { cout<<"A::foo() is called"<foo(); // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的! return 0; } 复制代码

• 一个类函数的调用并不是在编译时刻被确定的，而是在运行时刻被确定的。由于编写代码的时候并不能确定被调用的是基类的函数还是哪个派生类的函数，所以被称为“虚”函数。
• 纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加 “=0” ：virtual void funtion()=0
• 将函数定义为纯虚函数，则编译器要求在派生类中必须予以重写以实现多态性。声明了纯虚函数的类是一个抽象类。所以，用户不能创建类的实例，只能创建它的派生类的实例。

1.10 类模板、函数模板

• 模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。
• 模板是创建泛型类或函数的蓝图或公式。

模板函数定义的一般形式如下所示：

template ret-type func-name(parameter list) { // 函数的主体 } 复制代码

#include #include using namespace std; template inline T const& Max (T const& a, T const& b) { return a < b ? b:a; } int main () {int i = 39; int j = 20; cout << "Max(i, j): " << Max(i, j) << endl; double f1 = 13.5; double f2 = 20.7; cout << "Max(f1, f2): " << Max(f1, f2) << endl; string s1 = "Hello"; string s2 = "World"; cout << "Max(s1, s2): " << Max(s1, s2) << endl; return 0; } 复制代码

打印结果：

Max(i, j): 39 Max(f1, f2): 20.7 Max(s1, s2): World
类模板，泛型类声明的一般形式如下所示：

template class class-name { . . . } 复制代码

#include #include #include #include #include using namespace std; template class Stack { private: vector elems; // 元素 public: void push(T const&); // 入栈 void pop(); // 出栈 T top() const; // 返回栈顶元素 bool empty() const{// 如果为空则返回真。 return elems.empty(); } }; template void Stack::push (T const& elem) { // 追加传入元素的副本 elems.push_back(elem); } template void Stack::pop () { if (elems.empty()) { throw out_of_range("Stack<>::pop(): empty stack"); } // 删除最后一个元素 elems.pop_back(); } template T Stack::top () const { if (elems.empty()) { throw out_of_range("Stack<>::top(): empty stack"); } // 返回最后一个元素的副本 return elems.back(); } int main() { try { StackintStack; // int 类型的栈 Stack stringStack; // string 类型的栈 // 操作 int 类型的栈 intStack.push(7); cout << intStack.top() <

打印结果：

7 hello Exception: Stack<>::pop(): empty stack
1.11 容器

• 序列式容器（Sequence containers），此为可序群集，其中每个元素均有固定位置—取决于插入时机和地点，和元素值无关。如果你以追加方式对一个群集插入六个元素，它们的排列次序将和插入次序一致。STL提供了三个序列式容器：向量（vector）、双端队列（deque）、列表（list），此外你也可以把 string 和 array 当做一种序列式容器。
• 关联式容器（Associative containers），此为已序群集，元素位置取决于特定的排序准则以及元素值，和插入次序无关。如果你将六个元素置入这样的群集中，它们的位置取决于元素值，和插入次序无关。STL提供了四个关联式容器：集合（set）、多重集合（multiset）、映射（map）和多重映射（multimap）。
• 容器配接器：根据上面七种基本容器类别实现而成。stack，元素采取 LIFO（后进先出）的管理策略、queue，元素采取 FIFO（先进先出）的管理策略。也就是说，它是个普通的缓冲区（buffer）、priority_queue，元素可以拥有不同的优先权。所谓优先权，乃是基于程序员提供的排序准则（缺省使用 operators）而定义。Priority queue 的效果相当于这样一个 buffer：“下一元素永远是queue中优先级最高的元素”。如果同时有多个元素具备最髙优先权，则其次序无明确定义。

特点：

1. vector 头部与中间插入和删除效率较低，在尾部插入和删除效率高，支持随机访问。
2. deque 是在头部和尾部插入和删除效率较高，支持随机访问，但效率没有 vector 高。
3. list 在任意位置的插入和删除效率都较高，但不支持随机访问。
4. set 由红黑树实现，其内部元素依据其值自动排序，每个元素值只能出现一次，不允许重复，且插入和删除效率比用其他序列容器高。
5. map 可以自动建立 Key - value 的对应，key 和 value 可以是任意你需要的类型，根据 key 快速查找记录。

选择：

1. 如果需要高效的随机存取，不在乎插入和删除的效率，使用 vector。
2. 如果需要大量的插入和删除元素，不关心随机存取的效率，使用 list。
3. 如果需要随机存取，并且关心两端数据的插入和删除效率，使用 deque。
4. 如果打算存储数据字典，并且要求方便地根据 key 找到 value，一对一的情况使用 map，一对多的情况使用 multimap。
5. 如果打算查找一个元素是否存在于某集合中，唯一存在的情况使用 set，不唯一存在的情况使用 multiset。

时间复杂度：

1. vector 在头部和中间位置插入和删除的时间复杂度为 O(N)，在尾部插入和删除的时间复杂度为 O(1)，查找的时间复杂度为 O(1)；
2. deque 在中间位置插入和删除的时间复杂度为 O(N)，在头部和尾部插入和删除的时间复杂度为 O(1)，查找的时间复杂度为 O(1)；
3. list 在任意位置插入和删除的时间复杂度都为 O(1)，查找的时间复杂度为 O(N)；
4. set 和 map 都是通过红黑树实现，因此插入、删除和查找操作的时间复杂度都是 O(log N)。

1.12 命名空间 1.12.1 namespace

• 命名空间是一种描述逻辑分组的机制，可以将按某些标准在逻辑上属于同一个集团的声明放在同一个命名空间中。用于区分不同库中相同名称的函数、类、变量。

namespace namespace_name { // 代码声明 } 复制代码

• 无名命名空间。你可以在当前编译单元中（无名命名空间之外），直接使用无名命名空间中的成员名称，但是在当前编译单元之外，它又是不可见的。它可以使代码保持局部性，从而保护代码不被他人非法使用。

namespace { // 代码声明 } 复制代码

• 不能在命名空间的定义中声明（另一个嵌套的）子命名空间，只能在命名空间的定义中定义子命名空间。
• 不能直接使用 命名空间名::成员名 …… 定义方式，为命名空间添加新成员，而必须先在命名空间的定义中添加新成员的声明。
• 命名空间是开放的，即可以随时把新的成员名称加入到已有的命名空间之中去。方法是，多次声明和定义同一命名空间，每次添加自己的新成员和名称。

1.12.2 using

• 可以使用 using namespace 指令，这样在使用命名空间时就可以不用在前面加上命名空间的名称。这个指令会告诉编译器，后续的代码将使用指定的命名空间中的名称。

#include using namespace std; // 第一个命名空间 namespace first_space{ void func(){ cout << "Inside first_space" << endl; } } // 第二个命名空间 namespace second_space{ void func(){ cout << "Inside second_space" << endl; } } using namespace first_space; int main () {// 调用第一个命名空间中的函数 func(); return 0; } 复制代码

• 除了可以使用 using编译指令（组合关键字 using namespace）外，还可以使用 using声明 来简化对命名空间中的名称的使用：using 命名空间名::[命名空间名::……]成员名; 。注意，关键字 using 后面并没有跟关键字 namespace，而且最后必须为命名空间的成员名（而在 using 编译指令的最后，必须为命名空间名）。

using指令 使用后，可以一劳永逸，对整个命名空间的所有成员都有效，非常方便。而 using声明，则必须对命名空间的不同成员名称，一个一个地去声明。但是，一般来说，使用 using声明 会更安全。因为，using声明 只导入指定的名称，如果该名称与局部名称发生冲突，编译器会报错。而using指令 导入整个命名空间中的所有成员的名称，包括那些可能根本用不到的名称，如果其中有名称与局部名称发生冲突，则编译器并不会发出任何警告信息，而只是用局部名去自动覆盖命名空间中的同名成员。特别是命名空间的开放性，使得一个命名空间的成员，可能分散在多个地方，程序员难以准确知道，别人到底为该命名空间添加了哪些名称。

二、java 调用 C/C++

• 加载 .so 库；

//MainActivity.java static { System.loadLibrary("native-lib"); } 复制代码

• 编写 java 函数；

//MainActivity.java public native String stringFromJNI(); 复制代码

• 编写 C/C++ 函数；

//native-lib.cpp #include #include //函数名的构成：Java 加上包名、方法名并用下划线连接（Java_packageName_methodName） extern "C" JNIEXPORT jstring JNICALL Java_com_example_cppdemo_MainActivity_stringFromJNI( JNIEnv *env, jobject /* this */) { std::string hello = "Hello from C++"; return env->NewStringUTF(hello.c_str()); } 复制代码

• ndk/cmake 配置（下面只列出cmake配置）；

# CMakeLists.txt# 设置构建本地库所需的最小版本的cbuild。 cmake_minimum_required(VERSION 3.4.1) # 创建并命名一个库，将其设置为静态 # 或者共享，并提供其源代码的相对路径。 # 您可以定义多个库，而cbuild为您构建它们。 # Gradle自动将共享库与你的APK打包。 add_library( native-lib#设置库的名称。即SO文件的名称，生产的so文件为“libnative-lib.so”, 在加载的时候“System.loadLibrary("native-lib"); ” SHARED# 将库设置为共享库。 native-lib.cpp# 提供一个源文件的相对路径 helloJni.cpp# 提供同一个SO文件中的另一个源文件的相对路径 ) # 搜索指定的预构建库，并将该路径存储为一个变量。因为cbuild默认包含了搜索路径中的系统库，所以您只需要指定您想要添加的公共NDK库的名称。cbuild在完成构建之前验证这个库是否存在。 find_library(log-lib# 设置path变量的名称。 log#指定NDK库的名称 你想让CMake来定位。 ) #指定库的库应该链接到你的目标库。您可以链接多个库，比如在这个构建脚本中定义的库、预构建的第三方库或系统库。 target_link_libraries( native-lib# 指定目标库中。与 add_library的库名称一定要相同 ${log-lib}# 将目标库链接到日志库包含在NDK。 ) #如果需要生产多个SO文件的话，写法如下 add_library( natave-lib# 设置库的名称。另一个so文件的名称 SHARED# 将库设置为共享库。 nataveJni.cpp# 提供一个源文件的相对路径 ) target_link_libraries( natave-lib#指定目标库中。与 add_library的库名称一定要相同 ${log-lib}# 将目标库链接到日志库包含在NDK。 ) 复制代码

// build.gradle(:app) android { compileSdkVersion 29 buildToolsVersion "30.0.2"defaultConfig { applicationId "com.example.cppdemo" minSdkVersion 16 targetSdkVersion 29 versionCode 1 versionName "1.0"testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" externalNativeBuild { cmake { cppFlags "" } } }buildTypes { release { minifyEnabled false proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' } } externalNativeBuild { cmake { path "src/main/cpp/CMakeLists.txt" version "3.10.2" } } } 复制代码

三、JNI 基础
3.1 JNIEnv 、JavaVM

• JavaVM 是 Java 虚拟机在 JNI 层的代表, JNI 全局只有一个；
• 从上面的代码中我们可以发现，虽然 Java 函数不带参数，但是 native 函数却带了两个参数，第一个参数 JNIEnv 是指向可用 JNI 函数表的接口指针，第二个参数 jobject 是 Java 函数所在类的实例的 Java 对象引用；
• JNIEnv 是 JavaVM 在线程中的代表, 每个线程都有一个， JNI 中可能有很多个 JNIEnv，同时 JNIEnv 具有线程相关性，也就是 B 线程无法使用 A 线程的 JNIEnv；
• JNIEnv 类型实际上代表了 Java 环境，通过这个 JNIEnv* 指针，就可以对 Java 端的代码进行操作：

调用 Java 函数； 操作 Java 对象；

• JNIEnv 的本质是一个与线程相关的代表 JNI 环境的结构体，里面存放了大量的 JNI 函数指针；
• JNIEnv 内部结构如下：

文章图片

• JavaVM 的结构如下：

【分享|腾讯T4大佬闲暇无事整理好的NDK开发，带你入门NDK开发】
文章图片


文章图片

3.2 数据类型 3.2.1 基础数据类型

Signature格式	Java	Native	Description
B	byte	jbyte	signed 8 bits
C	char	jchar	unsigned 16 bits
D	double	jdouble	64 bits
F	float	jfloat	32 bits
I	int	jint	signed 32 bits
S	short	jshort	signed 16 bits
J	long	jlong	signed 64 bits
Z	boolean	jboolean	unsigned 8 bits
V	void	void	N/A

3.2.2 数组数据类型 数组简称：在前面添加 [

Signature格式	Java	Native
[B	byte[]	jbyteArray
[C	char[]	jcharArray
[D	double[]	jdoubleArray
[F	float[]	jfloatArray
[I	int[]	jintArray
[S	short[]	jshortArray
[J	long[]	jlongArray
[Z	boolean[]	jbooleanArray

3.2.3 复杂数据类型 对象类型简称：L+classname +;

Signature格式	Java	Native
Ljava/lang/String;	String	jstring
L+classname +;	所有对象	jobject
[L+classname +;	Object[]	jobjectArray
Ljava.lang.Class;	Class	jclass
Ljava.lang.Throwable;	Throwable	jthrowable

3.2.4 函数签名 (输入参数...)返回值参数

Signature格式	Java函数
()V	void func()
(I)F	float func(int i)
([I)J	long func(int[] i)
(Ljava/lang/Class; )D	double func(Class c)
([ILjava/lang/String; )Z	boolean func(int[] i,String s)
(I)Ljava/lang/String;	String func(int i)

3.3 JNI 操作 JAVA 对象、类

• 获取你需要访问的 Java 对象的类：

jclass thisclazz = env->GetObjectClass(thiz); //使用GetObjectClass方法获取thiz对应的jclass。 jclass thisclazz = env->FindClass("com/xxx/xxx/abc"); //直接搜索类名 复制代码

• 获取 MethodID:

/** * thisclazz -->上一步获取的 jclass * "onCallback"-->要调用的方法名 * "(I)Ljava/lang/String; "-->方法的 Signature， 签名参照前面的第 3.2 小节表格。 */ jmethodID mid_callback = env->GetMethodID(thisclazz , "onCallback", "(Ljava/lang/String; )I"); jmethodID mid_callback = env->GetStaticMethodID(thisclazz , "onCallback", "(Ljava/lang/String; )I"); //获取静态方法的ID 复制代码

• 调用方法：

jint result = env->CallIntMethod(thisclazz , mid_callback , jstrParams); jint result = env->CallStaticIntMethod(thisclazz , mid_callback , jstrParams); //调用静态方法 复制代码

贴一下JNI 常用接口文档，有需要可以在这里查询。
3.4 JNI 引用 3.4.1 局部引用

• 通过 NewLocalRef 和各种JNI接口创建（FindClass、NewObject、GetObjectClass和NewCharArray等）。
• 会阻止 GC 回收所引用的对象，不在本地函数中跨函数使用，不能跨线前使用。
• 函数返回后局部引用所引用的对象会被 JVM 自动释放，或手动释放。
• 手动释放的方式：GetXXX 就必须调用 ReleaseXXX，调用完 GetStringUTFChars 之后，调用 ReleaseStringUTFChars 释放；对于手动创建的 jclass，jobject 等对象使用 DeleteLocalRef 方法进行释放。

3.4.2 全局引用

• 调用 NewGlobalRef 基于局部引用创建。
• 会阻 GC 回收所引用的对象。可以跨方法、跨线程使用。
• JVM 不会自动释放，必须手动释放。
• 全局引用在显式释放之前保持有效，必须通过 DeleteGlobalRef 来手动删除全局引用调用。

3.4.3 弱全局引用

• 调用 NewWeakGlobalRef 基于局部引用或全局引用创建。
• 不会阻止 GC 回收所引用的对象，可以跨方法、跨线程使用。
• 引用不会自动释放，在 JVM 认为应该回收它的时候（比如内存紧张的时候）进行回收而被释放。或调用 DeleteWeakGlobalRef 手动释放。

后续
本文参考了部分视频、书籍、博客的内容。这里就不列出来了。想要了解更多NDK开发项目与学习资料，点击下方二维码。

文章图片

推荐阅读

• 

  大股东占用子公司资金的形式有哪些？
• 

  叶绍翁《汉武帝》这首诗的主题是什么？
• 

  加工中心编程软件免费下载，哪里可以下载到CNC数控加工中心编程软件急问
• 

  捷信逾期三年有没有人催收
• 

  形容高兴的四字的词语有哪些 形容高兴的四字的词语总结
• 

  彪炳史册的含义是 彪炳史册的解释
• 

  分辨和分辩有什么不同 分辨和分辩的区别读音
• 

  高血压患者|高血压患者低压高，有2大原因，首选这3类降压药，找对原因不难降
• 

  疑似病例|这地发现1例疑似病例，当地政府连夜通告：即日起隔离封闭管理
• 

  西瓜什么时候种
• 

  android 的Manifest对图标的影响
• 

  2021年5月3号是返程高峰吗
• 

  当下的力量经典语录
• 

  Win8改Win7安装前如何设置Bios？
• 

  大阿福起源于哪里
• 

  安卓模拟器雷霆战机,电脑上玩雷霆战机如何进行?
• 

  谁动了我的“幸福”
• 

  日本的“薙刀”是怎样一种武器,为何会成为女性和僧兵的常用武器？
• 

  1000:A+B Problem
• 

  初伏中伏末伏哪个最热

• 第326天
• 姚老师互动问答会|姚老师互动问答会 # 问题001（如何更有智慧的和身边人分享金刚智慧（））
• 焦点学习田源分享第267天《来访》
• 《偶得》
• 2018.03.18
• 坚持分享第104天
• 句子分享
• 记录iOS生成分享图片的一些问题，根据UIView生成固定尺寸的分享图片
• 康恩赫助力线头公益#义卖星推官#，分享你最喜爱的义卖明星
• 腾讯视频（我有一段rap想给你说）