首页
学习
活动
专区
工具
TVP
发布
精选内容/技术社群/优惠产品,尽在小程序
立即前往

C++:使用父类运算符函数更新子类对象的继承变量

在C++中,父类运算符函数不能直接更新子类对象的继承变量。继承是一种面向对象编程的概念,它允许子类继承父类的属性和方法。当子类继承父类时,子类会拥有父类的所有成员变量和成员函数。

然而,父类的运算符函数只能操作父类的成员变量,无法直接访问或更新子类的成员变量。这是因为子类的成员变量可能与父类的成员变量不同,子类可能有自己独有的成员变量。

如果需要在父类中定义一个运算符函数来更新子类对象的继承变量,可以考虑使用虚函数和多态的特性。通过在父类中定义一个虚函数,然后在子类中重写该虚函数,可以实现对子类对象的成员变量进行更新操作。

以下是一个示例代码:

代码语言:cpp
复制
#include <iostream>

class Parent {
protected:
    int inheritedVariable;

public:
    Parent(int value) : inheritedVariable(value) {}

    virtual void updateInheritedVariable(int value) {
        inheritedVariable = value;
    }

    void printInheritedVariable() {
        std::cout << "Inherited Variable: " << inheritedVariable << std::endl;
    }
};

class Child : public Parent {
public:
    Child(int value) : Parent(value) {}

    void updateInheritedVariable(int value) override {
        inheritedVariable = value * 2;
    }
};

int main() {
    Parent* parent = new Child(10);
    parent->printInheritedVariable();  // Output: Inherited Variable: 10

    parent->updateInheritedVariable(5);
    parent->printInheritedVariable();  // Output: Inherited Variable: 10

    Child* child = dynamic_cast<Child*>(parent);
    child->updateInheritedVariable(5);
    child->printInheritedVariable();  // Output: Inherited Variable: 10

    delete parent;
    return 0;
}

在上述示例中,父类Parent中定义了一个虚函数updateInheritedVariable,该函数用于更新继承变量inheritedVariable的值。子类Child重写了该虚函数,并在其中对继承变量进行了更新操作。

然后,在main函数中,创建了一个指向子类对象的父类指针parent。通过调用parent->updateInheritedVariable(5),无法直接更新子类对象的继承变量。但是,通过使用dynamic_cast将父类指针转换为子类指针child,可以调用child->updateInheritedVariable(5)来更新子类对象的继承变量。

需要注意的是,虚函数和多态的使用需要谨慎,确保在正确的上下文中使用,以避免潜在的错误和问题。

腾讯云相关产品和产品介绍链接地址:

页面内容是否对你有帮助?
有帮助
没帮助

相关·内容

C++继承 ⑥ ( 继承构造函数和析构函数 | 类型兼容性原则 | 指针 指向 子类对象 | 使用 子类对象对象 进行初始化 )

一、public 公有继承 - 示例分析 1、类型兼容性原则 类型兼容性原则 : C++ " 类型兼容性原则 “ 又称为 ” 赋值兼容性原则 " ; 子类代替父 : 需要 基 ( ) 对象...地方 , 都可以使用 " 公有继承 " 派生 ( 子类 ) 对象 替代 , 该 派生 ( 子类 ) 得到了 除 构造函数 和 析构函数 之外 所有 成员变量 和 成员方法 ; 功能完整性 :..." 公有继承 " 派生 ( 子类 ) 本质上 具有 基 ( ) 完整功能 , 使用 可以解决问题 , 使用 公有继承派生 都能解决 ; 特别注意 : " 保护继承 " 和..." 应用场景 : 直接使用 : 使用 子类对象 作为 对象 使用 ; 赋值 : 将 子类对象 赋值给 对象 ; 初始化 : 使用 子类对象对象 初始化 ; 指针 : 指针 指向...); } 2、使用 子类对象对象 进行初始化 定义父对象 , 可以直接使用 子类对象 进行初始化操作 ; // II.

28220

【Python】面向对象 - 继承 ② ( 子类重写成员 | 子类调用重名成员 | 子类使用 名 调用成员 | 子类使用 super 调用成员 )

