C++将派生类赋值给基类（向上转型）

最新推荐文章于 2023-03-07 16:35:31 发布
最新推荐文章于 2023-03-07 16:35:31 发布
阅读量664 收藏 4
点赞数 3
文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/k6604125/article/details/129241953
版权
本文通过C++代码示例展示了派生类对象赋值给基类对象以及派生类指针赋值给基类指针的操作，并探讨了virtual关键字在实现多态中的作用。同时，详细解释了dynamic_cast在向上和向下转型中的应用，包括其依赖于RTTI（运行时类型信息）进行安全性检查的特点。
摘要由CSDN通过智能技术生成

1.将派生类对象赋值给基类对象

#include <iostream>
using namespace std;

//基类
class A{
public:
    A(int a);
public:
    void display();
public:
    int m_a;
};
A::A(int a): m_a(a){ }
void A::display(){
    cout<<"Class A: m_a="<<m_a<<endl;
}

//派生类
class B: public A{
public:
    B(int a, int b);
public:
    void display();
public:
    int m_b;
};
B::B(int a, int b): A(a), m_b(b){ }
void B::display(){
    cout<<"Class B: m_a="<<m_a<<", m_b="<<m_b<<endl;
}


int main(){
    A a(10);
    B b(66, 99);
    //赋值前
    a.display();
    b.display();
    cout<<"--------------"<<endl;
    //赋值后
    a = b;
    a.display();
    b.display();

    return 0;
}

运行结果：

Class A: m_a=10
Class B: m_a=66, m_b=99
'----------------------------
Class A: m_a=66
Class B: m_a=66, m_b=99
在这里插入图片描述

2.将派生类指针赋值给基类指针

#include <iostream>
using namespace std;

//基类A
class A{
public:
    A(int a);
public:
    void display();
protected:
    int m_a;
};
A::A(int a): m_a(a){ }
void A::display(){
    cout<<"Class A: m_a="<<m_a<<endl;
}

//中间派生类B
class B: public A{
public:
    B(int a, int b);
public:
    void display();
protected:
    int m_b;
};
B::B(int a, int b): A(a), m_b(b){ }
void B::display(){
    cout<<"Class B: m_a="<<m_a<<", m_b="<<m_b<<endl;
}

//基类C
class C{
public:
    C(int c);
public:
    void display();
protected:
    int m_c;
};
C::C(int c): m_c(c){ }
void C::display(){
    cout<<"Class C: m_c="<<m_c<<endl;
}

//最终派生类D
class D: public B, public C{
public:
    D(int a, int b, int c, int d);
public:
    void display();
private:
    int m_d;
};
D::D(int a, int b, int c, int d): B(a, b), C(c), m_d(d){ }
void D::display(){
    cout<<"Class D: m_a="<<m_a<<", m_b="<<m_b<<", m_c="<<m_c<<", m_d="<<m_d<<endl;
}


int main(){
    A *pa = new A(1);
    B *pb = new B(2, 20);
    C *pc = new C(3);
    D *pd = new D(4, 40, 400, 4000);

    pa = pd;
    pa -> display();

    pb = pd;
    pb -> display();

    pc = pd;
    pc -> display();

    cout<<"-----------------------"<<endl;
    cout<<"pa="<<pa<<endl;
    cout<<"pb="<<pb<<endl;
    cout<<"pc="<<pc<<endl;
    cout<<"pd="<<pd<<endl;

    return 0;
}

运行结果：

Class A: m_a=4
Class B: m_a=4, m_b=40
Class C: m_c=400
'-----------------------
pa=0x9b17f8
pb=0x9b17f8
pc=0x9b1800
pd=0x9b17f8

本例中定义了多个对象指针，并尝试将派生类指针赋值给基类指针。与对象变量之间的赋值不同的是，对象指针之间的赋值并没有拷贝对象的成员，也没有修改对象本身的数据，*仅仅是改变了指针的指向*。
3.virtual实现多态

#include <iostream>
using namespace std;

//基类People
class People{
public:
    People(char *name, int age);
    void display();
protected:
    char *m_name;
    int m_age;
};
People::People(char *name, int age): m_name(name), m_age(age){}
void People::display(){
    cout<<m_name<<"今年"<<m_age<<"岁了，是个无业游民。"<<endl;
}

