Android NDK篇-C++语言之运算符重载 与多继承二义性

最新推荐文章于 2024-02-17 18:56:18 发布
最新推荐文章于 2024-02-17 18:56:18 发布
阅读量181 收藏
点赞数
分类专栏： Android NDK 文章标签： c++ c++ 多继承二义性 运算符重载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014078003/article/details/126264102
版权
1.类外运算符重载
class Point {
private:
    int x,y;

public:
    // 系统C++源码，大量使用此方式 :x(x), y(y)
    Point(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;
    }
};

/*类外运算符重载
 * 在真实开发过程中，基本上都是写在类的里面的，外部是不能获取内部的私有成员的
 * */
Point operator + (Point point1,Point point2){
    int x = point1.getX() + point2.getX();
    int y = point1.getY() + point2.getY();

    Point res(x, y);
    return res;
}

int main(){
    Point pointA(10,20);
    Point pointB(10,20);
    Point pointC=pointA+pointB;

    cout << pointC.getX() << " , " << pointC.getY() << endl;

}

日志输出：
20 , 40

两个对象做+法运算就是执行了运算符重载函数

2.类内部运算符号重载
class Point {
private:
    int x,y;

public:

    Point(){}
    // 系统C++源码，大量使用此方式 :x(x), y(y)
    Point(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;
    }

    /*
     * 常量引用：不允许修改，只读模式
     * & 性能的提高，如果没有&  运行+ 构建新的副本，会浪费性能
     * 如果增加了& 引用是给这块内存空间取一个别名而已
     * */
    Point operator + (const Point & point){
        int x=this->x+point.x;
        int y=this->y+point.y;
        return Point(x,y);
    }

    Point operator - (const Point & point){
        int x=this->x-point.x;
        int y=this->y-point.y;
        return Point(x,y);
    }


    void operator ++() { //  ++对象
        this->x = this->x + 1;
        this->y = this->y + 1;
    }

    void operator ++ (int) { // 对象++
        this->x = this->x + 1;
        this->y = this->y + 1;
    }

    /*重载<< 输出运算符号
     * istream 输入 系统的
     * ostream 输出 系统的
     * */
  /*  friend void operator << (ostream & _START,Point &point){
        _START << " 开始输出 " << point.x << " : " << point.y << " 结束了 " << endl;
    }*/

    /*多个<< 连着写 */
  friend ostream & operator << (ostream & _START,Point &point){
      _START << " 开始输出 " << point.x << " : " << point.y << " 结束了 " << endl;
      return _START;
  }


    // istream 输入 系统的
    friend istream & operator >> (istream & _START, Point & point) {
        // 接收用户的输入，把输入的信息
        
        _START >> point.x >> point.y;

        return _START;
    }


};

int main(){
    Point pointA(30,50);
    Point pointB(10,20);

//    Point pointC=pointA-pointB;
    ++pointA;

//    cout << pointA.getX() << " , " << pointA.getY() << endl;
     cout << pointA << pointB <<endl; // 多个的


    Point pointC;
    cin >> pointC; // >> 是我们自己重载的哦
    cout << "你输入的是：" << pointC.getX() << endl;
    cout << "你输入的是：" << pointC.getY() << endl;
}
  • 类内部运算符重载，允许访问私有变量
  • 传入的参数是常量引用，const 表示不可更改，& 可以提升性能，只会有一个变量别名，不加会拷贝一份，浪费内存。
  • << >> 重载，需要加friend 友元函数来进行重载
  • ostream & _START：表示输出
  • istream & _START：表示输入
3.[] 运算符号重载
class ArrayClass {

private:
    int size =0 ; // 大小  开发过程中，给size赋默认值，不然可能会出现，无穷大的问题
    int * arrayValue; // 数组存放 int 类型的很多值

public:

    ArrayClass(){
        /*指针类型必须分配空间*/
        arrayValue= static_cast<int *>(malloc(sizeof(int *) * 10));
    }
    void set(int index, int value) {
        arrayValue[index] = value; // []目前不是我的
        size+=1;
    }
    int getSize() { // size成员的目标：是为了循环可以遍历
        return this->size;
    }
    // 运算符重载 [index]
    int operator[](int index) {
        return this->arrayValue[index]; // 系统的
    }
};

// 输出容器的内容
void printfArryClass(ArrayClass arrayClass) {
    cout << arrayClass.getSize() << endl;
    for (int i = 0; i < arrayClass.getSize(); ++i) {
        cout << arrayClass[i] << endl; // []是我们自己的 重载符号
    }
}

int main(){
    ArrayClass arrayClass;  // 栈区    实例出来的对象，是在堆区了
    arrayClass.set(0, 100);
    arrayClass.set(1, 200);
    arrayClass.set(2, 300);
    arrayClass.set(3, 400);
    arrayClass.set(4, 500);
    printfArryClass(arrayClass);
}
4.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();
    }
};
  • 默认是 隐式代码： : private Person
  • 私有继承：在子类里面是可以访问父类的成员，但是在类的外面不行
  • 必须公开继承，才可以访问父类的成员
  • 先执行父类的构造函数，再执行子类的构造函数
