C++ 函数重载

简而言之，面向对象编程是C++中的一个概念（也被称为OOPS）。我们将讨论OOPS中的各种特性中的函数重载。每种编程语言都提供了通过使用函数来重用以前编写的代码的能力。通常，由程序员根据函数的定义决定提供给函数的参数的数量和类型。函数重载是编程语言的进一步特性，它在函数方面实现了OOPS的思想。它指的是具有相同名称但不同参数的许多函数的可能性。

当发生函数重载时，两个或多个函数可能具有相同的名称，但参数列表不同。这是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 <iostream>
using namespace std;
void add(int a, int b)
{
cout << "sum = " << (a + b);
}
void add(double a, double b)
{
    cout << endl << "sum = " << (a + b);
}
int main()
{
    add(10, 2);
    add(5.3, 6.2);
           return 0;
}

输出：

在上述示例中，我们可以看到有两个函数被定义为一段代码。函数的名字相同——”addPodium”，但是返回类型、输入参数列表和这些参数的数据类型已经改变。

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

// 带有不同类型参数的函数重载示例。

#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 是：42
r2 是：0.6  

函数重载和二义性

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

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

函数重载的原因：

• 类型转换。
• 带有默认参数的函数。
• 引用传递的函数。

类型转换：

看一个简单的示例

#include
using namespace std;
void fun(int);
void fun(float);
void fun(int i)
{
    std::cout << "i的值是：" << i << std::endl;
}
void fun(float j)
{
    std::cout << "j的值是：" << j << std::endl;
}
int main()
{
    fun(12);
    fun(1.2);
    return 0;
}

上面的示例显示了一个错误“call of overloaded ‘fun(double)’ is ambiguous”。 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 << "i的值为： " <<i<< std::endl;  
}  
void fun(int a,int b=9)  
{  
    std::cout << "a的值为： " <<a<< std::endl;  
    std::cout << "b的值为： " <<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 
using namespace std;
void fun(int);
void fun(int&);
int main()
{
    int a=10;
    fun(a); // 错误，那个f()？
    return 0;
}
void fun(int x)
{
    std::cout << "x的值是：" << x << std::endl;
}
void fun(int &b;)
{
    std::cout << "b的值是：" << b << std::endl;
}

上面的示例显示了一个错误“ 调用选择性多载 ‘fun(int &)’ 是模棱两可的 ”。第一个函数接受一个整数参数，第二个函数接受引用参数作为参数。在这种情况下，编译器无法确定用户需要哪个函数。

为什么C++要使用函数重载

相较于传统的结构化编程语言，面向对象编程的思想提供了许多好处。函数重载被视为编译时多态性。借助这个面向对象的思想，程序员可以创建具有相同名称但执行模式不同的函数，从而使代码更易于理解和重复使用。

C++函数重载的规则有哪些

C++中，当对函数进行重载时，必须遵守一些准则。让我们仔细看一下其中的一些：

1）每个函数的参数必须按照不同的顺序。

2）函数的名称必须相同。

3）函数的参数必须不同。

4）函数的参数必须是各种类型。

C++中的函数重载有哪些类型

在C++中，有两种类型的函数重载。它们是

1）在编译时重载，当使用替代签名来重载函数时发生。函数的返回类型、参数的数量和类型都被视为函数的签名。

2）在运行时发生重载，指的是函数的重载。运行时重载发生在执行过程中向函数添加不同数量的参数。

C++中函数重载的优点是什么

以下是C++中函数重载的一些好处。

1）通过使用函数重载，程序员可以创建具有不同目的但名称相同的函数。

2) 它加快了程序的执行速度。

3) 代码更清晰简单易理解。

4) 它减少了内存利用并使程序可重用。

C++中函数重载的缺点是什么

以下是C++函数重载的一些缺点。

1) 函数重载的主要缺点是它阻止了具有不同返回类型的函数的重载。

2) 在静态函数的情况下，无法重载具有相同参数的函数。

函数重载和运算符重载有什么区别

函数重载和函数重写之间的区别是什么