C++ 向上转型和向下转型

本节将通过C++编程语言的一个示例讨论向上转型和向下转型。当我们将一个数据类型转换为另一种类型时，这个过程被称为类型转换。但是，向上转型和向下转型是对象类型转换的一种类型。假设父类和子类有两种对象类型，parent_obj和child_obj，可以使用向上转型和向下转型将它们转换为父类到子类和子类到父类。

向上转型

它是从基类的指针或引用创建派生类的指针或引用的过程，这个过程被称为向上转型。这意味着向上转型用于将派生类的引用或指针转换为基类。与向下转型相比，向上转型是安全的转换。它允许公共继承，即将一个类的引用隐式地转换为另一个类，而无需显式类型转换。默认情况下，向上转型在基类和派生类之间创建了一个is-a的关系。

Base *ptr = &derived_obj;

派生类可以继承所有基类的属性，包括数据成员和使用派生类对象执行函数的成员函数，就像我们对待基本对象一样。

用C++演示向上转型的程序

让我们考虑一个示例，在C++编程语言中将派生类的指针转换为基类的指针。

Program1.cpp

#include 
using namespace std;
class Base
{
    public:
        void disp()
    {
        cout << " It is the Super function of the Base class ";
    }
};

class derive : public Base
{
    public:
        void disp()
        {
            cout << "\n It is the derive class function ";
        }

};

int main ()
{
    // create base class pointer
    Base *ptr;

    derive obj; // create object of derive class
    ptr = &obj // assign the obj address to ptr variable

    // create base class's reference
     Base &ref = obj; 
    // Or
    // get disp() function using pointer variable

    ptr->disp();
    return 0;
}

输出

It is the Super function of the Base class

下行转换

下行转换是与上行转换相对应的过程，它将基类的指针或引用转换为派生类的指针或引用。它手动将基类的对象强制转换为派生类的对象，因此我们必须指定显式类型转换。下行转换在大多数情况下不遵循“是一个”关系。与上行转换不同，它不安全。此外，派生类可以添加新功能，例如：新的数据成员和使用这些数据成员的类成员函数。但这些功能无法应用于基类。

Derived *d_ptr = &b_obj;

C++ 中演示向下转型的程序

让我们创建一个示例，用 C++ 编程语言将基类的对象向下转型为派生类。

Program2.cpp

#include 
using namespace std;
class Parent
{
    public:
        void base()
        {
            cout << " It is the function of the Parent class "<< endl; 
        }
};

class Child : public Parent
{
    public:
        void derive()
        {
            cout << " it is the function of the Child class " < derive();

    return 0;
}

输出

It is the function of the Child class

在C++中演示向上转型和向下转型的程序

让我们考虑一个示例，使用C++中的向下转型和向上转型将基类转换为派生类以及将派生类的对象转换为基类。

Program3.cpp

#include 
using namespace std;

class Parent {
    private:
        int id;

    public:
        void showid ()
        {
            cout << " I am in the Parent class " << endl;
            }   
};

class Myson : public Parent {
    public:
        void disp ()
        {
            cout << " I am in the Myson class " << endl;
        }
};

int main ( int argc, char * argv[])
{
    // create object of the Parent class
    Parent par_obj;

    // create object of the Myson class
    Myson my_obj;

    // upcast - here upcasting can be done implicitly
    Parent *ptr1 = &my_obj; // base class's reference the derive class's object

    // downcast - here typecasting is done explicitly 
    Myson *ptr2 = (Myson *) ∥_obj;

    // Upcasting is safe:
    ptr1->showid();
    ptr2->showid();


    // downcasting is unsafe:
    ptr2->disp();

    getchar();
    return 0;

}

输出

I am in the Parent class
 I am in the Parent class
 I am in the Myson class