NDK開發

一、C++ 基礎知識

1.1 函數

• 函數是一組一起執行一個任務的語句。每個 C 程序都至少有一個函數，即主函數 main() ，所有簡單的程序都可以定義其他額外的函數。
• .h 頭文件 。
• 指針函數：指帶指針的函數，即本質是一個函數。函數返回類型是某一類型的指針。int *func(int x, int y)。
• 函數指針：指向函數的指針變量，即本質是一個指針變量。int (*funcp)(int x)。

int i;
int *a = &i;        //這里a是一個指針，它指向變量i
int &b = i;         //這里b是一個引用，它是變量i的引用(別名)
int * &c = a;       //這里c是一個引用，它是指針a的引用
int & *d;           //這里d是一個指針，它指向引用，但引用不是實體，所以這是錯誤的

在分析上面代碼時，可以從變量標識符開始從右往左看，最靠近標識符的是變量的本質類型，而再往左即為對變量類型的進一步修飾。
例如：int * & a
標識符a的左邊緊鄰的是 &，證明 a 是一個引用變量，而再往左是 * ，可見 a 是一個指針的引用，再往左是 int，可見 a 是一個指向int類型的指針的引用。

• . 和 ->

struct Data
{
int a,b,c;
}; /*定義結構體類型*/
struct Data * p;                 /*  定義結構體指針   */
struct Data A = {1,2,3};         / *  聲明結構體變量A，A即結構體名   */
int x;                               /*  聲明一個變量x  */
p = &A ;                           /*   地址賦值，讓p指向A    */
x = p->a;        /* 取出p所指向的結構體中包含的數據項a賦值給x   */
/* 此時由于p指向A，因而 p->a == A.a,也就是1 */

因為此處 p 是一個指針，所以不能使用.號訪問內部成員(即不能 p.a)，而要使用 ->。但是 A.a 是可以的，因為 A 不是指針，是結構體名。
一般情況下用 “.” 只需要聲明一個結構體。格式是：結構體類型名+結構體名。然后用 結構體名加“.”加成員名 就可以引用成員了。因為自動分配了結構體的內存。如同 int a; 一樣。
用 “->” ，則要聲明一個結構體指針，還要手動開辟一個該結構體的內存（上面的代碼則是建了一個結構體實例，自動分配了內存，下面的例子則會講到手動動態開辟內存），然后把返回的地址賦給聲明的結構體指針，才能用“->” 正確引用。否則內存中只分配了指針的內存，沒有分配結構體的內存，導致想要的結構體實際上是不存在。這時候用 “->” 引用自然出錯了，因為沒有結構體，自然沒有結構體的域了。
此外，(*p).a 等價于 p->a。

• ::

:: 是作用域符，是運算符中等級最高的，它分為三種:

1. 全局作用域符，用法 ::name
2. 類作用域符，用法 class::name
3. 命名空間作用域符，用法 namespace::name

他們都是左關聯，他們的作用都是為了更明確的調用你想要的變量:

1. 如在程序中的某一處你想調用全局變量 a，那么就寫成 ::a；（也可以是全局函數）
2. 如果想調用 class A 中的成員變量 a，那么就寫成 A::a；
3. 另外一個如果想調用 namespace std 中的 cout 成員，你就寫成 std::cout（相當于 using namespace std；cout）意思是在這里我想用 cout 對象是命名空間 std 中的cout（即就是標準庫里邊的cout）；

（1）表示“域操作符”：聲明了一個類 A，類 A 里聲明了一個成員函數 void f()，但沒有在類的聲明里給出 f 的定義，那么在類外定義f時， 就要寫成 void A::f()，表示這個 f() 函數是類 A 的成員函數。
（2）直接用在全局函數前，表示是全局函數：在 VC 里，你可以在調用 API 函數里，在 API 函數名前加 ::
（3）表示引用成員函數及變量，作用域成員運算符：System::Math::Sqrt() 相當于 System.Math.Sqrt()；

1.2 linux內存布局

C 語言內存組成

1.3 指針數組

• 數組： int arr[] = {1,2,3};
• 指針： int* p = arr，指針 p 指向數組 arr 的首地址；*p = 6; 將 arr 數組的第一個元素賦值為 6；*(p+1) = 10; 將 arr 數組第二個元素賦值為 10；
• 指針數組：數組里面每一個元素都是指針

int* p[3]；
for(int i = 0; i<3; i++){
 p[i] = &arr[i];
}

