函数重载的简单例子（什么叫函数重载）

本文目录

• 什么叫函数重载
• 写个重载->的例子
• 请举一个构造函数重载的例子给我看看
• C++中输入输出流运算符重载求个具体的例子，尽量简单点儿新手
• 什么是重载函数举例说明
• C++中函数重载是什么，能举个例子说明是如何重载的吗
• C++中是如何实现函数重载的

什么叫函数重载

函数重载是一个同名函数完成不同的功能，编译系统在编译阶段通过函数参数个数、参数类型不同，函数的返回值来区分该调用哪一个函数，即实现的是静态的多态性。但是记住：不能仅仅通过函数返回值不同来实现函数重载。

扩展资料

重载函数的多义性无法确定，直到遇到函数调用。 此时，将为函数调用中的每个参数生成集，并且可以确定是否存在明确的重载。 这意味着，多义性可保持在您的代码中，直到它们由特定函数调用引发。

参数类型差异

重载函数区分使用不同的初始值设定项的参数类型。 因此，对于重载而言，给定类型的参数和对该类型的引用将视为相同。 由于它们采用相同的初始值设定项，因此它们被视为是相同的。 例如，max( double, double ) 被视为与 max( double &, double & ) 相同。 声明两个此类函数会导致错误。

出于同一原因，对由 const 或 volatile 修改的类型的函数参数（出于重载的目的）的处理方式与基类没有什么不同。

但是，函数重载机制可以区分由 const 和 volatile 限定的引用和对基类型的引用。

写个重载->的例子

#include 《iostream》
using namespace std;
struct node{
int d;
node(int d): d(d){}
};
class A{
node *n;
public:
A(): n(new node(123)){}
node *operator -》(){
return n;
}
};
int main(){
A a;
cout 《《 a-》d 《《 endl;
}

将打印 123

这例子不仅体现了operator -》的重载，同时也体现了指针的危险，破坏了封装性。n是A的私有成员，但有了指针后仍然可以访问。

请举一个构造函数重载的例子给我看看

public AppMain()
{
InitializeComponent();
}
上面这个是普通的构造
下面这个是带参数的重载构造
public AppMain(string str)
{
InitializeComponent();
}

C++中输入输出流运算符重载求个具体的例子，尽量简单点儿新手

 
class Point 
{ 
private: 
       int x;
public: 
       Point(int x1)
       {    x=x1;}
       friend ostream& operator《《(ostream& cout,const Point& p);//使用友元函数重载《《输出运算符
       friend istream& operator》》(istream& cin,Point& p);//使用友元函数重载》》输出运算符
}; 
ostream& operator《《(ostream& cout,const Point& p)
{
       cout《《p.x《《endl;
       return cout;
}
istream& operator》》(istream& cin,Point& p)
{
       cin》》p.x;
       return cin;
}
 
调用： 
 void main()
{
Point a(1); 
Point b(2); 
cin》》a》》b; 
cout《《a《《b《《endl;
}

什么是重载函数举例说明

所谓函数重载是指同一个函数名可以对应着多个函数的实现。例如，可以给函数名add()定义多个函数实现，该函数的功能是求和，即求两个操作数的和。其中，一个函数实现是求两个int型数之和，另一个实现是求两个浮点型数之和，再一个实现是求两个复数的和。每种实现对应着一个函数体，这些函数的名字相同，但是函数的参数的类型不同。这就是函数重载的概念。函数重载在类和对象的应用尤其重要。
函数重载要求编译器能够唯一地确定调用一个函数时应执行哪个函数代码，即采用哪个函数实现。确定函数实现时，要求从函数参数的个数和类型上来区分。这就是说，进行函数重载时，要求同名函数在参数个数上不同，或者参数类型上不同。否则，将无法实现重载。
参数类型上不同的重载函数
下面举一个在参数类型不同的重载函数的例子：
#include 《iostream.h》
int add(int, int);
double add(double, double);
void main()
{
cout《《add(5, 10)《《endl;
cout《《add(5.0, 10.5)endl;
}
int add(int x, int y)
{
return x+y;
}
double add(double a, double b)
{
return a+b;
}
该程序中，main()函数中调用相同名字add的两个函数，前边一个add()函数对应的是两个int型数求和的函数实现，而后边一个add()函数对应的是两个double型数求和的函数实现。这便是函数的重载。
以上程序输出结果为：
15
15.5
参数个数上不同的重载函数
下面举一个在参数个数上不相同的重载函数的例子：
#include 《iostream.h》
int min(int a, int b);
int min(int a, int b, int c);
int min(int a, int b, int c, int d);
void main()
{
cout《《min(13, 5, 4, 9)《《endl;
cout《《min(-2, 8, 0)《《endl;
}
int min(int a, int b)
{
return a《b?a:b;
}
int min(int a, int b, int c)
{
int t = min(a, b);
return min(t,c);
}
int min(int a, int b, int c, int d)
{
int t1 = min(a, b);
int t2 = min(c, d);
return min(t1, t2);
}
该程序中出现了函数重载，函数名min对应有三个不同的实现，函数的区分依据参数个数不同，这里的三个函数实现中，参数个数分别为2,3和4，在调用函数时根据实参的个数来选取不同的函数实现。

C++中函数重载是什么，能举个例子说明是如何重载的吗

函数重载：

C++允许定义多个同名函数，但是参数不能相同，必须满足以下条件之一

1，参数类型不同

2，参数数量不同              比如：

int fun(int,int);
int fun(long,int);             //类型不同
int fun(int);                  //数量不同

这样三个函数实现了重载，编译器会认为是三个不同的函数

PS：返回值类型不同，参数相同，是不能重载的

C++中是如何实现函数重载的

函数重载，简单来说 就是一个函数名称，但是有多个函数定义，它们是通过函数参数来区分的，
比如
int A() { } // 函数定义1
int A(int p) { } // 函数定义2，参数 和 定义1不一样，视为重载

实际上，C++ 的函数重载比较复杂，因为这涉及到了 C++ 隐晦的类型 转换问题，深入之后自然会碰到（不过也不必担心，通常不会碰到这个问题，除非应聘工作时哪些主考官们可能会考考这类问题)。
至于 C++ 编译器怎么实现函数重载的，这主要通过 一种 叫 Name-mangling 的技术，这种技术在编译器编译函数时，根据函数参数、参数类型 参数个数 等信息， 悄悄地改写函数名字，当然改写后的名字是供编译器使用的，程序员往往不可见的。
如果你不需要在 C++中使用 Name-mangling 技术，必须 在 函数 前面 加上 extern "C" ， 表示不使用 Name-mangling 技术，这也就是 为什么 前面有 extern "C" 声明的
函数 不能重载的原因
extern "C" int A() { }
extern "C" int A(int p) { } //编译错误，