C++重载（函数和运算符）

本文概述

• C ++中的重载类型为
• C ++函数重载
• C ++函数重载示例
• 函数重载和歧义
• C ++运算符重载
• 运算符重载的语法
• 运算符重载规则
• C ++运算符重载示例

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

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

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

C ++中的重载类型为

• 函数重载
• 运算符重载

C ++函数重载

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

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

C ++函数重载示例

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

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

#include <iostream>  
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<<C.add(10, 20)<<endl;    
    cout<<C.add(12, 20, 23);   
   return 0;  
}

输出：

30
55

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

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

#include<iostream>
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<< std::endl;
    std::cout <<"r2 is : "  <<r2<< std::endl;
    return 0;
}

输出：

r1 is : 42
r2 is : 0.6

函数重载和歧义

当编译器无法确定重载函数中要调用哪个函数时, 这种情况称为函数重载。

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

函数重载的原因：

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

• 类型转换：

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

#include<iostream>
using namespace std;
void fun(int);
void fun(float);
void fun(int i)
{
    std::cout << "Value of i is : " <<i<< std::endl;
}
void fun(float j)
{
    std::cout << "Value of j is : " <<j<< std::endl;
}
int main()
{
    fun(12);
    fun(1.2);
    return 0;
}

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

• 具有默认参数的功能

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

#include<iostream>
using namespace std;
void fun(int);
void fun(int, int);
void fun(int i)
{
    std::cout << "Value of i is : " <<i<< std::endl;
}
void fun(int a, int b=9)
{
    std::cout << "Value of a is : " <<a<< std::endl;
    std::cout << "Value of b is : " <<b<< std::endl;
}
int main()
{
    fun(12);
 
    return 0;
}

上面的示例显示了一个错误“重载’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 <iostream>
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 : " <<x<< std::endl;
}
void fun(int &b)
{
std::cout << "Value of b is : " <<b<< std::endl;
}

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

C ++运算符重载

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

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

不能重载的运算符如下：

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

运算符重载的语法

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

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

class_name是类的名称。

operator op是一个运算符函数, 其中op是重载的运算符, 而operator是关键字。

运算符重载规则

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

C ++运算符重载示例

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

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

#include <iostream>  
using namespace std;  
class Test  
{  
   private:  
      int num;  
   public:  
       Test(): num(8){}  
       void operator ++()         {   
          num = num+2;   
       }  
       void Print() {   
           cout<<"The Count is: "<<num;   
       }  
};  
int main()  
{  
    Test tt;  
    ++tt;  // calling of a function "void operator ++()"  
    tt.Print();  
    return 0;  
}

输出：

The Count is: 10

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

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

#include <iostream>
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 : "<<m;

}
int main()
{
    A a1(5);
    A a2(4);
    a1+a2;
    return 0;
}

输出：

The result of the addition of two objects is : 9