函数重载（overload）

函数重载（overload）

先看一个例子

#include<iostream>
using namespace std;
//计算两个参数a,b的乘积的函数
int multiply(int a,int b){
return a*b;
}
//计算三个参数a,b,c的乘积的函数
int multiply(int a,int b,int c){
return a*b*c;
}
int main()
{
    cout<<multiply(1,2)<<endl;
    cout<<multiply(1,2,3)<<endl;
}

通过例子可以感受到，函数重载就是使用同一个函数名字，可以规定不同的参数数量和顺序和类型，不影响程序对函数的调用。

#include <iostream>
using namespace std;
int multiplyadd(int a,int b)
{return a*b;
}
int multiplyadd(int a,int b,int c){
return a+b+c;}

int main(int argc, char *argv[])
{
    cout<<multiplyadd(0,2)<<endl;
    cout<<multiplyadd(3,2,3)<<endl;

    return 0;
}

 

可以发现，即使是不同的运算规则也可以正确执行。
但是下面这几种情况是错误的

• 仅仅变化返回类型，不能满足函数重载的要求，因为在读入参数后，编译器并不能识别出来此时应该调用哪个函数。

#include <iostream>
using namespace std;

float multiply(int a,int b){
    return a*b;   //返回类型是float
}
int multiply(int a,int b){
    return a*b;
}

int main(int argc, char *argv[])
{
 cout<<multiply(1,2)<<endl;
 cout<<multiply(2,3)<<endl;
    return 0;
}

• 传入参数类型模糊，可以默认转换，则会导致运行错误

• 因为传入的参数是整数类型，但是也可以转换为long或者double，那么编译器仍然不能确定需要调用哪个函数，所以报错。#include <iostream>
  using namespace std;
  int multiply(float a,long b){
  return a*b;
  }
  int multiply(long a,float b){
  return a*b;
  }

  int main(int argc, char *argv[])
  {
    cout<<multiply(2,3)<<endl;
    cout<<multiply(3,2)<<endl;
      return 0;
  }
   

我们如果这样修改就会正确

#include <iostream>
using namespace std;
int add(int a,int b){
    return a+b;
}
float add(int a,float b){
    return a+b;
}

int main(int argc, char *argv[])
{
  cout<<add(1,2)<<endl;
  cout<<add(1,2.33f)<<endl;
    return 0;
}

我们可以看到，传入的参数(1，2)自动的找到了第一个加法函数，因为类型符合，所以执行加法运算为5。而第二组参数(1,2.33f)自动的找到了第二个函数，因为函数类型为 int和float，最终执行乘法运算，结果为3.33。

默认参数

在声明参数的时候可以默认参数值
还是先举一个例子

#include <iostream>
using namespace std;

void print(int a=2){
    cout << "int a is "<< a <<endl; 
}

int main(){
    print();
    print(1);
    getchar();
    return 0;
}

这里说一个关于声明函数的问题，我们可以先声明函数，然后把实现放在后面

#include <iostream>
using namespace std;

void print(int a=2);//事先对函数声明int main(){
    print();
    print(1);
    getchar();
    return 0;
}
//函数的实现放在了main()后面
void print(int a){
    cout << "int a is "<< a <<endl; 
}

这里注意一个问题，默认参数定义的位置只能在声明部分，在实现部分定义，会报错
我们看一下函数运行的结果

可以发现，第一次调用print()函数时，我们并没有传参数，但是由于已经默认了参数，所以直接调用不传参数没有问题，运行也会按照默认参数运行。如果，传入参数，就会更改默认参数值，比如我们print(1);最后就会运行这个参数得到的结果。
下面是一些关于默认参数的注意事项

 

• 默认参数的设置，应该从右开始

首先先写一个两个默认值的函数

#include <iostream>
using namespace std;
void print(int a=2,int b=3);
int main(int argc, char *argv[])
{
 print();
    return 0;
}
void print(int a,int b)
{
    cout<<a<<endl;
    cout<<b<<endl;
}

然后我们看一下如果只给一个变量赋予默认值应该如何操作

#include <iostream>
using namespace std;

void print(int a, int b=2);//默认参数的设置从右开始

int main(){
    print(1);
    getchar();
    return 0;
}

void print(int a,int b){
    cout << "int a is "<< a <<endl;
    cout << "int b is "<< b <<endl;
}

我们可以发现，print(1);中的参数1传给了a，而b的值仍然是默认值2。
但是如果这样写就是错误的

#include <iostream>
using namespace std;
//错误的默认参数设置
void print(int a=2, int b);//默认参数不能从左开始设置

int main(){
    print(1);
    getchar();
    return 0;
}

void print(int a,int b){
    cout << "int a is "<< a <<endl; 
    cout << "int b is "<< b <<endl; 
}

因为这时候编译器不能理解，你传入的print(1);中的1是覆盖变量a的默认参数2，还是赋给变量b，所以会报错。
当然下面这种写法也是错误的

#include <iostream>
using namespace std;

void print(int a=2, int b);//参数从左赋值

int main(){
    print(1,3);//虽然传入了两个参数，还是不可以，会报错
    getchar();
    return 0;
}

void print(int a,int b){
    cout << "int a is "<< a <<endl; 
    cout << "int b is "<< b <<endl; 
}
 

 

所以总的来说，默认参数的赋值只能从右往左。
参数两个以上也是一样的道理

#include <iostream>
using namespace std;

void print(int a, int b=3,int c =4);

int main(){
     print(2);
     return 0;
}

void print(int a,int b,int c){
    cout << "int a is "<< a <<endl;
    cout << "int b is "<< b <<endl;
    cout << "int c is "<< c <<endl;
}

• 还有我们刚才已经提醒过的问题，函数声明、实现分开时，默认参数只能放在声明部分
• 默认参数的值只能是常量，全局符号（全局变量和函数名）
  举个例子，比如我们事先定义了int con=5；

#include <iostream>
using namespace std;

int con=5;
void print(int a, int b=3,int c =con);

int main(){
    print(1);
    getchar();
    return 0;
}

void print(int a,int b,int c){
    cout << "int a is "<< a <<endl; 
    cout << "int b is "<< b <<endl; 
    cout << "int c is "<< c <<endl; 
}

 

我们下面讨论一下，函数名的问题，需要涉及指针

include <iostream>
using namespace std;

void print();//声明一个函数print()，print其实指代了这个函数所在的地址

int main(){
    void(*p_print)() = print;//把print所代表的函数print()的地址传给指针p_print
    p_print();//调用指针的地址中的函数print()
    getchar();
    return 0;
}

void print(){
    cout << "Hello World" <<endl; //函数的作用只是打印Hello World
}

我们再加入一个打印函数名字的函数

#include <iostream>
using namespace std;

void disp(void(*a)());//需要输入一个函数名字
void print();

int main(){
    disp(print);
    getchar();
    return 0;
}
//函数disp的作用是打印函数地址并且运行传入的函数
void disp(void(*a)()){
    cout<<"func address is "<<(void*)a<<endl;
    //这里需要说明，如果写成cout<<"func address is "<<a<<endl;
    //最后会输出func address is 1
    //原因是C++中的cout对象没有对函数指针作为输入参数的<<运算符重载。
    //函数把输入参数print当做bool量处理。
    a();
}

void print(){
    cout << "Hello World" <<endl; 
}
 

 

 

 

 

这里说一个关于声明函数的问题，我们可以先声明函数，然后把实现放在后面