C++ 多态

2025 年 4 月 25 日 | 7 分钟阅读

在 C++ 中，“多态性”一词是“poly”（多）+“morphs”（形式）两个词的组合，意为多种形式。它是一个希腊词。此属性创建相同的实体，例如函数和运算符在多种场景下表现不同。使用多态性，我们可以以多种方式执行单个任务。它使多态性成为 OOPs 概念的重要组成部分。

多态性的简单示例

让我们以 C++ 中使用 + 运算符的多态性简单示例。

示例

#include <iostream>
using namespace std; //using standard namespace

int main() //Main Function
{
    int a = 15; //initialize integer values
    int b = 20;
    string x = "poly"; //initialize string values
    string y = "morphism";
    
    cout << "The Value of a + b is: " << a + b <<endl;
    
    cout << "The Value of x + y is: " << x + y;
	return 0;
}

编译并运行

输出

The Value of a + b is: 35
The Value of x + y is: polymorphism

说明

在此示例中，我们使用了两个 (+) 运算符。第一个 + 运算符用于添加两个整数值，第二个 + 运算符用于连接两个字符串操作数。

多态性类型

多态性在 C++ 中可分为两类

编译时多态
运行时多态

编译时多态

在 C++ 中，编译时多态也称为早期绑定和静态多态。在这种多态中，编译器根据上下文指定运算符或函数将如何工作。它允许具有相同名称但参数列表不同的多个函数。

它通过函数重载和运算符重载实现。

a) 函数重载

在 C++ 中，函数重载是面向对象编程的重要组成部分。在函数重载中，我们可以使用多个名称相同但参数不同的函数。函数重载可以通过更改参数数量或更改参数来实现。

要了解更多信息： 函数重载

使用函数重载的编译时多态示例

让我们通过一个示例来使用函数重载实现编译时多态。

示例

#include <iostream>
using namespace std; //using standard namespace

class Tpoint {
public:
// Function to multiply two integer point values
   void multiplication(int x, int y) {
        cout << "Integer Multiplication Result = " << x * y
        << endl;
    }
    
    // Function to multiply two floating point values
    void multiplication(double x, double y) {
        cout << "Double Float Result = " << x * y
        << endl ;
    }
};

int main() //main function
{
    Tpoint obj;
    obj.multiplication(12, 5);         // calls show(int)
    obj.multiplication(4.5, 2.5);        // calls show(double)

    return 0;
}

编译并运行

输出

Integer Multiplication Result = 60
Double Float Result = 11.25

说明

在此示例中，我们使用了一个 Tpoint 类，其中包含两个名称相同但参数不同的 multiplication() 函数。第一个 multiplication() 函数接受整数，第二个接受双精度值。在 main() 函数中，调用 obj.multiplication(12, 5) 会调用整数版本，而 obj.multiplication(4.5, 2.5) 会调用浮点版本。

b) 运算符重载

在 C++ 中，运算符重载是一个为用户定义数据类型提供特定含义的运算符函数。它通过使用多个运算符实现，例如 +、-、*、==、<<、>> 等。如果要在 C++ 中使用运算符重载，则至少一个操作数应为用户定义的数据类型。

要了解更多信息： 运算符重载

使用运算符重载的 C++ 编译时多态示例

让我们通过一个示例来使用运算符重载实现编译时多态。

示例

#include <iostream>
using namespace std; //using standard namespace

class Tpoint_oper {
private:
    int value;

public:
    // Constructor to initialize value
    Tpoint_oper(int a) : value(a) {}

    // Overload * operator
    Tpoint_oper operator * (const Tpoint_oper& obj) {
        return Tpoint_oper(value * obj.value);
    }

    // Function to show value
    void show() {
        cout << "The Multiplication Result of Two Numbers is: " << value << endl;
    }
};

int main() //Main function
{
    Tpoint_oper x(12);
    Tpoint_oper y(5);
    
    Tpoint_oper result = x * y; // Calls overloaded * operator
    result.show();            

    return 0;
}

编译并运行

输出

The Multiplication Result of Two Numbers is: 60

说明

在此示例中，* 运算符在 Tpoint_oper 类中被重载，以执行两个对象之间的乘法运算。每个对象都存储一个整数值。重载的 * 运算符将另一个 Tpoint_oper 对象作为参数，将两个对象的内部值相乘，并返回一个包含结果的新对象。之后，使用 show() 函数显示乘法结果。

运行时多态

在 C++ 中，当对象的方法在运行时而不是编译时被调用时，就实现了运行时多态。它也称为后期绑定或动态绑定。它允许在派生类中进行方法重写。

它通过函数重写和虚函数实现。

a) 函数重写

在 C++ 中，函数重写是 Oops 的一个特性，它允许派生类重新定义其基类已提供的函数。它用于实现运行时多态。

为了允许重写，基类中的函数应定义为 virtual。在派生类中，函数应具有相同的名称、返回类型和参数。

要了解更多信息： 函数重写

使用函数重写的 C++ 运行时多态示例

让我们通过一个示例来使用函数重写实现运行时多态。

示例

