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;
}
输出:
当参数的类型变化时，让我们看一个简单的例子。
//使用不同类型的参数的函数重载程序。
#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;
}
输出:
函数重载和歧义
当编译器无法确定重载函数中要调用哪个函数时，这种情况称为函数重载 strong>。
当编译器显示歧义错误时，编译器不会运行该程序。
函数重载的原因:
类型转换。
具有默认参数的函数。
通过引用传递的功能。
类型转换:
让我们看一个简单的示例。
#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++提供了添加应用于内置数据类型的用户定义数据类型的变量的功能。
运算符重载的优点是对同一个操作数执行不同的操作。
不能重载的运算符如下:
范围运算符(::)
Sizeof
成员选择器(。)
成员指针选择器(*)
三元运算符(？:)
运算符重载语法
return_type class_name : : operator op(argument_list)
{
// body of the function.
}
返回类型是函数返回的值的类型。
class_name 是该类的名称。
operator op 是一个运算符，其中op是重载的运算符，
运算符重载规则
现有操作符只能重载，而新操作符不能重载。
重载的运算符包含用户定义的数据类型的至少一个操作数。
我们不能使用friend函数来重载某些运算符。但是，成员函数可用于重载那些运算符。
一元运算符通过成员函数重载时，不带任何显式参数，但是，如果它们由友元函数重载时，则带一个参数。
当二进制运算符通过成员函数重载时，将使用一个显式参数，如果它们通过朋友函数被重载，则将使用两个显式参数。
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;
}
输出:
让我们看一个简单的重载二元运算符的例子。
//程序中重载二元运算符。
#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