//派生类Teacher
class Teacher: public People{
public:
    Teacher(char *name, int age, int salary);
    void display();
private:
    int m_salary;
};
Teacher::Teacher(char *name, int age, int salary): People(name, age), m_salary(salary){}
void Teacher::display(){
    cout<<m_name<<"今年"<<m_age<<"岁了，是一名教师，每月有"<<m_salary<<"元的收入。"<<endl;
}

int main(){
    People *p = new People("王志刚", 23);
    p -> display();

    p = new Teacher("赵宏佳", 45, 8200);
    p -> display();

    return 0;
}

在这里插入图片描述

#include <iostream>
using namespace std;

//基类People
class People{
public:
    People(char *name, int age);
    virtual void display();  //声明为虚函数
protected:
    char *m_name;
    int m_age;
};
People::People(char *name, int age): m_name(name), m_age(age){}
void People::display(){
    cout<<m_name<<"今年"<<m_age<<"岁了，是个无业游民。"<<endl;
}

//派生类Teacher
class Teacher: public People{
public:
    Teacher(char *name, int age, int salary);
    virtual void display();  //声明为虚函数
private:
    int m_salary;
};
Teacher::Teacher(char *name, int age, int salary): People(name, age), m_salary(salary){}
void Teacher::display(){
    cout<<m_name<<"今年"<<m_age<<"岁了，是一名教师，每月有"<<m_salary<<"元的收入。"<<endl;
}

int main(){
    People *p = new People("王志刚", 23);
    p -> display();

    p = new Teacher("赵宏佳", 45, 8200);
    p -> display();

    return 0;
}

在这里插入图片描述
4.多态例子：

#include <iostream>
using namespace std;

//军队
class Troops{
public:
    virtual void fight(){ cout<<"Strike back!"<<endl; }
};

//陆军
class Army: public Troops{
public:
    void fight(){ cout<<"--Army is fighting!"<<endl; }
};
//99A主战坦克
class _99A: public Army{
public:
    void fight(){ cout<<"----99A(Tank) is fighting!"<<endl; }
};
//武直10武装直升机
class WZ_10: public Army{
public:
    void fight(){ cout<<"----WZ-10(Helicopter) is fighting!"<<endl; }
};
//长剑10巡航导弹
class CJ_10: public Army{
public:
    void fight(){ cout<<"----CJ-10(Missile) is fighting!"<<endl; }
};

//空军
class AirForce: public Troops{
public:
    void fight(){ cout<<"--AirForce is fighting!"<<endl; }
};
//J-20隐形歼击机
class J_20: public AirForce{
public:
    void fight(){ cout<<"----J-20(Fighter Plane) is fighting!"<<endl; }
};
//CH5无人机
class CH_5: public AirForce{
public:
    void fight(){ cout<<"----CH-5(UAV) is fighting!"<<endl; }
};
//轰6K轰炸机
class H_6K: public AirForce{
public:
    void fight(){ cout<<"----H-6K(Bomber) is fighting!"<<endl; }
};

int main(){
    Troops *p = new Troops;
    p ->fight();
    //陆军
    p = new Army;
    p ->fight();
    p = new _99A;
    p -> fight();
    p = new WZ_10;
    p -> fight();
    p = new CJ_10;
    p -> fight();
    //空军
    p = new AirForce;
    p -> fight();
    p = new J_20;
    p -> fight();
    p = new CH_5;
    p -> fight();
    p = new H_6K;
    p -> fight();

    return 0;
}

在这里插入图片描述
5.dynamic_cast 关键字
dynamic_cast 用于在类的继承层次之间进行类型转换，它既允许向上转型（Upcasting），也允许向下转型（Downcasting）。向上转型是无条件的，不会进行任何检测，所以都能成功；向下转型的前提必须是安全的，要借助 RTTI 进行检测，所有只有一部分能成功。
5.1.向上转型（Upcasting）
向上转型时，只要待转换的两个类型之间存在继承关系，并且基类包含了虚函数（这些信息在编译期间就能确定），就一定能转换成功。因为向上转型始终是安全的，所以 dynamic_cast 不会进行任何运行期间的检查，这个时候的 dynamic_cast 和 static_cast 就没有什么区别了。

#include <iostream>
#include <iomanip>
using namespace std;

class Base{
public:
    Base(int a = 0): m_a(a){ }
    int get_a() const{ return m_a; }
    virtual void func() const { }
protected:
    int m_a;
};

class Derived: public Base{
public:
    Derived(int a = 0, int b = 0): Base(a), m_b(b){ }
    int get_b() const { return m_b; }
private:
    int m_b;
};