• 數組指針：也稱為行指針；int (*p)[n]

優先級高，首先說明 p 是一個指針，指向一個整型的一維數組，這個一維數組的長度是 n，也可以說是 p 的步長。執行 p+1 時，p 要跨過 n 個整型數據的長度。
int a[3][4];
int (*p)[4]; //該語句是定義一個數組指針，指向含 4 個元素的一維數組
p = a; //將該二維數組的首地址賦給 p，也就是 a[0] 或 &a[0][0]
p++; //該語句執行后，也就是 p = p+1; p 跨過行 a[0][] 指向了行 a[1][]

1.4 結構體

struct Person
{
    char c;
    int i;
    char ch;
};

int main()
{
    struct Person person;
    person.c = 8;
    person.i = 9;
}

存儲變量時地址要求對齊，編譯器在編譯程序時會遵循兩個原則：
（1）結構體變量中成員的偏移量必須是成員大小的整數倍
（2）結構體大小必須是所有成員大小的整數倍，也即所有成員大小的公倍數

內存對齊

1.5 共用體

• 共用體是一種特殊的數據類型，允許你在相同的內存位置存儲不同的數據類型。
• 你可以定義一個帶有多成員的共用體，但是任何時候只能有一個成員帶有值。
• 共用體提供了一種使用相同的內存位置的有效方式。
• 共用體占用的內存應足夠存儲共用體中最大的成員。

union Data
{
    int i;
    float f;
    char str[20];
}data;

int main()
{
    union Data data;
    data.i = 11;
}

1.6 typedef

• 定義一種類型的別名，而不只是簡單的宏替換?？梢杂米魍瑫r聲明指針型的多個對象：

char *pa, *pb;//傳統寫法

typedef char* PCHAR; // 使用typedef 寫法  一般用大寫
PCHAR pa, pb; // 可行，同時聲明了兩個指向字符變量的指針

• 用在舊的C的代碼中，幫助 struct。以前的代碼中，聲明 struct 新對象時，必須要帶上 struct，即形式為： struct 結構名 對象名：

struct tagPOINT1
{
int x;
int y;
};
struct tagPOINT1 p1;

//使用 typedef
typedef struct tagPOINT
{
int x;
int y;
}POINT;

POINT p1; // 這樣就比原來的方式少寫了一個struct，比較省事，尤其在大量使用的時候

• 用 typedef 來定義與平臺無關的類型：

#if __ANDROID__
typedef double SUM;
#else
typedef float SUM ;
#endif

int test() {
    SUM a;
    return 0;
}

• 為復雜的聲明定義一個新的簡單的別名：

 //原聲明：
int *(*a[5])(int, char*);
//變量名為a，直接用一個新別名pFun替換a就可以了：
typedef int *(*pFun)(int, char*);
//原聲明的最簡化版：
pFun a[5];

1.7 類的構造和解析、友元函數

1.7.1 C++ 中頭文件（.h）和源文件（.cpp）

• .h 這里一般寫類的聲明（包括類里面的成員和方法的聲明）、函數原型、#define常數等，但一般來說不寫出具體的實現。寫頭文件時，為了防止重復編譯，我們在開頭和結尾處必須按照如下樣式加上預編譯語句：

#ifndef CIRCLE_H
#define CIRCLE_H

class Circle
{
private:
    double r;
public:
    Circle();//構造函數
    Circle(double R);//構造函數
    double Area();
};

#endif

至于 CIRCLE_H 這個名字實際上是無所謂的，你叫什么都行，只要符合規范都行。原則上來說，非常建議把它寫成這種形式，因為比較容易和頭文件的名字對應。

• .cpp 源文件主要寫實現頭文件中已經聲明的那些函數的具體代碼。需要注意的是，開頭必須 #include 一下實現的頭文件，以及要用到的頭文件。

#include "Circle.h"

Circle::Circle()
{
    this->r=5.0;
}
Circle::Circle(double R)
{
    this->r=R;
}
double Circle:: Area()
{
    return 3.14*r*r;
}

• 最后，我們建一個 main.cpp 來測試我們寫的 Circle 類

#include <iostream>
#include "Circle.h"
using namespace std;

int main()
{
    Circle c(3);
    cout<<"Area="<<c.Area()<<endl;
    return 1;
}

1.7.2 構造函數和析構函數

