详解C++中的内联函数和函数重载

内联函数（内嵌函数，内置函数）

调用函数时需要一定的时间和空间的开销。C++提供一种提高效率的方法，即在编译时将函数调用处用函数体替换，类似于C语言中的宏展开。这种在函数调用处直接嵌入函数体的函数称为内联函数（inline function），又称内嵌函数或内嵌函数。

指定内联函数的方法很简单，只需要在定义函数时增加 inline 关键字。

注意：是在函数定义时增加 inline 关键字，而不是在函数声明时。在函数声明时增加 inline 关键虽然没有错误，但是也没有任何效果

inline 关键字放在函数声明处不会起作用：

inline void swap(int &a, int &b);
void swap(int &a, int &b)
{
  int temp = a;
  a = b;
  b = temp;
}
inline 关键字应该与函数体放在一起：
void swap(int &a, int &b);
inline void swap(int &a, int &b)
{
  int temp = a;
  a = b;
  b = temp;
}

采用内联函数可以有效避免函数调用的开销，程序执行效率更高。使用内联函数的缺点就是，如果被声明为内联函数的函数体非常大，则编译器编译后程序的可执行码将会变得很大。

另外，如果函数体内出现循环或者其它复杂的控制结构的时候，这个时候处理这些复杂控制结构所花费的时间远大于函数调用所花的时间，因此如果将这类函数声明为内联函数意义不大，反而会使得编译后可执行代码变长。

通常在程序设计过程中，我们会将一些频繁被调用的短小函数声明为内联函数。

应当说明：对函数作inline声明，只是程序员对编译系统提出的一个建议，也就是说它是建议性的，而不是指令性的。并非一经指定为inline，编译系统就必须这样做。编译系统会根据具体情况决定是否这样做。

一个完整的示例：

#include <iostream>
using namespace std;
int max(int, int, int); //函数声明，左端也可以加inline
int main( )
{
  int i=10, j=20, k=30, m;
  m = max(i, j, k);
  cout<<"max="<<m<<endl;
  return 0;
}
inline int max(int a, int b, int c) //定义max为内联函数
{
  if(b>a) a=b;
  if(c>a) a=c;
  return a;
}

运行结果：

max=30

由于在定义函数时指定它为内置函数，因此编译系统在遇到函数调用“max(i, j, k)”时，就用max函数体的代码代替“max(i,j, k)”，同时将实参代替形参。这样，程序第6行 “m=max(i, j, k);”就被置换成：

  if (j>i) i=j;
  if(k>i) i=k;
  m=i;

函数重载

在编程时，有时我们要实现的是同一类的功能，只是有些细节不同。例如希望从3个数中找出其中的最大者，而每次求最大数时数据的类型不同，可能是3个整数、3个双精度数或3个长整数。程序设计者往往会分别设计出3个不同名的函数，其函数原型为：

  int max1(int a, int b, int c); //求3个整数中的最大者
  double max2(double a, double b, double c); //求3个双精度数中最大者
  long max3(long a, long b, long c); //求3个长整数中的最大者

C++允许用同一函数名定义多个函数，这些函数的参数个数和参数类型不同。这就是函数的重载(function overloading)。即对一个函数名重新赋予它新的含义，使一个函数名可以多用。

对上面求最大数的问题可以编写如下的C++程序。

【例】求3个数中最大的数(分别考虑整数、双精度数、长整数的情况)。

#include <iostream>
using namespace std;
int main( )
{
  int max(int a,int b,int c); //函数声明
  double max(double a,double b,double c); //函数声明
  long max(long a,long b,long c);//函数声明
  int i1,i2,i3,i;
  cin>>i1>>i2>>i3; //输入3个整数
  i=max(i1,i2,i3); //求3个整数中的最大者
  cout<<"i_max="<<i<<endl;
  double d1,d2,d3,d;
  cin>>d1>>d2>>d3; //输入3个双精度数
  d=max(d1,d2,d3); //求3个双精度数中的最大者
  cout<<"d_max="<<d<<endl;
  long g1,g2,g3,g;
  cin>>g1>>g2>>g3; //输入3个长整数
  g=max(g1,g2,g3); //求3个长整数中的最大者
  cout<<"g_max="<<g<<endl;
}
int max(int a,int b,int c) //定义求3个整数中的最大者的函数
{
  if(b>a) a=b;
  if(c>a) a=c;
  return a;
}
double max(double a,double b,double c)//定义求3个双精度数中的最大者的函数
{
  if(b>a) a=b;
  if(c>a) a=c;
  return a;
}
long max(long a,long b,long c) //定义求3个长整数中的最大者的函数
{
  if(b>a) a=b;
  if(c>a) a=c;
  return a;
}

运行情况如下：

185-76567 (输入3个整数)
56.87 90.23 -3214.78 (输入3个实数)
67854 -912456 673456 (输入3个长整数)
i_max=567 (输出3个整数的最大值)
d_max=90.23 (输出3个双精度数的最大值)
g_max=673456 (输出3个长整数的最大值)

上例3个max函数的函数体是相同的。

其实重载函数并不要求函数体相同；除了允许参数类型不同以外，还允许参数的个数不同。

【例】编写一个程序，用来求两个整数或3个整数中的最大数。如果输入两个整数，程序就输出这两个整数中的最大数，如果输入3个整数，程序就输出这3个整数中的最大数。

#include <iostream>
using namespace std;
int main( )
{
  int max(int a,int b,int c); //函数声明
  int max(int a,int b); //函数声明
  int a=8,b=-12,c=27;
  cout<<"max(a,b,c)="<<max(a,b,c)<<endl;//输出3个整数中的最大者
  cout<<"max(a,b)="<<max(a,b)<<endl; //输出两个整数中的最大者
}
int max(int a,int b,int c)//此max函数的作用是求3个整数中的最大者
{
  if(b>a) a=b;
  if(c>a) a=c;
  return a;
}
int max(int a,int b)//此max函数的作用是求两个整数中的最大者
{
  if(a>b) return a;
  else return b;
}

运行情况如下：

max(a, b, c)=27
max(a, b)=8

两次调用max函数的参数个数不同，系统就根据参数的个数找到与之匹配的函数并调用它。

参数的个数和类型可以都不同。但不能只有函数的类型不同而参数的个数和类型相同。例如：

  int f(int); //函数返回值为整型
  long f(int); //函数返回值为长整型
  void f(int); //函数无返回值

在函数调用时都是同一形式，如“f(10)”。编译系统无法判别应该调用哪一个函数。重载函数的参数个数、参数类型或参数顺序3者中必须至少有一种不同，函数返回值类型可以相同也可以不同。

在使用重载函数时，同名函数的功能应当相同或相近，不要用同一函数名去实现完全不相干的功能，虽然程序也能运行，但可读性不好，使人莫名其妙。