C++ 多态的类型

2024年8月28日 | 阅读 4 分钟

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

例如

例如，运算符“+”用于添加两个整数，也用于连接两个字符串。

因此，“+”运算符服务于两个目的——相加和连接。

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

编译时多态

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

编译时多态的例子

1) 函数重载

函数重载定义为将一个函数用于不同的目的。在这里，一个函数通过改变函数签名（参数数量和参数类型）来执行许多任务。它是编译时多态的一个例子，因为在编译时决定调用哪个函数。

示例

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

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

编码

#include <iostream>
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 <bits/stdc++.h>
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

运行时多态

运行时多态定义为在程序执行时调用函数的过程。

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

函数重写

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

示例

在下面的示例中，一个动物类有一个函数f()，它也存在于派生类Man中。当我们使用基类对象调用函数 f() 时，它会打印基类的内容，而使用派生类对象则打印派生类的内容。因此，选择函数 f() 是在运行时决定的。

编码

#include <iostream>
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;
}

输出

Eating...
Walking ...

下一主题在不使用 C++ STL 容器的情况下实现集合

C++ 多态的类型

编译时多态

编译时多态的例子

运算符重载

示例

运行时多态

函数重写

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

C++ 教程

C++ 控制语句

C++ 函数

C++ 数组

C++ 类和对象

C++ 构造函数

C++ 继承

C++ 多态

C++ 抽象

C++ 命名空间

C++ 模板

C++ 字符串

C++ 指针

信号处理

C++ 异常

C++ 文件与流

C++ STL 教程

面试题

选择题

C++ 程序

C++ STL Stack

C++ STL Bitset

C++ STL Deque

C++ STL List

C++ STL Map

C++ STL Math

C++ STL priority_queue

C++ STL Queue

C++ STL Multiset

C++ STL Multimap

C++ STL Set

C++ STD Strings

C++ STL Vector

C++ 操纵符

C++ STL Algorithms

C++ Algorithm

C++ Iterators

C++ 杂项

C++ 多态的类型

编译时多态

编译时多态的例子

运算符重载

示例

运行时多态

函数重写

相关帖子

C++ Eratosthenes 筛法

C++ String::npos

C++ 跳转语句

C++ 中字符出现频率最多为奇数的子串数量

C++ 稳定婚配问题

C++ 中 Vector 和 List 的区别

C++ 转换构造函数

C++ Isdigit() 函数

C++ 有序映射

C++ 中 std::set 和 std::vector 的区别

订阅 Tpoint Tech

联系信息

关注我们

教程