int main(){
    //情况①
    Derived *pd1 = new Derived(35, 78);
    Base *pb1 = dynamic_cast<Derived*>(pd1);
    cout<<"pd1 = "<<pd1<<", pb1 = "<<pb1<<endl;
    cout<<pb1->get_a()<<endl;	//OK
    cout<<pb1->get_b()<<endl;	//NG
    cout<<pd1->get_b()<<endl;	//OK
    pb1->func();

    return 0;
}

5.2.向下转型（Downcasting）
向下转型是有风险的，dynamic_cast 会借助 RTTI 信息进行检测，确定安全的才能转换成功，否则就转换失败。那么，哪些向下转型是安全地呢，哪些又是不安全的呢？下面我们通过一个例子来演示：

#include <iostream>
using namespace std;

class A{
public:
    virtual void func() const { cout<<"Class A"<<endl; }
private:
    int m_a;
};

class B: public A{
public:
    virtual void func() const { cout<<"Class B"<<endl; }
private:
    int m_b;
};

class C: public B{
public:
    virtual void func() const { cout<<"Class C"<<endl; }
private:
    int m_c;
};

class D: public C{
public:
    virtual void func() const { cout<<"Class D"<<endl; }
private:
    int m_d;
};

int main(){
    A *pa = new A();
    B *pb;
    C *pc;
   
    //情况①
    pb = dynamic_cast<B*>(pa);  //向下转型失败
    if(pb == NULL){
        cout<<"Downcasting failed: A* to B*"<<endl;
    }else{
        cout<<"Downcasting successfully: A* to B*"<<endl;
        pb -> func();
    }
    pc = dynamic_cast<C*>(pa);  //向下转型失败
    if(pc == NULL){
        cout<<"Downcasting failed: A* to C*"<<endl;
    }else{
        cout<<"Downcasting successfully: A* to C*"<<endl;
        pc -> func();
    }
   
    cout<<"-------------------------"<<endl;
   
    //情况②
    pa = new D();  //向上转型都是允许的
    pb = dynamic_cast<B*>(pa);  //向下转型成功
    if(pb == NULL){
        cout<<"Downcasting failed: A* to B*"<<endl;
    }else{
        cout<<"Downcasting successfully: A* to B*"<<endl;
        pb -> func();
    }
    pc = dynamic_cast<C*>(pa);  //向下转型成功
    if(pc == NULL){
        cout<<"Downcasting failed: A* to C*"<<endl;
    }else{
        cout<<"Downcasting successfully: A* to C*"<<endl;
        pc -> func();
    }
   
    return 0;
}

在这里插入图片描述

在这里插入图片描述