• 類的構造函數是類的一種特殊的成員函數，它會在每次創建類的新對象時執行。構造函數的名稱與類的名稱是完全相同的，并且不會返回任何類型，也不會返回 void。構造函數可用于為某些成員變量設置初始值。
• 類的析構函數是類的一種特殊的成員函數，它會在每次刪除所創建的對象時執行。析構函數的名稱與類的名稱是完全相同的，只是在前面加了個波浪號（~）作為前綴，它不會返回任何值，也不能帶有任何參數。析構函數有助于在跳出程序（比如關閉文件、釋放內存等）前釋放資源。

1.7.3 友元函數、友元類

• 友元函數是一種定義在類外部的普通函數，它不屬于任何類，但它需要在類體內進行說明，為了與該類的成員函數加以區別，在說明時前面加以關鍵字 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 <iostream>
using namespace std;
class girl
{  
private:
    char *name;  
    int age;  
    friend class  boy;   //聲明類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:"<<name<<",age:"<<age<<endl;
    cout<<"girl's name is:"<<x.name<<",age:"<<x.age<<endl; 
    //借助友元，在boy的成員函數disp中，借助girl的對象，直接訪問girl的私有變量
    //正常情況下，只允許在girl的成員函數中訪問girl的私有變量
}
  
void main()  
{   
    boy b("aaa",8);  
    girl g("bbb",99);  
    b.disp(g); 
}

1.8 單例對象、操作符重載

• 我們可以重定義或重載大部分 C++ 內置的運算符。這樣就能使用自定義類型的運算符。重載的運算符是帶有特殊名稱的函數，函數名是由關鍵字 operator 和其后要重載的運算符符號構成的。與其他函數一樣，重載運算符有一個返回類型和一個參數列表。

#include <iostream>
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 <<endl;
 
   // Box2 的體積
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;
 
   // 把兩個對象相加，得到 Box3
   Box3 = Box1 + Box2;
 
   // Box3 的體積
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;
 
   return 0;
}

打印結果：
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 <iostream>
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"<<endl;
    }
};
class B:public A
{
public:
    void foo()
    {
        cout<<"B::foo() is called"<<endl;
    }
};
int main(void)
{
    A *a = new B();
    a->foo();   // 在這里，a雖然是指向A的指針，但是被調用的函數(foo)卻是B的!
    return 0;
}

• 一個類函數的調用并不是在編譯時刻被確定的，而是在運行時刻被確定的。由于編寫代碼的時候并不能確定被調用的是基類的函數還是哪個派生類的函數，所以被稱為“虛”函數。
• 純虛函數是在基類中聲明的虛函數，它在基類中沒有定義，但要求任何派生類都要定義自己的實現方法。在基類中實現純虛函數的方法是在函數原型后加 "=0" ：virtual void funtion()=0
• 將函數定義為純虛函數，則編譯器要求在派生類中必須予以重寫以實現多態性。聲明了純虛函數的類是一個抽象類。所以，用戶不能創建類的實例，只能創建它的派生類的實例。

1.10 類模板、函數模板

• 模板是泛型編程的基礎，泛型編程即以一種獨立于任何特定類型的方式編寫代碼。
• 模板是創建泛型類或函數的藍圖或公式。

模板函數定義的一般形式如下所示：

template <typename type> ret-type func-name(parameter list)
{
   // 函數的主體
}

#include <iostream>
#include <string>
 
using namespace std;
 
template <typename T>
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 type> class class-name {
.
.
.
}

#include <iostream>
#include <vector>
#include <cstdlib>
#include <string>
#include <stdexcept>
 
using namespace std;
 
template <class T>
class Stack { 
  private: 
    vector<T> elems;     // 元素 
 
  public: 
    void push(T const&);  // 入棧
    void pop();               // 出棧
    T top() const;            // 返回棧頂元素
    bool empty() const{       // 如果為空則返回真。
        return elems.empty(); 
    } 
}; 
 
template <class T>
void Stack<T>::push (T const& elem) 
{ 
    // 追加傳入元素的副本
    elems.push_back(elem);    
} 
 
template <class T>
void Stack<T>::pop () 
{ 
    if (elems.empty()) { 
        throw out_of_range("Stack<>::pop(): empty stack"); 
    }
    // 刪除最后一個元素
    elems.pop_back();         
} 
 
template <class T>
T Stack<T>::top () const 
{ 
    if (elems.empty()) { 
        throw out_of_range("Stack<>::top(): empty stack"); 
    }
    // 返回最后一個元素的副本 
    return elems.back();      
} 
 
