Android JNI--C++基础

1,基础结构

C++标准支持
#include <iostream>C语言的标准支持
#include <stdio.h>

命名空间 C++的特性  std  C++系统的命名空间 也可以自定义
using namespace std;

C++中命名空间的作用类似于操作系统中的目录和文件的关系，由于文件很多，不便管理，而且容易重名，于是设立若干子目录，把文件放到不同的子目录中，不同子目录中的文件可以同名，而调用文件时应指出文件路径。
命名空间的作用是建立一些互相分隔的作用域，把一些全局实体分隔开来,以免产生名字冲突

C++打印方法：

cout << "hello,world!" << "~你好"<< endl;输出hello,world!~你好

2，常量引用

常量引用不可以修改，只能读：

定义一个Person类
typedef struct {char name[20];int age;
}Person;void printPerson(const Person & person) {// strcpy(person.name, "张三"); 这样是错误的，不能修改// 只能读 不能操作cout << person.name << "," << person.age << endl;
}int main() {Person person= {"王五", 38};printPerson(person);return 0;
}

3，函数重载

C++是支持函数重载的，C语言不支持

int add(int number1) {return number1;
}int add(int number1, int number2) {return number1 + number2;
}int add(int number1, int number2, int number3) {return number1 + number2 + number3;
}int main() {add(999);add(999, 777);add(100, 200, 888);return 0;
}

要注意函数重载的二义性，比如：

int add(int number1, int number2) {return number1 + number2;
}int add(float number1, float number2) {return number1 + number2;
}int main() {add(17.8, 19.8);return 0;
}传入的参数都是double类型，不符合上面两个方法的任意一个，就出现了二义性

4，面向对象

C++和Java一样都是面向对象的语言

对象的声明我们可以写在.h的头文件里，头文件里面只写声明不写实现 .h头文件如下

#include <iostream>using namespace std;//命名空间class Student {private: // 下面的代码（成员和函数），都是私有char * name;int age;public: // 下面的代码（成员和函数），都是公开// set getvoid setAge(int age); // 声明函数void setName(char * age); // 声明函数int getAge(); // 声明函数char * getName(); // 声明函数
};

Student.cpp文件里面写实现

#include "Student.h" //引入头文件// 根据 Student.h 头文件 ，写实现void Student::setAge(int age) { // 实现函数// C++对象指向的是一个指针// -> 调用一级指针的成员this->age = age;
}void  Student::setName(char * name) { // 实现函数this->name = name;
}
int Student::getAge() { // 实现函数return this->age;
}
char * Student:: getName() { // 实现函数return this->name;
}

这样就完成了一个Student对象

在栈区开辟空间：

Student student1; // 栈区开辟空间
student1.setAge(99);
student1.setName("张三");
cout << "name:" << student1.getName() << " ,age:" << student1.getAge() << endl;

在堆区开辟空间：

Student * student2 = new Student(); // new/delete
student2->setAge(88);
student2->setName("张三");cout << "name:" << student2->getName() << " ,age:" << student2->getAge() << endl;if (student2)
delete student2; // 必须手动释放堆空间的对象student2
student2 = NULL; // 指向NULL的地址区域

5，命名空间

前面说到过，std是C++自己的命名空间

那么我们还可以自定义命名空间：

namespace zhangsan {int age = 88;char * name = "张三啊";void show() {cout << "name:" << name << ", age:" << age << endl;}
}namespace zhangsan2 {void show() {}
}int main() {// 声明自己的命名空间using namespace zhangsan;int ageValue = zhangsan::age; // 方式1 使用 刚刚声明的命名空间zhangsan::show(); // 使用 刚刚声明的命名空间ageValue = age; // 方式2 直接去引出来 ::show(); // 直接去引出来 ::// 命名空间里面重复的函数using namespace zhangsan2;zhangsan::show();zhangsan2::show();return 0;
}

6，构造函数和析构函数

class Student {// 构造函数
public:// 空参数构造函数Student() {cout << "空参数构造函数" << endl;}// 一个参数的构造函数// :Student(name, 87) 等价 1.调用两个参数的构造函数， 2.再调用当前函数Student(char *name) :Student(name, 87) {cout << "一个参数的构造函数" << endl;this->name = name;}// 两个参数的构造函数Student(char *name, int age) {// this->name = name;// 堆区this->name = (char *) (malloc(sizeof(char *) * 10));strcpy(this->name, name);this->age = age;cout << "两个参数的构造函数" << endl;}// 析构函数 Student对象被回收了，做一些释放工作// delete stu 的时候，我们的析构函数一定执行// free不会执行析构函数，也意味着，你没法在析构函数里面，做释放工作， malloc也不会调用构造函数~Student() {cout << "析构函数" << endl;// 必须释放 堆区开辟的成员if (this->name) {free(this->name);this->name = NULL; // 执行NULL的地址，避免出现悬空指针}}// 私有属性
private:char *name;int age;// 公开的 set get 函数
public:int getAge() {return this->age;}char *getName() {return this->name;}void setAge(int age) {this->age = age;}void setName(char *name) {this->name = name;}
};