#include <iostream>    
using namespace std; //using standard namespace
class Shape // base class  
{  
    public:    
virtual void draw() // virtual function  
{   
cout<<"drawing..."<<endl;      
    }        
};     
class Rectangle: public Shape  // derived class inheriting shape class 
{      
 public:    
 void draw() override  
   {      
       cout<<"drawing rectangle..."<<endl;      
    }      
};    
class Circle: public Shape  //derived class
  
{      
 public:    
 void draw() override  
   {      
      cout<<"drawing circle..."<<endl;      
   }      
};    
int main(void) //main function
{    
    Shape *s;  // base class pointer.  
    Shape sh;  // base class object.  
       Rectangle rect;  //Derived class object
        Circle circ;    
      s=&sh;    
     s->draw();     
        s=▭    
     s->draw();      
    s= ˆ 
    s->draw();     
}    

编译并运行

输出

drawing...
drawing rectangle...
drawing circle...

说明

在此示例中，我们使用了一个基类 Shape，其中包含一个虚函数 draw()。之后，派生类 Rectangle 和 Circle 用于重写 draw() 函数。在 main 函数中，使用基类指针 s 在不同时间表示不同的对象。

b) 虚函数

在 C++ 中，虚函数是在基类中声明的成员函数。使用 virtual 关键字，我们可以在基类中声明虚函数。如果我们将基类中的方法声明为 virtual 并使用基类指针调用该方法，它会调用派生类的方法。在基类中，虚函数帮助派生类方法重写该函数。

要了解更多信息： 虚函数

使用虚函数的 C++ 运行时多态示例

让我们通过一个示例来使用虚函数实现运行时多态。

示例

#include <iostream>
using namespace std; //using standard namespace

class Animal {
   public:
    virtual void Ani_color() {
        cout << "Animal Color Black" << endl;
    }
};
class Dog : public Animal {
   public:
    void Ani_color() {
        cout << "Animal Color Gray" << endl;
    }
};

int main() //main function
{
    Dog dog1;

    //pointer of Base type
    Animal* ani1 = &dog1;

    //calls member function of Derived class
    ani1->Ani_color();

    return 0;
}

编译并运行

输出

Animal Color Gray

说明

在此示例中，我们使用了一个基类 Animal，其中包含一个虚函数 Ani_color()，该函数在派生类 Dog 中被重写。在 main() 函数中，使用 Animal* 类型的指针指向 Dog 类的一个对象。当使用此基类指针调用 Ani_color() 函数时，由于 virtual 关键字，它会调用 Dog 类中重写版本。

编译时多态和运行时多态的区别

C++ 中编译时多态和运行时多态的几个区别如下

编译时多态	运行时多态
要调用的函数在编译时已知。	要调用的函数在运行时已知。
它也称为重载、早期绑定和静态绑定。	它也称为重写、动态绑定和后期绑定。
重载是编译时多态，其中多个方法具有相同的名称但参数数量不同。	重写是运行时多态，其中多个方法具有相同的名称和参数数量。
它通过函数重载和运算符重载实现。	它通过虚函数和指针实现。
它在编译时提供快速执行。	它在运行时提供慢速执行。
它不太灵活，因为所有函数都在编译时执行。	它更灵活，因为所有函数都在运行时执行。

C++ 多态性 MCQ

1) 哪种类型的多态性通过函数重写实现？

运行时多态
编译时多态
动态多态性
静态多态

答案： b) 编译时多态

2) 以下哪个关键字用于在 C++ 中实现运行时多态？

virtual
polymorphic
final
override

答案： a) virtual

3) 给定程序的输出是什么？

#include <iostream>
using namespace std; //using standard namespace

class Employee
{ 
    public : int emp_id; 
	void show() 
	{ 
		cout<<"It is the base class" <<endl;
	}
};
	class department : public Employee{
		public : 
		void show()
		{ 
			cout<<"It is the derived class"; 
		}
	};
int main() //main function
	{ 
	    Employee emp1; 
	    department dept;
	emp1.show();
	dept.show();
};

这是派生类这是基类
这是派生类
这是基类
这是基类
这是派生类
这是基类这是派生类

答案： c) 这是基类

这是派生类

4) 以下哪个选项显示了 C++ 中的多态性？

重载 &&
重载 +=
重载 ||
重载 <<

答案： d) 重载 <<

5) 以下哪个选项是 C++ 中多态性的主要优点？

代码优化
类型安全
代码重用性
内存效率

答案： c) 代码可重用性

下一个主题C++ 中的运算符重载

C++ 多态

多态性的简单示例

示例

多态性类型

编译时多态

a) 函数重载

使用函数重载的编译时多态示例

示例

b) 运算符重载

使用运算符重载的 C++ 编译时多态示例

示例

运行时多态

a) 函数重写

使用函数重写的 C++ 运行时多态示例

示例

b) 虚函数

使用虚函数的 C++ 运行时多态示例

示例

C++ 多态性 MCQ

联系信息

关注我们

教程

面试题

在线编译器

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++ 多态

多态性的简单示例

示例

多态性类型

编译时多态

a) 函数重载

使用函数重载的编译时多态示例

示例

b) 运算符重载

使用运算符重载的 C++ 编译时多态示例

示例

运行时多态

a) 函数重写

使用函数重写的 C++ 运行时多态示例

示例

b) 虚函数

使用虚函数的 C++ 运行时多态示例

示例

C++ 多态性 MCQ

相关帖子

C++ 函数重载

C++ 函数重写