📌  相关文章
📜  C++重载

📅  最后修改于: 2020-10-16 07:06:48             🧑  作者: Mango

C++重载(函数和运算符)

如果我们创建两个或多个具有相同名称但参数数量或类型不同的成员，则称为C++重载。在C++中，我们可以重载：

  • 方法，
  • 构造函数，以及
  • 索引属性

这是因为这些成员仅具有参数。

C++中的重载类型为：

  • 函数重载
  • 运算符重载

C++函数重载

函数重载定义为具有两个或多个具有相同名称但参数不同的函数的过程，在C++中称为函数重载。在函数重载，该函数通过使用不同类型的参数或者不同的数量的参数重新定义。只有通过这些差异，编译器才能区分功能。

函数重载的优点是它可以提高程序的可读性，因为您无需为同一操作使用不同的名称。

C++函数重载示例

让我们看一下函数重载的简单示例，其中我们要更改add()方法的参数数量。

//当参数数量变化时函数重载程序。

#include   
using namespace std;  
class Cal {  
    public:  
static int add(int a,int b){    
        return a + b;    
    }    
static int add(int a, int b, int c)    
    {    
        return a + b + c;    
    }    
};   
int main(void) {  
    Cal C;                                                    //     class object declaration. 
    cout<

输出：

30
55

让我们看一个简单的示例，其中参数的类型有所不同。

//使用不同类型的参数进行函数重载的程序。

#include
using namespace std;
int mul(int,int);
float mul(float,int);


int mul(int a,int b)
{
    return a*b;
}
float mul(double x, int y)
{
    return x*y;
}
int main()
{
    int r1 = mul(6,7);
    float r2 = mul(0.2,3); 
    std::cout << "r1 is : " <

输出：

r1 is : 42
r2 is : 0.6

函数重载和歧义

当编译器是无法决定哪些函数是重载函数中被调用，这种情况被称为函数重载。

当编译器显示歧义错误时，编译器不会运行该程序。

函数重载的原因：

  • 类型转换。
  • 具有默认参数的函数。
  • 通过引用传递功能。

  • 类型转换：

让我们看一个简单的例子。

#include
using namespace std;
void fun(int);
void fun(float);
void fun(int i)
{
    std::cout << "Value of i is : " <

上面的示例显示了一个错误“重载’fun(double)’的调用不明确”。 fun(10)将调用第一个函数。 fun(1.2)根据我们的预测调用第二个函数。但是，这并不像C++那样引用任何函数，所有浮点常量都被视为double而不是float。如果将float替换为double，该程序将起作用。因此，这是从float到double的类型转换。

  • 具有默认参数的功能

让我们看一个简单的例子。

#include
using namespace std;
void fun(int);
void fun(int,int);
void fun(int i)
{
    std::cout << "Value of i is : " <

上面的示例显示了一个错误“对重载的’fun(int)’的调用不明确”。 fun(int a，int b = 9)可以通过两种方式调用：第一种是通过使用一个参数调用函数(即fun(12))，另一种方法是通过两个参数调用函数，即fun(4) ，5)。 fun(int i)函数由一个参数调用。因此，编译器无法在fun(int i)和fun(int a，int b = 9)之间进行选择。

  • 通过引用传递功能

让我们看一个简单的例子。

#include 
using namespace std;
void fun(int);
void fun(int &); 
int main()
{
int a=10;
fun(a); // error, which f()?
return 0;
}
void fun(int x)
{
std::cout << "Value of x is : " <

上面的示例显示了一个错误“重载’fun(int＆)’的调用不明确”。第一个函数接受一个整数参数，第二个函数接受参考参数作为参数。在这种情况下，编译器不知道用户需要哪个函数，因为fun(int)和fun(int＆)之间没有语法上的区别。

C++运算符重载

运算符重载是一种编译时多态性，其中运算符被重载以为用户定义的数据类型提供特殊含义。运算符重载用于重载或重新定义C++中可用的大多数运算符。它用于对用户定义的数据类型执行操作。例如，C++提供了添加应用于内置数据类型的用户定义数据类型的变量的功能。

运算符重载的优点是对同一操作数执行不同的运算。

不能重载的运算符如下：

  • 范围运算符(：:)
  • 尺寸
  • 成员选择器(。)
  • 成员指针选择器(*)
  • 三元运算符(？:)

运算符重载的语法

return_type class_name  : : operator op(argument_list)
{
     // body of the function.
}

返回类型是函数返回的值的类型。

class_name是类的名称。

运算符OP是其中op被运算符过载运算符函数，并且运算符是关键字。

运算符重载规则

  • 现有运算符只能重载，而新运算符不能重载。
  • 重载的运算符包含用户定义数据类型的至少一个操作数。
  • 我们不能使用好友函数来重载某些运算符。但是，成员函数可用于重载那些运算符。
  • 通过成员函数重载一元运算运算符，不带任何显式参数，但是，如果一个友元函数重载一元运算符，则带一个参数。
  • 当二进制运算符通过成员函数重载时，将使用一个显式参数，如果它们通过朋友函数被重载，则将使用两个显式参数。

C++运算符重载示例

让我们看一下C++中运算符重载的简单示例。在此示例中，定义了void 运算符 ++()运算符函数(在Test类内部)。

//程序以重载一元运算运算符++。

#include   
using namespace std;  
class Test  
{  
   private:  
      int num;  
   public:  
       Test(): num(8){}  
       void operator ++()         {   
          num = num+2;   
       }  
       void Print() {   
           cout<<"The Count is: "<

输出：

The Count is: 10

让我们看一个简单的重载二元运算符的例子。

//程序以重载二进制运算符。

#include 
using namespace std;
class A
{
  
    int x;
      public:
      A(){}
    A(int i)
    {
       x=i;
    }
    void operator+(A);
    void display();
};

void A :: operator+(A a)
{
   
    int m = x+a.x;
    cout<<"The result of the addition of two objects is : "<

输出：

The result of the addition of two objects is : 9