栈区开辟空间：

int main() {Student stu; // 调用 空参数构造函数
stu.setAge(38);
stu.setName("张三");
cout << "name:" << stu.getName() << ", age:" << stu.getAge() <<  endl;
}

堆区开辟空间:

// *stu  ->：调用一级指针的成员
// new/delete
// C++中，必须使用 new/delete 一套
Student *stu = new Student("张三", 26);
cout << "name:" << stu->getName() << ", age:" << stu->getAge() <<  endl;
delete stu;

new/delete 是一套  会调用构造函数 与 析构函数 malloc/free是一套  不调用构造函数 与 析构函数

7，拷贝构造函数

拷贝构造函数默认有，我们看不到，一旦我们写了拷贝构造函数，会覆盖它

    // 覆盖拷贝构造函数Student(const Student & student) { // 常量引用：只读的，不让你修改cout << "拷贝构造函数" << endl;this->name = student.name;this->age = student.age;}

    Person person1 = {88, "张三"};// = 你看起来，没有什么特殊，隐士的代码：你看不到  C/C++编译器 会把p1的成员值赋值给p2成员Person person2 = person1;

     Student stu1("张三", 88);Student stu2;stu2 = stu1; // 这样赋值是不会调用 自定义拷贝构造函数，但是会调用默认赋值Student stu2 = stu1;  // 这样赋值是会调用 自定义拷贝构造函数，我们自己赋值

 Student *student1 = new Student("张三", 88);Student *student2 = student1; 压根就不会执行拷贝构造函数（指针指向问题）

8，指针常量

int number = 9;// 常量指针
const int * numberP1 = &number;
// *numberP1 = 100; // 报错，不允许去修改【常量指针】存放地址所对应的值
// numberP1 = &number2; // OK，允许重新指向【常量指针】存放的地址//  指针常量
int* const numberP2 = &number;
*numberP2 = 100; // OK，允许去修改【指针常量】存放地址所对应的值
// numberP2 = &number2; // 报错，不允许重新指向【指针常量】存放的地址// 常量指针常量
const int * const numberP3 = &number;
// *numberP3 = 100; // 报错，不允许去修改【常量指针常量】存放地址所对应的值
// numberP3 = &number2; // 报错，不允许重新指向【常量指针常量】存放的地址

9，浅拷贝与深拷贝

浅拷贝：将原对象或原数组的引用直接赋给新对象，新数组，新对象/新数组只是原对象的一个引用。

深拷贝：创建一个新的对象和数组，将原对象的各项属性的“值”（数组的所有元素）拷贝过来，是“值”而不是引用，深拷贝会在堆内存中另外申请空间来储存数据，从而解决了指针悬挂问题。当数据成员中有指针时，必须要用深拷贝

下面来看浅拷贝的使用：

class Student
{
public:int age;char * name;Student() { cout << "空参数构造函数" << endl; }Student(char * name) :Student(name, 99) {cout << "一个参数构造函数 this:" << this << endl;}Student(char * name, int age) {cout << "二个参数构造函数 this:" << this << endl;this->name = (char *)malloc(sizeof(char *)* 10);strcpy(this->name, name);this->age = age;}~Student() {cout << "析构函数执行 &this->name:" << &this->name << endl;free(this->name);this->name = NULL;}// 此拷贝构造函数执行完 会出现一个 this==新地址  给 main函数的 stuStudent(const Student & stu) {// stu 旧地址// this 新地址cout << "拷贝构造函数 &stu:" << &stu << " this:" << this << endl;// 新地址name = 旧地址 （浅拷贝）this->name = stu.name;} };

Student getStudent(char * name) {Student stu(name); // 旧地址cout << "getStudent函数:" << &stu << endl; // 旧地址return stu; // stu 旧地址
}

void main() {Student stu = getStudent("张三");cout << "main函数:" << &stu << endl;
}

执行main函数会发现打印如下：

二个参数构造函数 this:008FF999 旧地址

一个参数构造函数 this:008FF999 旧地址

getStudent函数:008FF999 旧地址

拷贝构造函数 &stu:008FF999 旧地址  this：008FF988 新地址

析构函数执行 &this->name:008FF988 新地址

main函数：008FF988 新地址

下面来看深拷贝的使用：

在Student.cpp中，其余都和浅拷贝一样，区别是：

