C++ 函数重载

1.普通函数的重载，我们可以将一个名字相同的但是不同类型的函数重复调用多次，来处理不同类型的数据。

#include <iostream>
using namespace std;
void func(int); //声明一个无返回值并且带有一个整型参数的func函数
void func(long); //声明一个无返回值并且带有一个长整型参数的func函数
void func(float); //声明一个无返回值并且带有一个浮点型参数的func函数
void func(double); //声明一个无返回值并且带有一个双精度型参数的func函数
void main()
{
int a=1; //定义一个整型变量a并将它的值赋为1
long b=100000; //定义一个长整型变量b并将它的值赋为100000
float c=1.5; //定义一个浮点型变量c并将它的值赋为1.5
double d=6.45679; //定义一个双精度型变量d并将它的值赋为6.45679
cout<<"a:"<<a<<endl; //输出整型变量a的值
cout<<"b:"<<b<<endl; //输出长整型变量b的值
cout<<"c:"<<c<<endl; //输出浮点型变量c的值
cout<<"d:"<<d<<endl; //输出双精度型变量d的值
func(a); //调用func并将整型变量a传递给它，编译器会根据参数a
                                     //的类型自动判断调用哪个函数
func(b); //调用func并将长整型变量b传递给它，编译器会根据参数b
                                     //的类型自动判断调用哪个函数
func(c); //调用func并将浮点型变量c传递给它，编译器会根据参数c
                                     //的类型自动判断调用哪个函数
func(d); //调用func并将双精度型变量d传递给它，编译器会根据参数d
                                     //的类型自动判断调用哪个函数
}
void func(int a){cout<<"a的平方为:"<<a*a<<endl;}  
     //带一个整型参数的func函数的定义部分
void func(long b){cout<<"b的平方为:"<<b*b<<endl;}  
     //带一个长整型参数的func函数的定义部分
void func(float c){cout<<"c的平方为:"<<c*c<<endl;}
     //带一个浮点参数的func 函数的定义部分
void func(double d){cout<<"d的平方为:"<<d*d<<endl;}
     //带一个双精度参数的func函数定义部分

2.成员函数的重载

#include <iostream>
using namespace std;
class cube //声明一个cube类
{
public:
void sum() //定义一个没有返回值并且不带参数的成员函数sum
{
cout<<"i的立方:"<<i*i*i<<"\t"<<"j的立方:"<<j*j*j<<endl;
//该函数的功能是输出i和j的立方
}
void sum(int x,int y)
{ //定义一个没有返回值并且带两个整型参数的成员函数sum
i=x;j=y;
cout<<"i:"<<i<<"\t\t"<<"j:"<<j<<endl;
} //该函数的作用是接收两个整型参数并且将它们赋给私有成员i和j，然后输出i和j
private:
int i; //私有成员变量i
int j; //私有成员变量j
};
void main()
{
cube a; //声明一个cube类的对象a
a.sum(2,3);    //用该对象调用带两个整型参数的sum成员函数
a.sum(); //用该对象调用不带参数的sum成员函数
}

3.函数的默认参数

在定义某个函数时，将它的参数也初始化，那么这个或者这个参数就是该函数的默认参数，又称为缺省参数。

/*函数的默认值
#include <iostream>
using namespace std;
void func(int=0,int=0);
void main()
{
  func(); //调用带默认参数的函数func
  func(3,5); //调用func函数的同时给它的两个参数赋了3和5两个值
}
void func(int x,int y){cout<<"x:"<<x<<"\t"<<"y:"<<y<<endl;}
*/

类的成员函数也可以拥有一个或者多个默认值。

//成员函数的默认值，其例程如下：
#include <iostream>
using namespace std;
class A
{
public:
void set(int=30,int=5); //set函数有两个整型参数，默认值为30和5
void count(bool =false); //count函数有一个布尔参数，默认值为false，也就是为假
private:
int w;
int h;
};
void A::set(int  width, int height){w=width;h=height;}
//set函数定义部分将两个参数的值赋给私有成员变量w和h
void A::count(bool val)   //count函数的定义部分
{
if(val==true)   //假如布尔参数的值为真
{
cout<<"val的值为真时:"<<w*h<<endl; //输出私有成员变量w与h相乘的结果
}
else             //否则，也就是布尔参数的值为假时
{
cout<<"val的值为假时:"<<w*h/2<<endl;//输出私有成员变量w与h相乘再与2相除的结果
}
}
void main()
{
A a;
a.set(); //用对象a来访问默认set函数
a.count(); //用对象a来访问默认count函数
a.count(1); //用对象a来访问布尔参数被赋为1的count函数，
                                    //当然这里你也可以用count(true)来代替
}

具有默认参数的函数和重载函数的区别：

1.重载函数使用方便，易于理解。默认参数的函数如果不叫标注很容易被忽略，而且容易被具有参数的同名函数覆盖。

2.具有默认参数的函数重载的是参数的数值，而重载函数重载的是参数的类型。