5.多继承
class BaseActivity1 {
public:
    void onCreate() {
        cout << "BaseActivity1 onCreate" << endl;
    }

    void onStart() {
        cout << "BaseActivity1 onStart" << endl;
    }

    void show() {
        cout << "BaseActivity1 show" << endl;
    }
};

class BaseActivity2 {
public:
    void onCreate() {
        cout << "BaseActivity2 onCreate" << endl;
    }

    void onStart() {
        cout << "BaseActivity2 onStart" << endl;
    }

    void show() {
        cout << "BaseActivity2 show" << endl;
    }
};

// 子类 继承 二个父类
class MainActivity1 : public BaseActivity1, public BaseActivity2{
public:
    void onCreate() {
        cout << "MainActivity1 onCreate" << endl;
    }

    void onStart() {
        cout << "MainActivity1 onStart" << endl;
    }

    void showSonInfo() {
        cout << "MainActivity1 showSonInfo" << endl;
    }

   
   // void show() {
     //   cout << "MainActivity1 show" << endl;
    //}

};

int main(){
    // 这个是优先寻找子类的函数，因为特别明确，没有问题，还没有产生歧义（二义性）
    MainActivity1 mainActivity1; // 子类
    mainActivity1.onCreate();
    mainActivity1.onStart();
    mainActivity1.showSonInfo();

    // 不明确，二义性，歧义  /*request for member ‘show’ is ambiguous*/
//     mainActivity1.show();

    /*解决二义性 通过.来引出父类 然后再调用*/
    mainActivity1.BaseActivity3::show();
    mainActivity1.BaseActivity2::show();
    mainActivity1.BaseActivity1::show();


    // 解决方案二： 子类上 重写父类的show函数
    mainActivity1.show();
}
  • c++ 允许多继承，可能会出现二义性，原则上是尽量避免二义性
  • 通过明确父类的方式解决二义性
  • 通过子类重写父类的方法规避二义性
6.通过虚继承来解决二义性问题
// 祖父类
class Object{
public:
    int number;
    void show() {
        cout << "Object show run..." << endl;
    }
};

// 父类1
class BaseActivity1 : virtual public Object {
};

// 父类2
class BaseActivity2 : virtual public Object {

};

// 子类
class Son : public BaseActivity1, public BaseActivity2 {

};

int main(){
    Object object;
    BaseActivity1 baseActivity1;
    BaseActivity2 baseActivity2;
    Son son;

    object.number = 100;
    baseActivity1.number = 200;
    baseActivity2.number = 300;
    son.number = 400;

    object.show();
    baseActivity1.show();
    baseActivity2.show();
    son.show();

    cout << object.number << endl;
    cout << baseActivity1.number << endl;
    cout << baseActivity2.number << endl;
    cout << son.number << endl;

}
  • 如果没有虚继承，那么son对象访问number就会报二义性的问题，同时访问show方法同样存在二义性问题
  • 由于在继承的时候添加了虚继承，就能解决类似这样的问题，虚继承的含义是：将通过继承得来的number和show方法，放置在另外一个统一空间上，这样子类再访问的时候就不会出现二义性的问题了。