一、子类重写成员 1、子类重写成员语法 子类 继承 成员属性 与 成员方法 后 , 如果对 继承 成员 不满意 , 可以 重写 成员 ; 成员 属性 和 成员 方法 , 都可以进行重写...1、子类调用重名成员语法 在 外部 是无法访问 成员 : 子类 重写 成员后 , 通过 子类 实例对象 调用 该 重写后 成员时 , 默认调用就是 重写后成员 ; 在 子类内部 可以...访问成员 : 如果需要调用被重写之前 成员 , 则需要使用如下方法 : 方法一 : 使用 名 调用成员 ; 调用类同名成员变量 : 名.成员变量名 调用类同名成员方法...) 2、代码示例 - 子类使用 名 调用成员 在 Dog 子类 make_sound 函数中 , 通过 Animal.name 和 Animal.age 可以调用成员变量 , 打印出来值为成员变量值...super 调用成员 在 Dog 子类 make_sound 函数中 , 通过 super().name 和 super().age 可以调用成员变量 , 打印出来值为成员变量

59730
  • C++继承 ⑥ ( 类型兼容性原则 | 指针 指向 子类对象 | 使用 子类对象对象 进行初始化 )

    一、public 公有继承 - 示例分析 1、类型兼容性原则 类型兼容性原则 : C++ " 类型兼容性原则 “ 又称为 ” 赋值兼容性原则 " ; 子类代替父 : 需要 基 ( ) 对象...地方 , 都可以使用 " 公有继承 " 派生 ( 子类 ) 对象 替代 , 该 派生 ( 子类 ) 得到了 除 构造函数 和 析构函数 之外 所有 成员变量 和 成员方法 ; 功能完整性 :..." 公有继承 " 派生 ( 子类 ) 本质上 具有 基 ( ) 完整功能 , 使用 可以解决问题 , 使用 公有继承派生 都能解决 ; 特别注意 : " 保护继承 " 和..." 应用场景 : 直接使用 : 使用 子类对象 作为 对象 使用 ; 赋值 : 将 子类对象 赋值给 对象 ; 初始化 : 使用 子类对象对象 初始化 ; 指针 : 指针 指向...); } 2、使用 子类对象对象 进行初始化 定义父对象 , 可以直接使用 子类对象 进行初始化操作 ; // II.

    30400

    Java子类之间对象转换(说明继承

    参考链接: 子类在Java中具有相同数据成员 在使用Java多态机制时,常常使用一个特性便是子类之间对象转换。...从子类转换称为向上转换(upcasting),通过向上转换,我们能够在编写程序时采用通用程序设计思想,在需要使用子类对象时候,通过把变量定义为类型,我们可以通过一个变量使用类型所有子类型实例...向上转换比较直观,总是能够将一个子类实例转换为一个对象,从继承角度,这个特性很容易理解:继承是一种“是一种”关系,从父派生出子类,我们都能理解为,子类总是一个实例。...这就要考虑到,在继承关系中,有一些方法是不适合由定义并由子类继承并重写,有些方法是子类特有的,不应该通过继承得到,且子类可能也会有自己特有的成员变量,那么在使用多态机制时候,若我们要通过类型变量使用到这些子类特有的方法和属性的话...首先,变量子类转换必须通过显式强制类型转换,采取和向上转换相同直接赋值方式是不行,;并且,当把一个类型变量实例转换为子类变量时,必须确保该变量子类一个实例,从继承角度来理解这些原因

    3.7K20

    C++ 语言】面向对象 ( 继承 | 重写 | 子类调用方法 | 静态多态 | 动态多态 | 虚函数 | 纯虚函数 )

    文章目录 继承 方法重写 子类中调用方法 多态 虚函数函数示例 纯虚函数 相关代码 继承 ---- 1....继承表示 : C++继承可以使用 “:” 符号 , 格式为 "class 子类名称 : 名称{};" // class Parent{ }; //子类 //继承 Parent class...C++继承 : Java 中只能进行单继承 , 但是在 C++ 中是可以继承多个 ; 在多继承时 , 使用 “,” 将多个分隔即可 ; 5....虚函数解析 : 在对象调用虚函数方法时 , 系统会查看该对象真正类型是什么类型 , 然后去调用对应类型方法 ; 对象使用什么类型构造函数创建 , 其真正类型就是这个类型 , 因此最终调用该类中函数方法...virtual_method 方法 , 该方法时虚函数 , 子类重写了该虚函数 , 在函数调用时候 , 会自动根据对象类型判定调用哪个方法 , 该对象使用 new Child() 创建 , 其类型是

    1.5K20

    子类A继承B, A a = new A(); 则B构造函数B静态代码块、B非静态代码块、子类A构造函数子类A静态代码块、子类A非静态代码块 执行先后顺序是?

    (1)子类A继承B, A a = new A(); 则: B静态代码块->子类A静态代码块->B非静态代码块->B构造函数->子类A非静态代码块->子类A构造函数 (2)若子类构造函数中显式调用了某构造函数..."B"); } public static void main(String[] args) { new Test(); } } CBB 首先new了一个子类对象...,那么就要调用构造方法来初始化该子类对象,但是该类继承自A,所以要先调用构造方法,这里通过super(“B”)显示调用了带参构造。...执行带参构造前要先对对象进行初始化,对c成员进行初始化,调用了C无参构造,所以调用顺序为: 先调用C无参构造 再调用A带参构造 最后调用调用子类构造 (3...顺序为:静态变量静态代码块 ,子类静态变量子类静态代码块。

    2.1K30

    子类继承,重写synchronized方法,两个synchronized方法对象问题

    参考链接: 用子类引用子类对象 vs 引用 这是java并发编程实践中有关重入概念介绍时产生问题  public class Widget {       public synchronized...System.out.println(toString() + ": calling doSomething");           super.doSomething();       }   }  子类继承...,重写synchronized方法,两个synchronized方法对象问题  是同一个锁还是不同锁呢,是同一个锁的话是  对象作为锁还是子类对象作为锁呢? ...,那么另一个线程仍然可以获得子类对象锁。...,至于理解么:  可以认为即便是继承创建了对象,并把对象引用交给了子类,但是在super.去调用方法时候JVM认为调用者依然是子类

    1.8K20

    C++继承 ③ ( 继承一些重要特性 | 子类拥有所有成员 | 多态性 | 子类可以拥有没有的成员 | 代码示例 )

    一、继承一些重要特性 1、子类拥有所有成员 子类 继承 , 则 子类 拥有 所有 成员变量 和 成员函数 ; 这里要注意 : 子类 拥有 私有成员 , 但是 子类不能 直接访问...子类 可以 在 继承 成员变量 和 成员函数 基础上 , 定义 其它 成员变量 和 成员函数 ; 因此 , 子类 可以 拥有 所没有的 成员变量 和 成员函数 ; 在下面的代码中... ; 在下面的代码中 , 定义了 Parent 类型变量 , Parent c2 ; 使用 Child c 对象 , 为 Parent c2 进行初始化赋值 , 代码为 Parent c2...= c , 该操作执行正常 , 并没有报错 ; 调用 c2.publicFun() 代码 , 访问 publicFun 函数 , 该操作正常执行 ; 说明 子类对象 可以当做 对象 使用...; 注意 : 如果 使用 子类对象对象 进行初始化 , 则该对象 不能调用 子类独有的成员; 部分代码示例 : 子类 代码 , 参考上面的章节 Parent 和 Child

    63730

    C++继承 ⑩ ( 继承机制中 static 静态成员 | 子类中访问静态成员方法 )

    一、继承机制中派生 static 关键字 1、子类继承静态成员 子类继承静态成员 : ( 基 ) 中 使用 static 关键字 定义 静态成员变量 , 可以被所有的 子类 (...派生 ) 共享 ; 2、静态成员访问控制权限改变 继承 静态成员变量 , 仍然遵循 继承子类 访问控制特性 , public 公有继承 : 成员 在 子类 中 , 访问控制权限...成员 ; private 成员 仍然是 private 成员 ; private 私有继承 : 成员 在 子类 中 , 所有成员访问控制权限 变为 private , 基 所有成员...; 或 对象名.静态成员名 child.c = 30; 方式 , 访问 继承 静态成员 ; 4、静态成员使用要点 参考 【C++】静态成员变量 ( 静态成员变量概念 | 静态成员变量声明 |...c = 20; child.print(); // 通过对象访问静态成员 child.c = 30; child.print(); // 使用 子类名称::静态成员名 访问静态成员

    43910

    C++】多态 ⑥ ( 函数重定义涉及问题 - 子类覆盖函数名 )

    , 子类 会 覆盖 函数名称 ; 执行 Child c; c.fun(1, 2, 3); 代码 , 尝试调用 3 个参数 fun 函数 , 出现错误 , 报错 : error...C2661: “Child::fun”: 没有重载函数接受 3 个参数 ; 该错误是编译阶段报错误 , 编译根本通不过 ; 3、错误原因分析 - 函数重定义问题 : 子类覆盖函数名 错误原因分析...: 函数重定义 带来问题 , 子类覆盖函数名 ; 函数重定义函数名称覆盖问题 : C++ 编译器 发现 Child c 对象要调用 void fun(int a, int b, int c) 函数..., 子类中已经存在 fun 函数了 , 子类 会 覆盖 函数名 , C++ 编译器只会在 子类查找 该函数 , 不会去 查找 ; 子类查找函数 : C++ 编译器 在 子类中找到了 void...: 没有重载函数接受 3 个参数 ; 4、正确调用函数方法 在这种情况下 , 由于子类 重定义了部分 重载函数 , 导致 函数名被覆盖 , 此时需要使用 域操作符 访问 被覆盖函数

    17720

    C++反汇编第四讲,反汇编中识别继承关系,,子类,成员对象

    C++反汇编第四讲,反汇编中识别继承关系,,子类,成员对象 讲解目录:    1.各类在内存中表现形式   备注: 主要复习开发知识,和反汇编没有关系,但是是理解反汇编前提....       2.子类继承      2.1 子类中有虚函数,中有虚函数    : 都有的情况下        2.2 子类中没有虚函数,中有虚函数   : 子类没有,有的情况 2.1...一丶各类在内存中表现形式(复习开发知识) 讲解之前,我们首先要明白C/C++内存结构.继承之后内存结构 普通内存结构:   高级代码: class MyTest { public:...构造中先填写虚表指针.   2.构造完成之后,子类会重新写入虚表指针.   3..子类继承,都有虚函数情况下,会产生复写行为, 对象首地址4个字节处填写虚表.  2.2 子类中没有虚函数,...1.构造,因为没有虚函数,所以+4构造一下,且有一个成员,所以申请了4个字节空间 2.成员变量构造+8位置开始构造,构造完毕之后构造,且此时成员对象没有虚函数. 3.子类在自己头4

    99990

    C++】异常处理 ⑦ ( 异常继承层次结构 | 抛出 捕获 多个类型异常对象 | 抛出子类异常对象 捕获并处理 异常对象 )

    自定义 异常 , 可能存在 继承结构 , 也就是说 在 同一个 try-catch 代码块中 , 如果需要 拦截 和 处理多个 异常时 , 如果 这些异常都继承相同 , 只需要拦截一个 异常即可..., 本篇博客中 , 讨论 抛出 / 捕获 异常 存在 继承结构 情况 ; 一、抛出 / 捕获 多个类型异常对象 1、抛出 / 捕获 多个类型异常对象 定义一个函数 , 传入一个 int 类型参数...二、异常继承层次结构 1、抛出子类异常对象 / 捕获并处理 异常对象 如果 抛出 / 捕获 多个类型异常对象 , 每次拦截处理异常时 , 都要手动编写多个 catch 分支 , 不利于代码维护...; 如果将 相似类型异常 都继承自 一个 , 那么每次拦截时 , 只需要拦截一个异常即可 ; 定义父异常 , 其中定义一个纯虚函数 , 该纯虚函数是异常打印 , 或者异常处理通用操作 ;..., 会发生多态 ; 在拦截对象时 , 调用不同 异常对象 , 会分别调用不同子类函数方法 ; 抛出异常函数如下 , 抛出异常时 , 需要抛出子类异常对象 ; // 1.

    19710

    C++】多态 ⑤ ( 虚析构函数 | 虚析构函数语法 | 虚析构函数意义 | 指针指向子类对象情况下子类使用 virtual 虚析构函数 | 代码示例 )

    一、虚析构函数 1、构造函数不能是虚函数 构造函数 不能定义为 虚函数 , 不能使用 virtual 关键字修饰 ; 如果要创建一个 子类 实例对象 , 需要 从 该子类 最上层 开始 , 沿着继承路径...A 构造函数 , 然后调用 B 构造函数 , 最后调用 C 构造函数 ; 参考 【C++继承 ⑧ ( 继承 + 组合 模式对象 构造函数 和 析构函数 调用规则 ) 博客中 , 构造函数... 主要作用是 , 使用 delete 运算符 释放对象时 , 引导 delete 预算符 释放 动态对象 ; 虚析构函数 Virtual Destructor 是特殊 析构函数 , 该函数用于在...子类 中覆盖 析构函数 ; 场景说明 : A 是基 , B 继承 A ; 声明一个 A 类型 指针变量 , 为其赋值 B 类型对象地址 , 当需要释放该指针变量时 , 使用...; 当使用 指针指向一个 子类 对象时 , 如果要通过 delete 释放该指针指向对象 , 如果是正常析构函数 , 没有 使用 virtual 定义虚析构函数 , 则只会调用 析构函数

    1.1K20

    创建子类对象时,构造函数中调用被子类重写方法为什么调用子类方法?

    static void main(String[] args) { A a = new A(); B b = new B(); } } 问题:为什么创建A对象时候会调用子类方法...但是:创建B对象会调用方法? 答案: 当子类被加载到内存方法区后,会继续加载到内存中。...如果,子类重写了方法,子类方法引用会指向子类方法,否则子类方法引用会指向方法引用。 如果子类重载了方法,则子类重载方法引用还指向子类方法。...如果子类方法没有重写也没有重载方法,则方法引用会指向方法。 当子类对象创建时,会先行调用构造方法(构造方法也是方法),虚拟机会在子类方法区寻找该方法并运行。...其结果是当编译时候,构造方法调用方法参数已经强制转换为符合方法参数了。 上边代码在编译前已经转换为下面这个样子了。

    6.2K10

    C++继承 ⑧ ( 继承 + 组合 模式对象 构造函数 和 析构函数 调用规则 )

    一、继承 + 组合 模式对象 构造函数和析构函数调用规则 1、场景说明 如果一个继承了 基 , 又 在中 维护了一个 其它类型 成员变量 , 那么 该类 构造 与 析构 , 就需要涉及到... 本身 构造函数 和 析构函数 , 构造函数 和 析构函数 , 成员变量 构造函数 和 析构函数 ; 2、调用规则 在 继承 + 组合 情况下 , 构造函数 与 析构函数 调用规则如下...: 构造函数 : -> 成员 -> 自身 ; 首先 , 调用 构造函数 ; 然后 , 调用 成员 构造函数 ; 也就是 成员变量 类型 构造函数 ; 最后 , 调用 自己 构造函数 ;...自身定义 构造函数 ; 析构函数 : 自身 -> 成员 -> ; 首先 , 调用 自己 析构函数 ; 自身定义 析构函数 ; 然后 , 调用 成员 析构函数 ; 也就是 成员变量 类型...<< "C 析构函数调用" << endl; } public: int z; D d; }; 可根据下面的调用规则 , 分析出 C 对象中 , 涉及到 构造/析构函数 , 自身构造/析构函数

    18310

    【Kotlin】Kotlin 继承 三 ( super 关键字使用 | super@ 外部调用方法 | 子类选择性调用 接口 方法 super )

    继承 / 实现 : 子类继承 , 或实现了接口 , 接收了所有操作与属性 , 2 ....super 关键字进行简单调用即可 ; ② 子类内部类调用 : 如果想要在子类内部调用成员和方法 , 需要使用 super@子类名称 调用 ; ③ 子类调用不同父同名方法 : 如果子类继承...子类调用方法 ( super ) ---- 子类调用方法 : 子类中可以通过 super 调用方法 , 包括普通方法 , 和属性访问 setter 方法 ; 其中 super 相当于对象引用...子类内部类调用方法 ( super@ ) ---- 子类内部类调用方法 : 在子类内部类中 , 如果想要访问方法 , 可以使用 super@子类名称.方法() 形式 , 调用方法...子类选择性调用 / 接口方法 : 子类可以继承 , 实现多个接口 , 如果与接口 , 或者不同接口之间定义了相同名称方法 , 那么需要使用 super.方法名() 选择调用指定

    1.5K10

    C++运算符重载 ⑧ ( 左移运算符重载 | 友元函数 成员函数 实现运算符重载 | 对象 使用 左移运算符 )

    一、左移运算符重载 1、友元函数 / 成员函数 实现运算符重载 运算符重载 正规写法一般都是 使用 成员函数 形式 实现 ; 加法 + , 减法 - , 自增 ++ , 自减 - - , 一般都使用成员函数...实现 运算符重载 ; 上述 运算符重载 既可以使用 成员函数 进行重载 , 又可以使用友元函数进行重载 ; 只能使用 成员函数 重载运算符 : = , [] , () , -> 等操作符 只能使用...成员函数 进行重载 ; 只能使用 友元函数 重载运算符 : 无法修改 左操作数 情况下 , 只能使用 全局函数 ( 需声明 友元函数 ) 进行重载 ; 2、对象 使用 左移运算符 平时使用 cout...: error C2679: 二进制“<<”: 没有找到接受“Student”类型右操作数运算符(或没有可接受转换) 如果想要使用 cout << s1 << endl; 用法输出对象到日志中..." 后面跟上要重载运算符 , 函数名是 operate<< ; operate<< 然后 , 根据操作数 写出函数参数 , 参数一般都是 对象引用 ; cout << s1 左操作数是 ostream

    25710

    C++进阶学习】第二弹——继承(下)——挖掘继承深处奥秘

    一、隐藏 1.1 隐藏概念 在 C++ 中,继承是一种机制,使得子类可以继承成员变量和成员函数。...隐藏是指:如果子类中出现了与类同名成员变量或成员函数,则子类这个成员会“隐藏”同名成员,使得同名成员在子类中不可见。...如果想在子类中访问中被隐藏成员,可以使用作用域运算符(::)来显式地指明要访问成员所在。...四、继承与静态成员 在 C++ 中,可以包含静态成员变量和静态成员函数,其中静态成员变量属于本身,而不是某个对象,因此它们可以在不创建对象情况下被访问。...在子类中重新定义父静态成员函数时,子类静态成员函数会隐藏静态成员函数,因此如果在子类中需要调用静态成员函数,需要使用作用域运算符 :: 来显式地调用。

    12010

    一文带你掌握多继承,菱形继承以及虚拟继承

    一、隐藏 继承体系中,子类和父亲是两个不同作用域,即子类分别有自己作用域. > 由于是两个不同作用域,所以语法上是在子类中可以定义同名成员变量....如果不想访问子类同名成员,可以在子类成员函数中显示调用成员. 显示调用格式: 基: 基成员 出现相同名称变量终究是容易让人混乱,还是不建议在子类中定义同名成员变量....,而子类函数需要传参 cout << endl; s1.People::Print(); //显示调用函数 cout << endl; p1.Print(); //对象调用函数...cout << endl; return 0; } 运行结果: 三、多继承继承: C++继承是指一个子类只能继承一个特性。...多继承可以让一个拥有多个不同父成员函数和成员变量,提高代码复用性。同时,多继承也会带来一些问题和挑战,例如菱形继承问题,需要合理使用

    31250
    领券