Android JNI2--C++基础

袁震

已于 2023-08-12 14:28:55 修改

阅读量834

点赞数 2

分类专栏： android NDK开发文章标签： android c++ 开发语言

于 2023-08-08 20:33:06 首次发布

本文链接：https://blog.csdn.net/y2653904/article/details/132173298

版权

android NDK开发专栏收录该内容

3 篇文章 0 订阅

订阅专栏

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 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<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();

22，list

C++的list 内部采用链表

23，set

C++的set内部是红黑树结构，会对你存入的数据进行排序，但是绝对不允许元素相同

袁震

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
3
评论
Android JNI2--C++基础

对象的声明我们可以写在.h的头文件里，头文件里面只写声明不写实现 .h头文件如下。拷贝构造函数默认有，我们看不到，一旦我们写了拷贝构造函数，会覆盖它。C++和Java一样都是面向对象的语言。前面说到过，std是C++自己的命名空间。C++是支持函数重载的，C语言不支持。Student.cpp文件里面写实现。这样就完成了一个Student对象。
复制链接

扫一扫