若之灵动
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 运算符重载（二） | 类型转换运算符，二义性问题
Jormungand_V的博客
09-17 969
文章目录类型转换运算符概念避免过度使用类型转换函数解决上述问题的方法转换为 bool显式的类型转换运算符类型转换二义性重载函数与类型转换结合导致的二义性重载运算符与类型转换结合导致的二义性 类型转换运算符 概念 类型转换运算符（conversion operator）是类的一种特殊成员函数。负责将一个类类型的值转换成其他类型。 operator type() const ; 其中 type 表示某种类型。类型转换运算符可以面向任意类型（除了 void 之外）进行定义，只要该类型能作为函数的返回类型。因此
Android Application 多继承
Eshel的博客
12-22 6119
Android Application 多继承 首先，附上Demo链接：https://github.com/EshelGuo/AppMultipleExtends/tree/master  众所周知，Java里的继承都是单继承，而我们今天的话题是通过反射实现Application多继承。那么为什么非要Application多继承呢？想必大家在做项目的时候肯定集成很多SDK吧，也应该遇见过一部分S
android-ndk（android-ndk-r25b-windows.zip）
10-20
android-ndk（android-ndk-r25b-windows.zip）适用于Windows系统
android-ndk（android-ndk-r26b-windows.zip）
10-20
android-ndk（android-ndk-r26b-windows.zip）适用于Windows系统
【Android进阶笔记】NDK-C++面向对象（封装、继承、多态、RVO、NRVO）
Android学习笔记
03-09 347
文章目录1. 类与对象1.1. C++ 类定义1.1.1. 类访问修饰符1.1.2. 构造函数 & 析构函数1.1.3. 静态成员1.2. C++ 函数1.2.1. 拷贝构造函数1.2.2. 友元函数1.2.3. 内联函数2. 函数重载和运算符重载2.1. 函数重载2.2. 运算符重载2.2.1. 可重载运算符2.2.2. 不可重载运算符3. 封装4. 继承4.1. 继承类型4.2. 多继承4.3. 基类 & 派生类5. 多态5.1. 静态多态5.2. 动态多态（虚函数）5.2.1. 虚函数
多用继承 android,Android温习之路之继承
weixin_26875051的博客
06-04 531
描述首先说一下继承的好处：1.提高了代码的复用性2.让类和类之间产生了关系(关系是多态的前提)将对像中的内容不断的向上抽取，就形成了关系，就有了继承，就有父子类，提高了代码的复用性。继承的特点：java语言当中的继承只能单继承单继承：一个类只能有一个父类，可以理解为一个儿子只能有一个父亲。多继承：一个类可以有多个父类，一个儿子有多个父亲下面简单用个例子来解释一下：class A{void show...
android继承多个类,关于Android类和继承的问题
weixin_33462050的博客
05-26 457
该楼层疑似违规已被系统折叠隐藏此楼查看此楼首先我新建了一个类Title类public class Title extends Activity {private TextView tx;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContent...
C++ - 类型转换和二义性
一只羊
11-23 346
类型转换： // 类型转换测试 class SmallInt { friend SmallInt operator+(const SmallInt &lhs, const SmallInt &rhs); public: SmallInt(int i = 0) : val(i) {} explicit operator bool() { return bool(val); } operator in
Android Activity继承体系梳理
最新发布
xiaokangss的博客
02-17 702
Activity的子类往往是用于引入新特性。这些新特性从理论上会逐步往基类Activity里面迁移，从而减轻开发者的认知成本。截止到2024年，我们的应用很少需要兼容4.4（Kikkat）以下，因此继承ComponentActivity即可。如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。
Android C++系列：C++最佳实践2多重继承与虚继承
Android 开发架构
06-01 254
Java和C++在语法层面比较的时候就不得不提到C++的多继承，我们知道Android是单继承，C++是多继承。在大型项目中不可避免的会用到多继承，本文分析C++多继承的一些特征。C++中，我们可以在派生列表中包含多个基类： 关于多继承的几点说明：在多继承中，子类的对象包含每个基类的子对象，比如Sub继承Base1，Base2，Base1又继承自Base，那么Sub对象的结构如下图：构造一个派生类的对象将同时构造并初始化它的所有基类子对象，并且多重继承的派生类的构造函数值也只能初始化它的直接子类。子类的构造
Hydra:Android风格多重继承项目
06-16
九头蛇 Android 风格的多继承项目。
android 多个application怎么使用
07-18
在android中必须要有一个application，那我们用第三方的时候多个application如何使用，这是一个demo，值得你看一下
android-ndk（android-ndk-r23b-windows.zip）
10-20
android-ndk（android-ndk-r23b-windows.zip）适用于Windows系统
android-ndk（android-ndk-r25b-linux.zip）
10-20
android-ndk（android-ndk-r25b-linux.zip）适用于Linux系统
android-ndk（android-ndk-r25b-darwin.zip）
10-20
android-ndk（android-ndk-r25b-darwin.zip）适用于macOS系统
android多重继承,详解C++多重继承
weixin_29170089的博客
06-03 280
本文转载自：http://blog.csdn.net/wuliming_sc/article/details/3832583多重继承《C++ primer 3th》P794~798为支持多继承，一个类的派生表：class Bear : public ZooAnimal { ... };被扩展成支持逗号分割的基类表。例如：class Panda : publicBear, publicEndan...
Android NDK开发之旅23 C++ 继承、多态与接口
weixin_34129145的博客
01-18 113
###C++ 继承 面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行时间的效果。 当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。 继承代表了 is a 关系。例如，哺乳动物是动物，狗是哺乳动...
Android NDK开发入门 jni javah使用（类继承Activity）
qq_26410361的博客
04-14 521
javah找不到android.app.Activity的类文件 使用javah 1.java下载以及环境变量的设置，在CMD中输入javah 如下图： 如果现实没有命令，先按照Java，再查看Java环境变量是否配置成功 2.有些人说能直接在通过源代码来生成jni的头文件，但我不行，我是通过编译后的class文件来生成的，具体步骤如下 2-1.
android继承多个接口,关于android：Java：由于继承，多次实现相同的接口。 可以吗...
weixin_42380646的博客
05-27 375
这个问题主要与继承和扩展的工作方式有关。我目前有以下内容：public class Client extends BaseClient { ... }和public class BaseClient extends MinimalisticClient { ... }它们之间的主要区别是它们持有(从数据库中获取)的参数(数据)的数量。我要做的是为每个仅包含吸气剂的接口创建一个接口。因此，它将类似于...
android-ndk-r20b下载
11-21
Android NDK（Native Development Kit）是一个用于...总而言之，您可以通过访问 Android NDK 的官方网站并按照官方的指引来下载并开始使用 android-ndk-r20b，以便使您的 Android 应用程序充分发挥 C/C++ 的编程能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值