k6604125
关注
C++将派生类赋值给基类终结篇
深入浅出讲透复杂深奥的问题
05-12 611
向上转型后通过基类的对象、指针、引用只能访问从基类继承过去的成员（包括成员变量和成员函数），不能访问派生类新增的成员。 基类指针指向派生类对象 如果访问的是基类中的虚函数，且派生类中也实现了该函数，则访问的是派生类中的实现 namespace { class Base { public: virtual void Display(const std::string &text = "Base!") { std::cout << text <&lt.
基于C/C++将派生类赋值给基类的详细讲解
最新发布
阿玥的小博客
06-06 736
评论“人生苦短，拒绝内卷！”就有可能获得实体书一本哦，快来参与吧！
派生类的对象赋值给基类对象
ShenHang_的博客
12-18 4796
派生类对象隐含转换为基类对象，即用派生类对象中从基类继承来的成员，逐个赋值给基类对象的成员。 注意：public继承方式下，基类的private成员，在派生类中虽然无法访问，但是还是客观存在的！！！。如果一定要通过派生类对象访问基类的private成员，那么只能在基类中设置一个公有接口。 自己写了一个程序例子，觉得很清楚了（这里还涉及到了静态联编）： #include<iostream&gt...
【C++基础】将派生类赋值给基类（向上转型）
qq_43456016的博客
03-07 892
将派生类赋值给基类（向上转型）
派生类指针赋值给基类指针
luoganttcc的博客
11-10 1002
#include <iostream> using namespace std; //基类A class A{ public: A(int a); public: void display(); protected: int m_a; }; A::A(int a): m_a(a){ } void A::display(){ cout<<"Class A: m_a="<<m_a<<endl; cout<<"A
派生类和基类之间的赋值
Orangetc的博客
11-02 2026
派生类和基类的赋值关系： 派生类可以赋值给基类；基类不可以赋值给派生类。 1.对象赋值 class Father { ... }; class Son: public Father { ... }; Father f; Son s; f=s;//可以 s=f;//不可以 说明： 原因是派生类所占的空间比基类大。赋值运算会调用operator =()函数，赋值操作...
C++：派生类指针赋值给基类指针问题
ENSHADOWER的博客
07-20 6907
在C++继承中，很容易遇到一个问题，那就是将派生类指针赋值给基类指针(向上转型)的情况，下面我们就来举例分析： 举一个多继承的例子： #include <iostream> using namespace std; //基类A class A { public: A(int a); public: void display(); protected: int m_a;...
将派生类指针赋值给基类的指针
luoganttcc的博客
11-10 1779
除了可以将派生类对象赋值给基类对象（对象变量之间的赋值），还可以将派生类指针赋值给基类指针（对象指针之间的赋值）。我们先来看一个多继承的例子，继承关系为： #include <iostream> using namespace std; //基类 class A{ public: A(int a); int m_a; public: void display(); }; A::A(int a):m_a(a) {} void A::display() {
C++基类指针和派生类指针之间的转换方法讲解
08-26
今天小编就为大家分享一篇关于C++基类指针和派生类指针之间的转换方法讲解，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
C++ 派生类赋值给基类指针
qq_37026934的博客
05-09 753
基类和派生类的关系 基类和派生类不是2个独立的类型，派生类是一个基类的类型，它们2个不是分开的，当我们创建一个派生类的时候，派生类中的数据member应该如下 BaseClass : [Base Data] DerivedClass : [Base Data][Derived Data] 派生类的数据类型附加于基类之后 当我们给一个基类类型指向派生类的时候，这个基类指针访问的是派生类继承基类的那部分数据，就算我们在派生类中重新更改继承而来的基类类型，基类指针访问的还是原来的数值，如下 #include &
C++派生类指针赋值给基类指针问题（虚函数和非虚函数不同）
像我这样的人
02-09 905
C++ 派生类指针赋值给基类指针问题
C++常见面试题（九）——派生类指针赋值给基类指针问题
一个小孩
07-05 1427
在C++继承中，很容易遇到一个问题，那就是将派生类指针赋值给基类指针(向上转型)的情况，下面我们就来举例分析： 举一个多继承的例子： #include <iostream> using namespace std; //基类A class A { public: A(int a); public: void display(); protected: int m_a; }; A::A(int a) : m_a(a) { } void A::display() { cout
C++派生类与基类的赋值
Gexyz的专栏
04-11 1561
class A{ A& operator =(const A&){} }; class B:A{ B& operator=(const &B){} }; void main() { A a; B b; a=b;//正确 b=a;//错误 } 可以把派生类赋值给基类。我们知道赋值，是调用了类的赋值运算符。所以当派生类给基类赋值时，调用了基类的复制运算符函数，该函数的参数是基
基类与派生类对象之间的赋值问题
weixin_43850474的博客
06-16 3601
一、将派生类对象赋值给基类对象？ 注意：这不同于将派生类对象赋值给基类的引用或者指针 请看如下代码： Base b; //基类对象 Derived d; //派生类对象 b=d; //赋值 这将使用哪一个运算符呢？赋值语句实际上会被转换为下面的语句： b.operator=(d); 其中左边的对象是基类对象，所以调用的是基类中的赋值运算符重载函数，右边的对象作为传入的参数。而实参与形参结合的过程实际上就是派生类对象赋值给基类对象的引用。所以，b=
基类与派生类对象和指针赋值的小结
gswjj1的专栏
07-04 1030
基类指针和派生类指针指向基类对象和派生类对象的4中方法： 1.  基类指针指向基类对象，只需要通过基类指针简单地调用基类的功能。 2.  派生类指针指向派生类对象，只需要通过派生类指针简单地调用派生类功能。 3.  基类指针指向派生类对象，安全，实现多态的语言基础。         但是要注意的是，这个指针只能用来调用基类的成员函数，如果试图通过基类指针调用派生类才有的成员
第二十九节 C++ 继承之向基类传递参数
菜鸟博客
04-08 3037
#include &lt;iostream&gt; using namespace std; /*有时，基类存在重载的构造函数，而搞造函数对类的数据成员进行了初始化， * 这种情况下，在继承基类时，需要对基类的数据成员进行初始化 * */ class Person { protected: //只能在派生类内部访问protected成员，外部不可访问 bool man; public: //...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值