Android JNI2--C++基础
1,基础结构
C++标准支持
#include
C语言的标准支持
#include 命名空间 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
using namespace std;//命名空间
class Student {
private: // 下面的代码（成员和函数），都是私有
char * name;
int age;
public: // 下面的代码（成员和函数），都是公开
// set get
void 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函数的 stu
Student(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("AAA", "BBB");
return 0;
} 19,vector
vector是向量类型，它可以容纳许多类型的数据，如若干个整数，所以称其为容器。vector 是C++ STL的一个重要成员，使用它时需要包含头文件:#include
vector.begin() 插入到前面
vector.end() 插入到后面
vector.insert(vector.begin(),20);插入数据
vector.front() 获取第一个
vector.back()获取最后一个
20，stack栈
栈是先进后出，后进先出
stack stackVar;
// 压栈
stackVar.push(30);
stackVar.push(60);
stackVar.push(90);
//弹栈 把栈顶的元素弹出去
stackVar.pop(); 21，队列
队列是先进先出
queue queueVar;//定义队列
//插入队列
queueVar.push(20);
queueVar.push(40);
queueVar.push(60);
//取队列第一个元素
queueVar.front() = 88;
//取队列最后一个元素
queueVar.back() = 88;
//弹出队列
queueVar.pop(); 22，list
C++的list 内部采用链表
23，set
C++的set内部是红黑树结构，会对你存入的数据进行排序，但是绝对不允许元素相同