	~Student() {cout << "析构函数执行 &this->name:" << (int)this->name << endl;free(this->name);this->name = NULL;}Student(const Student & stu) {cout << "拷贝构造函数 &stu:" << (int)&stu << " this:" << (int)this << endl;// 深拷贝this->name = (char *)malloc(sizeof(char *)* 10);strcpy(this->name, name);this->age = stu.age;cout << "拷贝构造函数 this->name:" << ((int) this->name) << "  stu.name:" << (int)stu.name << endl;}

10，C++可变参数

Java的可变参数的写法：int ...

C++的可变参数的写法：...

void sum(int count, ...) {va_list vp; // 可变参数的动作// 参数一：可变参数开始的动作vp// 参数二：内部需要一个 存储地址用的参考值，如果没有第二个参数，内部他无法处理存放参数信息va_start(vp, count);// 到这里后：vp就已经有丰富的信息// 取出可变参数的一个值int number  = va_arg(vp, int);cout << number << endl;// 取出可变参数的一个值number  = va_arg(vp, int);cout << number << endl;// 取出可变参数的一个值number  = va_arg(vp, int);cout << number << endl;// 越界 系统值 乱码// 取出可变参数的一个值 【娶不到后，会取系统值 乱码】number  = va_arg(vp, int);cout << number << endl;// 关闭阶段va_end(vp);
}// 1.可变参数
int main() {sum(546, 6,7,8);return 0;
}

11，static关键字

静态可以直接通过类名::静态成员（属性，函数）调用

静态的属性必须要初始化，然后再实现

静态的函数只能够操作静态的属性和方法

class Person {
public:char * info;int age;// 先声明static int id;static void update() {id += 90;// 静态函数不能调用非静态函数// update2();}void update2() {id = 88;}
};// 再实现
int Person::id = 9;int main() {Person person;person.update2(); // 普通函数Person::update(); // 静态函数return 0;
}

12,友元函数

友元函数是一种特殊的函数，它可以访问并操作类的私有成员，即使它不是类的成员函数。通过友元函数，我们可以实现对类的私有成员的非成员函数访问权限。

友元函数的特性:

(1) 友元函数可以访问类的私有和保护成员，但不是类的成员函数。

(2) 友元函数不能被const修饰。由于友元函数不属于任何类的成员函数，它们无法被 const 修饰。

(3) 友元函数可以在类定义的任何地方声明，不受类访问限定符限制。

(4) 一个函数可以是多个类的友元函数。

(5) 友元函数的调用与普通函数的调用和原理相同。

class Person {
private: // 私有的age，外界不能访问int age = 0;public:Person(int age) {this->age = age;}int getAge() {return this->age;}// 定义友元函数 (声明，没有实现)friend void updateAge(Person * person, int age);
};// 友元函数的实现，可以访问所以私有成员
void updateAge(Person* person, int age) {// 默认情况下：不能修改 私有的age// 谁有这个权限：友元（拿到所有私有成员）person->age = age;
}
int main() {Person person = Person(9);updateAge(&person, 88);cout << person.getAge() << endl;return 0;
}

13,运算符重载

运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。
运算符重载的目的是让语法更加简洁
运算符重载不能改变本来寓意，不能改变基础类型寓意
运算符重载的本质是另一种函数调用（是编译器去调用）
这个函数统一的名字叫operator
重载函数可以写成全局或成员函数
重载函数如果写成全局的，那么双目运算符左边的是第一个参数，右边是第二个参数
重载函数如果写成成员函数，那么双目运算符的左边是this，右边是第一个参数
不能改变运算符优先级，不能改变运算符的参数个数。
下面重载一个+运算符：

class Person {
private:int x,y;public:Person(int x, int y) :x(x), y(y) {}// set get 函数void setX(int x) {this->x = x;}void setY(int y) {this->y = y;}int getX() {return this->x;}int getY() {return this->y;}
};// 把+重载 运算符重载
Person operator + (Person p1, Person p2) {int x = p1.getX() + p2.getX();int y = p1.getY() + p2.getY();Person p(x, y);return p;
}int main() {Person p1(1000, 2000);Person p2(3000, 4000);Person p= p1 + p2; return 0;
}

14,继承

与Java不同的是，C++的继承默认是隐式私有继承，在子类里面可以访问父类的成员，但是在类的外面不行，必须公开继承才可以访问父类的成员

class Person {
public:char *name;int age;public:Person(char *name, int age) : name(name) {this->age = age;cout << "Person 构造函数" << endl;}void print() {cout << this->name << " , " << this->age << endl;}
};

class Student : public Person {
private:char * course;public:// :父类 , 给自己子类成员初始化Student(char * name, int age, char* course) : Person(name, age) , course(course) {cout << "Student 构造函数" << endl;}void test() {cout << name << endl;cout << age << endl;print();}
};

C++是支持多继承的，Java是单继承多实现

多继承的缺点就是容易穿线二义性，解决方法就是子类重写父类具有二义性的函数或者明确指定父类

class BaseActivity1 {
public:void onCreate() {cout << "BaseActivity1 onCreate" << endl;}void show() {cout << "BaseActivity1 show" << endl;}
};class BaseActivity2 {
public:void onCreate() {cout << "BaseActivity2 onCreate" << endl;}void show() {cout << "BaseActivity2 show" << endl;}
};class BaseActivity3 {
public:void onCreate() {cout << "BaseActivity3 onCreate" << endl;}void show() {cout << "BaseActivity3 show" << endl;}
};// 子类 继承 三个父类
class MainActivity1 : public BaseActivity1, public BaseActivity2, public BaseActivity3 {
public:void onCreate() {cout << "MainActivity1 onCreate" << endl;}void showSonInfo() {cout << "MainActivity1 showSonInfo" << endl;}// 解决方案二： 子类上 重写父类的show函数void show() {cout << "MainActivity1 show" << endl;}};int main() {// 这个是优先寻找子类的函数，因为特别明确，没有问题，还没有产生歧义（二义性）MainActivity1 mainActivity1; // 子类mainActivity1.onCreate();mainActivity1.showSonInfo();// 不明确，二义性，歧义// mainActivity1.show();// 解决方案一： 明确指定父类 ::mainActivity1.BaseActivity3::show();mainActivity1.BaseActivity2::show();mainActivity1.BaseActivity1::show();// 解决方案二： 子类上 重写父类的show函数mainActivity1.show();return 0;
}

15，多态

C++默认关闭多态，开启的话，需要在父类上给函数增加virtual关键字

class BaseActivity {
public:virtual void onStart() {cout << "BaseActivity onStart" << endl;}
};
class HomeActivity : public BaseActivity {
public:void onStart() { // 重写父类的函数cout << "HomeActivity onStart" << endl;}
};class LoginActivity : public BaseActivity {
public:void onStart() { // 重写父类的函数cout << "LoginActivity onStart" << endl;}
};void startToActivity(BaseActivity * baseActivity) {baseActivity->onStart();
}
int main() {HomeActivity *homeActivity = new HomeActivity();LoginActivity *loginActivity = new LoginActivity();startToActivity(homeActivity);startToActivity(loginActivity);if (homeActivity && loginActivity) delete homeActivity; delete loginActivity;cout << endl;BaseActivity * activity1 = new HomeActivity();BaseActivity * activity2 = new LoginActivity();startToActivity(activity1);startToActivity(activity2);return 0;
}

16，纯虚函数

C++没有抽象类，所以C++的纯虚函数的类相当于Java的抽象类

virtual string getLayoutID() = 0; // 纯虚函数

17，全虚函数

全虚函数类里面的所有函数都是纯虚函数，类似于Java的接口

class ISudent_DB {virtual void insertStudent(Student student) = 0;virtual void deleteStudent(int _id) = 0;virtual void updateStudent(int _id, Student student) = 0;virtual Student queryByStudent(Student student) = 0;
};

18，模板函数

C++的模板函数，类似于Java的泛型

void addAction(TT n1, TT n2) {cout << "模板函数：" << n1 + n2 << endl;
}int main() {addAction(1, 2);addAction(10.2f, 20.3f);addAction(545.34, 324.3);addAction<string>("AAA", "BBB");return 0;
}

19,vector

vector是向量类型，它可以容纳许多类型的数据，如若干个整数，所以称其为容器。vector 是C++ STL的一个重要成员，使用它时需要包含头文件:#include <vector>

vector.begin() 插入到前面
vector.end() 插入到后面
vector.insert(vector.begin(),20);插入数据
vector.front() 获取第一个
vector.back()获取最后一个

20，stack栈

栈是先进后出，后进先出

stack<int> stackVar;// 压栈stackVar.push(30);stackVar.push(60);stackVar.push(90);//弹栈 把栈顶的元素弹出去stackVar.pop();

21，队列

队列是先进先出

    queue<int> queueVar;//定义队列//插入队列queueVar.push(20);queueVar.push(40);queueVar.push(60);//取队列第一个元素queueVar.front() = 88;//取队列最后一个元素queueVar.back() = 88;//弹出队列queueVar.pop();