int main() 
{ 
    try { 
        Stack<int>         intStack;  // int 類型的棧 
        Stack<string> stringStack;    // string 類型的棧 
 
        // 操作 int 類型的棧 
        intStack.push(7); 
        cout << intStack.top() <<endl; 
 
        // 操作 string 類型的棧 
        stringStack.push("hello"); 
        cout << stringStack.top() << std::endl; 
        stringStack.pop(); 
        stringStack.pop(); 
    } 
    catch (exception const& ex) { 
        cerr << "Exception: " << ex.what() <<endl; 
        return -1;
    } 
}

打印結果：
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中優先級最高的元素”。如果同時有多個元素具備最髙優先權，則其次序無明確定義。

特點：
vector 頭部與中間插入和刪除效率較低，在尾部插入和刪除效率高，支持隨機訪問。
deque 是在頭部和尾部插入和刪除效率較高，支持隨機訪問，但效率沒有 vector 高。
list 在任意位置的插入和刪除效率都較高，但不支持隨機訪問。
set 由紅黑樹實現，其內部元素依據其值自動排序，每個元素值只能出現一次，不允許重復，且插入和刪除效率比用其他序列容器高。
map 可以自動建立 Key - value 的對應，key 和 value 可以是任意你需要的類型，根據 key 快速查找記錄。

選擇：
如果需要高效的隨機存取，不在乎插入和刪除的效率，使用 vector。
如果需要大量的插入和刪除元素，不關心隨機存取的效率，使用 list。
如果需要隨機存取，并且關心兩端數據的插入和刪除效率，使用 deque。
如果打算存儲數據字典，并且要求方便地根據 key 找到 value，一對一的情況使用 map，一對多的情況使用 multimap。
如果打算查找一個元素是否存在于某集合中，唯一存在的情況使用 set，不唯一存在的情況使用 multiset。

時間復雜度：
vector 在頭部和中間位置插入和刪除的時間復雜度為 O(N)，在尾部插入和刪除的時間復雜度為 O(1)，查找的時間復雜度為 O(1)；
deque 在中間位置插入和刪除的時間復雜度為 O(N)，在頭部和尾部插入和刪除的時間復雜度為 O(1)，查找的時間復雜度為 O(1)；
list 在任意位置插入和刪除的時間復雜度都為 O(1)，查找的時間復雜度為 O(N)；
set 和 map 都是通過紅黑樹實現，因此插入、刪除和查找操作的時間復雜度都是 O(log N)。

1.12 命名空間

1.12.1 namespace

• 命名空間是一種描述邏輯分組的機制，可以將按某些標準在邏輯上屬于同一個集團的聲明放在同一個命名空間中。用于區分不同庫中相同名稱的函數、類、變量。

namespace namespace_name {
   // 代碼聲明
}

• 無名命名空間。你可以在當前編譯單元中（無名命名空間之外），直接使用無名命名空間中的成員名稱，但是在當前編譯單元之外，它又是不可見的。它可以使代碼保持局部性，從而保護代碼不被他人非法使用。

namespace {
   // 代碼聲明
}

• 不能在命名空間的定義中聲明（另一個嵌套的）子命名空間，只能在命名空間的定義中定義子命名空間。
• 不能直接使用 命名空間名::成員名 …… 定義方式，為命名空間添加新成員，而必須先在命名空間的定義中添加新成員的聲明。
• 命名空間是開放的，即可以隨時把新的成員名稱加入到已有的命名空間之中去。方法是，多次聲明和定義同一命名空間，每次添加自己的新成員和名稱。

1.12.2 using

• 可以使用 using namespace 指令，這樣在使用命名空間時就可以不用在前面加上命名空間的名稱。這個指令會告訴編譯器，后續的代碼將使用指定的命名空間中的名稱。

#include <iostream>
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 <jni.h>
#include <string>
//函數名的構成：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 內部結構如下：
  
  JNIEnv 內部結構
• JavaVM 的結構如下：
  
  JavaVM 結構

3.2 數據類型

3.2.1 基礎數據類型

3.2.2 數組數據類型

數組簡稱：在前面添加 [

3.2.3 復雜數據類型

對象類型簡稱：L+classname +;

3.2.4 函數簽名

(輸入參數...)返回值參數

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 手動釋放。

后續

本文參考了部分視頻、書籍、博客的內容。這里就不列出來了。