C++ 多态性类型

多态性被定义为使用函数或运算符来实现多个目的的过程。换句话说，我们也可以说一个运算符或一个函数可以以不同的方式为我们提供服务。

示例

假设我们用 ‘+’ 运算符来相加两个整数并且用它来连接两个字符串。

因此 ‘+’ 运算符有两个目的 – 相加和连接。

现在让我们来了解C++中的多态性类型。

编译时多态性

它被定义为在编译时调用函数的多态性。这种类型的过程也称为早期或静态绑定。

编译时多态性的示例

1）函数重载

函数重载是指使用一个函数来实现不同的目的。在这里，一个函数通过更改函数签名（参数的数量和类型）来执行多个任务。这是编译时多态性的示例，因为在编译时决定调用哪个函数。

示例

在下面的代码中，我们定义了一个名为Addition的类，它执行两个数字的相加和两个字符串的连接。它有一个被重载两次的函数ADD()。

函数 ADD(int X, int Y) 用于相加两个整数，而没有参数的函数 ADD() 用于字符串连接。

代码

#include 
using namespace std;
class Addition { // Create Addition class
public:
    int ADD(int X, int Y) // Add function add two numbers
    {
        return X + Y; // return the Addition of two numbers
    }
    int ADD()
    { // this ADD function concatenates two strings
        string a = "HELLO";
        string b = " JAVATPOINT";
        string c = a + b; // concatenate two strings
        cout << c << endl; // print result
    }
};
int main(void)
{
    Addition obj; // Object is created  of Addition class
    cout << obj.ADD(120, 105) << endl; //first method is called to add two integers
    obj.ADD(); // second method is called to concatenate two strings
    return 0;
}

输出

225
HELLO JAVATPOINT

操作符重载

操作符重载是指除了原有的加法操作之外，使用一个操作符进行加法运算。

操作符重载的概念是为用户自定义的数据类型提供特殊的含义。操作符重载的好处是可以使用相同的操作数来执行两个不同的操作。最基本的操作符重载示例是’+’操作符，它用于对数字和字符串进行加法运算。

操作符 , :: ?: sizeof 不能被重载。

示例

在下面的示例中，我们重载了’+’操作符来对两个字符串进行相加。

通过使用 operator 关键字和要重载的操作符来重载一个操作符。

代码

#include 
using namespace std;
class A // Create a class A
    {

    string x; // private data member x
public:
    A() {}
    A(string i)
    {
        x = i; // Assign the data member
    }
    void operator+(A); // operator overloading
};

void A::operator+(A a) // concetenate the strings and print output
{

    string m = x + a.x;
    cout << "The result of the addition of two objects is: " << m;
}
int main()
{
    A a1("Welcome "); // string 1
    A a2("to javatpoint"); // string 2
    a1 + a2; // concetenate two strings using operator overloading
    return 0;
}

输出

The result of the addition of two objects is: Welcome to javatpoint

运行时多态性

运行时多态性是指在程序执行时调用函数的过程。

运行时多态性的一个例子是函数重写。

函数重写

当我们说一个函数被重写时，意味着在派生类中给出了该函数的新定义。因此，在函数重写中，我们有两个定义，一个在基类中，另一个在派生类中。在运行时决定选择哪一个函数。

示例

在下面的示例中，一个类animal有一个函数 f() ，这个函数也在派生类 Man 中。当我们用基本对象调用函数f()时，它打印出基类的内容；当我们用派生对象调用时，它打印出派生类的内容。因此，选择函数f()是在运行时决定的。

代码

#include 
using namespace std;
class Animal { // Create a new class
public:
    void f()
    { // the function f will be overriden in the class Man
        cout << "Eating..." << endl;
    }
};
class Man : public Animal // Base class inheriting derived class
{
public:
    void f() // The function f being overriden
    {
        cout << "Walking ..." << endl;
    }
};
int main(void)
{
    Animal A = Animal();
    A.f(); //parent class object
    Man m = Man();
    m.f(); // child class object

    return 0;
}

输出